highlighting-kate 0.3.1 → 0.4

raw patch · 118 files changed

+17153/−21009 lines, 118 filesdep +blaze-htmldep +mtldep −xhtmlPVP ok

version bump matches the API change (PVP)

Dependencies added: blaze-html, mtl

Dependencies removed: xhtml

API changes (from Hackage documentation)

Files

• BUGS +0/−3
• Highlight.hs +79/−35
• ParseSyntaxFiles.hs +160/−137
• README +4/−9
• Text/Highlighting/Kate.hs +25/−17
• Text/Highlighting/Kate/Common.hs +129/−115
• Text/Highlighting/Kate/Definitions.hs +0/−37
• Text/Highlighting/Kate/Format.hs +0/−95
• Text/Highlighting/Kate/Format/HTML.hs +127/−0
• Text/Highlighting/Kate/Format/LaTeX.hs +125/−0
• Text/Highlighting/Kate/Styles.hs +140/−0
• Text/Highlighting/Kate/Syntax.hs +25/−16
• Text/Highlighting/Kate/Syntax.hs.in +23/−6
• Text/Highlighting/Kate/Syntax/Actionscript.hs +108/−124
• Text/Highlighting/Kate/Syntax/Ada.hs +76/−88
• Text/Highlighting/Kate/Syntax/Alert.hs +27/−38
• Text/Highlighting/Kate/Syntax/Alert_indent.hs +27/−38
• Text/Highlighting/Kate/Syntax/Apache.hs +73/−91
• Text/Highlighting/Kate/Syntax/Asn1.hs +33/−44
• Text/Highlighting/Kate/Syntax/Asp.hs +214/−237
• Text/Highlighting/Kate/Syntax/Awk.hs +55/−68
• Text/Highlighting/Kate/Syntax/Bash.hs +668/−727
• Text/Highlighting/Kate/Syntax/Bibtex.hs +96/−113
• Text/Highlighting/Kate/Syntax/Boo.hs +190/−216
• Text/Highlighting/Kate/Syntax/C.hs +161/−181
• Text/Highlighting/Kate/Syntax/Changelog.hs +35/−48
• Text/Highlighting/Kate/Syntax/Clojure.hs +88/−102
• Text/Highlighting/Kate/Syntax/Cmake.hs +78/−94
• Text/Highlighting/Kate/Syntax/Coffeescript.hs +127/−148
• Text/Highlighting/Kate/Syntax/Coldfusion.hs +232/−262
• Text/Highlighting/Kate/Syntax/Commonlisp.hs +81/−96
• Text/Highlighting/Kate/Syntax/Cpp.hs +175/−195
• Text/Highlighting/Kate/Syntax/Cs.hs +100/−114
• Text/Highlighting/Kate/Syntax/Css.hs +187/−216
• Text/Highlighting/Kate/Syntax/D.hs +449/−497
• Text/Highlighting/Kate/Syntax/Diff.hs +123/−143
• Text/Highlighting/Kate/Syntax/Djangotemplate.hs +338/−387
• Text/Highlighting/Kate/Syntax/Doxygen.hs +287/−329
• Text/Highlighting/Kate/Syntax/Doxygenlua.hs +0/−369
• Text/Highlighting/Kate/Syntax/Dtd.hs +94/−110
• Text/Highlighting/Kate/Syntax/Eiffel.hs +45/−57
• Text/Highlighting/Kate/Syntax/Email.hs +141/−152
• Text/Highlighting/Kate/Syntax/Erlang.hs +73/−88
• Text/Highlighting/Kate/Syntax/Fortran.hs +246/−276
• Text/Highlighting/Kate/Syntax/Fsharp.hs +156/−176
• Text/Highlighting/Kate/Syntax/Gnuassembler.hs +79/−94
• Text/Highlighting/Kate/Syntax/Go.hs +72/−86
• Text/Highlighting/Kate/Syntax/Haskell.hs +90/−102
• Text/Highlighting/Kate/Syntax/Haxe.hs +87/−102
• Text/Highlighting/Kate/Syntax/Html.hs +239/−276
• Text/Highlighting/Kate/Syntax/Ilerpg.hs +0/−565
• Text/Highlighting/Kate/Syntax/Ini.hs +50/−63
• Text/Highlighting/Kate/Syntax/Java.hs +125/−145
• Text/Highlighting/Kate/Syntax/Javadoc.hs +174/−192
• Text/Highlighting/Kate/Syntax/Javascript.hs +157/−179
• Text/Highlighting/Kate/Syntax/Json.hs +91/−107
• Text/Highlighting/Kate/Syntax/Jsp.hs +336/−368
• Text/Highlighting/Kate/Syntax/Latex.hs +736/−802
• Text/Highlighting/Kate/Syntax/Lex.hs +148/−178
• Text/Highlighting/Kate/Syntax/LiterateHaskell.hs +54/−70
• Text/Highlighting/Kate/Syntax/Lua.hs +119/−140
• Text/Highlighting/Kate/Syntax/Makefile.hs +100/−120
• Text/Highlighting/Kate/Syntax/Mandoc.hs +44/−57
• Text/Highlighting/Kate/Syntax/Matlab.hs +75/−87
• Text/Highlighting/Kate/Syntax/Maxima.hs +57/−70
• Text/Highlighting/Kate/Syntax/Mediawiki.hs +0/−221
• Text/Highlighting/Kate/Syntax/Metafont.hs +172/−191
• Text/Highlighting/Kate/Syntax/Mips.hs +63/−75
• Text/Highlighting/Kate/Syntax/Modula2.hs +55/−70
• Text/Highlighting/Kate/Syntax/Modula3.hs +68/−82
• Text/Highlighting/Kate/Syntax/Monobasic.hs +123/−135
• Text/Highlighting/Kate/Syntax/Nasm.hs +66/−78
• Text/Highlighting/Kate/Syntax/Noweb.hs +58/−72
• Text/Highlighting/Kate/Syntax/Objectivec.hs +96/−111
• Text/Highlighting/Kate/Syntax/Objectivecpp.hs +196/−217
• Text/Highlighting/Kate/Syntax/Ocaml.hs +151/−171
• Text/Highlighting/Kate/Syntax/Octave.hs +128/−140
• Text/Highlighting/Kate/Syntax/Pascal.hs +84/−104
• Text/Highlighting/Kate/Syntax/Perl.hs +844/−919
• Text/Highlighting/Kate/Syntax/Php.hs +216/−242
• Text/Highlighting/Kate/Syntax/Pike.hs +103/−120
• Text/Highlighting/Kate/Syntax/Postscript.hs +45/−57
• Text/Highlighting/Kate/Syntax/Prolog.hs +64/−78
• Text/Highlighting/Kate/Syntax/Python.hs +200/−227
• Text/Highlighting/Kate/Syntax/R.hs +120/−137
• Text/Highlighting/Kate/Syntax/Relaxngcompact.hs +46/−60
• Text/Highlighting/Kate/Syntax/Rhtml.hs +1234/−1342
• Text/Highlighting/Kate/Syntax/Ruby.hs +1009/−1096
• Text/Highlighting/Kate/Syntax/Scala.hs +112/−128
• Text/Highlighting/Kate/Syntax/Scheme.hs +124/−146
• Text/Highlighting/Kate/Syntax/Sci.hs +46/−57
• Text/Highlighting/Kate/Syntax/Sed.hs +332/−368
• Text/Highlighting/Kate/Syntax/Sgml.hs +49/−64
• Text/Highlighting/Kate/Syntax/Sql.hs +81/−95
• Text/Highlighting/Kate/Syntax/SqlMysql.hs +104/−119
• Text/Highlighting/Kate/Syntax/SqlPostgresql.hs +107/−124
• Text/Highlighting/Kate/Syntax/Tcl.hs +75/−88
• Text/Highlighting/Kate/Syntax/Texinfo.hs +52/−67
• Text/Highlighting/Kate/Syntax/Verilog.hs +111/−130
• Text/Highlighting/Kate/Syntax/Vhdl.hs +262/−297
• Text/Highlighting/Kate/Syntax/Xharbour.hs +0/−174
• Text/Highlighting/Kate/Syntax/Xml.hs +155/−184
• Text/Highlighting/Kate/Syntax/Xorg.hs +67/−82
• Text/Highlighting/Kate/Syntax/Xslt.hs +217/−249
• Text/Highlighting/Kate/Syntax/Xul.hs +264/−303
• Text/Highlighting/Kate/Syntax/Yacc.hs +148/−179
• Text/Highlighting/Kate/Syntax/Yaml.hs +215/−241
• Text/Highlighting/Kate/Types.hs +137/−0
• changelog +92/−0
• highlighting-kate.cabal +13/−19
• xml/doxygenlua.xml +0/−481
• xml/doxygenlua.xml.bkp +481/−0
• xml/haskell.xml +9/−3
• xml/ilerpg.xml +0/−725
• xml/lua.xml +2/−3
• xml/lua.xml.bkp +304/−0
• xml/mediawiki.xml +0/−98
• xml/xharbour.xml +0/−543

@@ -1,3 +0,0 @@-Known bugs:--

@@ -1,65 +1,73 @@-{-# LANGUAGE CPP #-}+{-# LANGUAGE CPP, OverloadedStrings #-} module Main where import Text.Highlighting.Kate import System.IO (hPutStrLn, stderr) import System.Environment-import Text.XHtml.Transitional import System.Console.GetOpt import System.Exit import System.FilePath (takeFileName) import Data.Maybe (listToMaybe) import Data.Char (toLower)+import Text.Blaze.Renderer.String+import Text.Blaze+import qualified Text.Blaze.Html5 as H+import qualified Text.Blaze.Html5.Attributes as A -data Flag = CssPath String+data Flag = Sty String+          | Format String           | Help           | Fragment           | List           | NumberLines           | Syntax String-          | Detailed           | TitleAttributes           | Version           deriving (Eq, Show)  options :: [OptDescr Flag] options =-  [ Option ['c'] ["css"] (ReqArg CssPath "PATH") "link CSS file"+  [ Option ['S'] ["style"] (ReqArg Sty "STYLE") "specify style"+  , Option ['F'] ["format"] (ReqArg Format "FORMAT")  "output format (html|latex)"   , Option ['f'] ["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 Syntax "SYNTAX")  "specify language syntax to use"-  , Option ['d'] ["details"] (NoArg Detailed) "include detailed lexical information in classes"   , Option ['t'] ["title-attributes"] (NoArg TitleAttributes)  "include structure in title attributes"   , Option ['v'] ["version"] (NoArg Version)   "print version"   ] -cssPathOf :: [Flag] -> Maybe String-cssPathOf [] = Nothing-cssPathOf (CssPath s : _) = Just s-cssPathOf (_:xs) = cssPathOf xs- syntaxOf :: [Flag] -> Maybe String syntaxOf [] = Nothing syntaxOf (Syntax s : _) = Just s syntaxOf (_:xs) = syntaxOf xs +styleOf :: [Flag] -> Maybe Style+styleOf [] = Nothing+styleOf (Sty s : _) = case map toLower s of+                            "pygments"   -> Just pygments+                            "espresso"   -> Just espresso+                            "kate"       -> Just kate+                            "tango"      -> Just tango+                            "haddock"    -> Just haddock+                            "monochrome" -> Just monochrome+                            _            -> error $ "Unknown style: " ++ s+styleOf (_ : xs) = styleOf xs++formatOf :: [Flag] -> String+formatOf [] = "html" -- default+formatOf (Format s : _) = case map toLower s of+                            "html"   -> "html"+                            "latex"  -> "latex"+                            _        -> error $ "Unknown format: " ++ s+formatOf (_ : xs) = formatOf xs+ filterNewlines :: String -> String filterNewlines ('\r':'\n':xs) = '\n' : filterNewlines xs filterNewlines ('\r':xs) = '\n' : filterNewlines xs filterNewlines (x:xs) = x : filterNewlines xs filterNewlines [] = [] --- | Highlight source code in XHTML using specified syntax.-xhtmlHighlight :: [FormatOption] -- ^ Options-               -> String         -- ^ Name of syntax to use-               -> String         -- ^ Source code to highlight-               -> Html-xhtmlHighlight opts lang code =-  case highlightAs lang code of-       Right result -> formatAsXHtml opts lang result-       Left  _      -> pre $ thecode << code- main = do   (opts, fnames, errs) <- getArgs >>= return . getOpt Permute options   prg <- getProgName@@ -95,17 +103,53 @@   if not (lang `elem` (map (map toLower) languages))      then hPutStrLn stderr ("Unknown syntax: " ++ lang) >> exitWith (ExitFailure 4)      else return ()-  let highlightOpts = [OptTitleAttributes | TitleAttributes `elem` opts] ++-                      [OptDetailed | Detailed `elem` opts] ++-                      [OptNumberLines | NumberLines `elem` opts] ++-                      [OptLineAnchors | NumberLines `elem` opts]-  let css = case cssPathOf opts of-                   Nothing      -> style ! [thetype "text/css"] $ primHtml defaultHighlightingCss -                   Just cssPath -> thelink ! [thetype "text/css", href cssPath, rel "stylesheet"] << noHtml-  let hcode = xhtmlHighlight highlightOpts lang code-  let pageTitle = if null fnames then noHtml else thetitle << (takeFileName $ head fnames)-  let metadata = meta ! [httpequiv "Content-Type", content "text/html; charset=UTF-8"] +++-                 meta ! [name "generator", content "highlight-kate"]-  if Fragment `elem` opts-     then putStrLn $ renderHtmlFragment hcode-     else putStrLn $ renderHtml $ header << [pageTitle, metadata, css] +++ body << hcode+  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+  case formatOf opts of+       "html"  -> hlHtml fragment fname highlightOpts (maybe pygments id $ styleOf opts)+                       lang code+       "latex" -> hlLaTeX fragment fname highlightOpts (maybe pygments id $ styleOf opts) lang code+       x       -> error $ "Uknown format " ++  x++hlHtml :: Bool               -- ^ Fragment+      -> FilePath            -- ^ Filename+      -> FormatOptions+      -> Style+      -> String              -- ^ language+      -> String              -- ^ code+      -> IO ()+hlHtml frag fname opts sty lang code =+ if frag+    then putStrLn $ renderHtml fragment+    else putStrLn $ renderHtml $ H.head (pageTitle >> metadata >> css) >> H.body (toHtml fragment)+  where fragment = formatHtmlBlock opts $ highlightAs lang code+        css = styleToHtml sty+        pageTitle = H.title $ toHtml fname+        metadata = H.meta ! A.httpEquiv "Content-Type" ! A.content "text/html; charset=UTF-8" >>+                    H.meta ! A.name "generator" ! A.content "highlight-kate"++hlLaTeX :: Bool               -- ^ Fragment+        -> FilePath            -- ^ Filename+        -> FormatOptions+        -> Style+        -> String              -- ^ language+        -> String              -- ^ code+        -> IO ()+hlLaTeX frag fname opts sty lang code =+ if frag+    then putStrLn fragment+    else 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 $ highlightAs lang code+        macros = styleToLaTeX sty+        pageTitle = "\\title{" ++ fname ++ "}\n"+++

@@ -1,6 +1,6 @@ {-# LANGUAGE Arrows #-} -{- +{- ParseSyntaxFiles.hs processes a directory containing Kate XML syntax highlighting definitions.  For each xml file in the directory, it creates a syntax highlighting parser@@ -21,23 +21,20 @@ module Main where  import Text.XML.HXT.Core-import Control.Arrow-import Control.Arrow.ArrowList-import Control.Monad (liftM)+import Control.Monad import Data.List-import Data.Maybe import Data.Char (toUpper, toLower, isAlphaNum) import qualified Data.Map as Map import System.Directory import System.Environment-import System.Exit import System.FilePath import Text.PrettyPrint import Text.Printf (printf) import Data.Char (ord)-import Text.Highlighting.Kate.Definitions+import Text.Highlighting.Kate.Types import qualified Data.ByteString as B import Data.ByteString.UTF8 (fromString, toString)+import Text.Regex.Posix ((=~))  data SyntaxDefinition =   SyntaxDefinition { synLanguage      :: String@@ -57,7 +54,7 @@                      , keywordDelims          :: [Char]                      } deriving (Read, Show) -data SyntaxContext = +data SyntaxContext =   SyntaxContext { contName               :: String                 , contAttribute          :: String                 , contLineEndContext     :: String@@ -65,7 +62,7 @@                 , contFallthrough        :: Bool                 , contFallthroughContext :: String                 , contDynamic            :: Bool-                , contParsers            :: [SyntaxParser] +                , contParsers            :: [SyntaxParser]                 } deriving (Read, Show)  data SyntaxParser =@@ -83,118 +80,152 @@                , parserChildren          :: [SyntaxParser]                } deriving (Read, Show) --- | Converts a list of files (ending in .xml) and directories containing .xml files--- into a list of .xml files.+-- | Converts a list of files (ending in .xml) and directories containing+-- .xml files into a list of .xml files. argFiles :: [String] -> IO [String]-argFiles [] = error "Specify paths of xml files and/or directories containing xml syntax files."+argFiles [] = error "Specify paths of xml files and/or directories." argFiles args = do   let isXmlFile x = isSuffixOf ".xml" x   let (files, dirs) = partition isXmlFile args-  dirContents <- mapM (\dir -> getDirectoryContents dir >>= return . map (combine dir) . filter isXmlFile) dirs+  dirContents <- forM dirs $ \dir -> do+                   dc <- getDirectoryContents dir+                   return $ map (combine dir) $ filter isXmlFile dc   return $ nub (files ++ concat dirContents) -+libraryPath :: FilePath libraryPath = joinPath ["Text", "Highlighting", "Kate"]++destDir :: FilePath destDir = joinPath [libraryPath, "Syntax"]  main :: IO () main = do   files <- getArgs >>= argFiles   destDirExists <- doesDirectoryExist destDir-  if destDirExists-     then return ()-     else createDirectory destDir +  unless destDirExists $ createDirectory destDir   mapM_ processOneFile files+  names <- (sort . map dropExtension . filter (isSuffixOf ".hs"))+          `fmap` (getDirectoryContents destDir)+  writeSyntaxFile names+  writeCabalFile names++writeSyntaxFile :: [String] -> IO ()+writeSyntaxFile names = do   let syntaxFile = combine libraryPath (addExtension "Syntax" "hs")   putStrLn $ "Writing " ++ syntaxFile   -- Get all syntax files, not only the newly generated ones.-  names <- getDirectoryContents destDir >>= return . sort . map dropExtension . filter (isSuffixOf ".hs")-  let imports = unlines $ map (\name -> "import qualified Text.Highlighting.Kate.Syntax." ++ name ++ " as " ++ name) names -  let cases = unlines $ map (\name -> show (map toLower name) ++ " -> " ++ name ++ ".highlight") names-  let languageExtensions = '[' :-        (intercalate ", " $ map (\name -> "(" ++ show name ++ ", " ++ name ++ ".syntaxExtensions)") names) ++ "]"+  let imports = unlines $ map (\name ->+                 "import qualified Text.Highlighting.Kate.Syntax." ++ name +++                 " as " ++ name) names+  let cases = unlines $ map (\name ->+                 show (map toLower name) ++ " -> " ++ name ++ ".highlight")+                 names+  let languageExtensions = "[" ++ (intercalate ", " $ map (\name ->+        "(" ++ show name ++ ", " ++ name ++ ".syntaxExtensions)") names) ++ "]"   syntaxFileTemplate <- liftM toString $ B.readFile (syntaxFile <.> "in")-  let filledTemplate = fillTemplate 0 [("imports",imports),-                                       ("languages",show names),-                                       ("languageExtensions",languageExtensions),-                                       ("cases",cases)] syntaxFileTemplate+  let filledTemplate = fillTemplate 0+                          [("imports",imports),+                           ("languages",show names),+                           ("supportedlanguages", intercalate ", " $ map (\x ->+                                "@" ++ map toLower x ++ "@") names),+                           ("languageExtensions",languageExtensions),+                           ("cases",cases)] syntaxFileTemplate   B.writeFile syntaxFile $ fromString filledTemplate +writeCabalFile :: [String] -> IO ()+writeCabalFile names = do+  copyFile "highlighting-kate.cabal" "highlighting-kate.cabal.orig"+  cabalLines <- lines `fmap` readFile "highlighting-kate.cabal.orig"+  let (front,rest) = break (=~ "Text\\.Highlighting\\.Kate\\.Syntax\\.")+                     cabalLines+  let end = dropWhile (=~ "Text\\.Highlighting\\.Kate\\.Syntax\\.") rest+  let toMod n = replicate 21 ' ' ++ "Text.Highlighting.Kate.Syntax." ++ n+  let newCabalLines = front ++ (map toMod names) ++ end+  writeFile "highlighting-kate.cabal" $ unlines newCabalLines+  putStrLn "Modified highlighting-kate.cabal."+  putStrLn "Backed up original as highlighting-kate.cabal.orig."+ processOneFile :: FilePath -> IO () processOneFile src = do   [syntax] <- runX $ application src   let name = nameFromPath src   let outFile = joinPath [libraryPath, "Syntax", addExtension name "hs"]+  let isIncludeRules p = parserType p == "IncludeRules" && "##" `isPrefixOf`+                              parserContext p   let includeLangs = nub $ filter (/= name) $ map (drop 2 . parserContext) $-        filter (\p -> (parserType p) == "IncludeRules" && "##" `isPrefixOf` (parserContext p)) $ -        concatMap contParsers $ synContexts syntax-  let includeImports = map (("import qualified " ++) . langNameToModule) includeLangs+        filter isIncludeRules $ concatMap contParsers $ synContexts syntax+  let includeImports = map (("import qualified " ++) . langNameToModule)+                        includeLangs   putStrLn $ "Writing " ++ outFile   B.writeFile outFile $ fromString $-           "{- This module was generated from data in the Kate syntax highlighting file " ++ (takeFileName src) ++ ", version " ++ -           synVersion syntax ++ ",\n" ++-           "   by  " ++ synAuthor syntax ++ " -}\n\n" ++ -           "module Text.Highlighting.Kate.Syntax." ++ name ++ " ( highlight, parseExpression, syntaxName, syntaxExtensions ) where\n\-           \import Text.Highlighting.Kate.Definitions\n\+           "{- This module was generated from data in the Kate syntax\n\+           \   highlighting file " ++ (takeFileName src) ++ ", version " +++           synVersion syntax ++ ", by " ++ synAuthor syntax ++ " -}\n\n" +++           "module Text.Highlighting.Kate.Syntax." ++ name ++ "\n          " +++           "(highlight, parseExpression, syntaxName, syntaxExtensions)" +++           "\nwhere\n\+           \import Text.Highlighting.Kate.Types\n\            \import Text.Highlighting.Kate.Common\n" ++-           unlines includeImports ++ -           "import Text.ParserCombinators.Parsec\n\-           \import Control.Monad (when)\n\+           unlines includeImports +++           "import Text.ParserCombinators.Parsec hiding (State)\n\            \import Data.Map (fromList)\n\-           \import Data.Maybe (fromMaybe, maybeToList)\n\n" +++           \import Control.Monad.State\n\+           \import Data.Char (isSpace)\n\+           \import Data.Maybe (fromMaybe)\n" ++            (if null (synLists syntax)-               then ""-               else "import qualified Data.Set as Set\n") +++               then "\n"+               else "import qualified Data.Set as Set\n\n") ++            render (mkParser syntax) ++ "\n" +labelFor :: SyntaxDefinition -> String -> TokenType+labelFor syntax attr' =+  case lookup attr' (synItemDatas syntax) of+       Just "dsKeyword" -> KeywordTok+       Just "dsDataType" -> DataTypeTok+       Just "dsDecVal" -> DecValTok+       Just "dsBaseN" -> BaseNTok+       Just "dsFloat" -> FloatTok+       Just "dsChar" -> CharTok+       Just "dsString" -> StringTok+       Just "dsComment" -> CommentTok+       Just "dsOthers" -> OtherTok+       Just "dsAlert" -> AlertTok+       Just "dsFunction" -> FunctionTok+       Just "dsRegionMarker" -> RegionMarkerTok+       Just "dsError" -> ErrorTok+       _ -> NormalTok+ mkParser :: SyntaxDefinition -> Doc-mkParser syntax = +mkParser syntax =   let name = text "-- | Full name of language." $$              text "syntaxName :: String" $$              text ("syntaxName = " ++ show (synLanguage syntax))       exts = text "-- | Filename extensions for this language." $$              text "syntaxExtensions :: String" $$              text ("syntaxExtensions = " ++ show (synExtensions syntax))-      shortFormOf "dsKeyword" = ["kw"]-      shortFormOf "dsDataType" = ["dt"] -      shortFormOf "dsDecVal" = ["dv"]-      shortFormOf "dsBaseN" = ["bn"]-      shortFormOf "dsFloat" = ["fl"]-      shortFormOf "dsChar" = ["ch"]-      shortFormOf "dsString" = ["st"]-      shortFormOf "dsComment" = ["co"]-      shortFormOf "dsOthers" = ["ot"]-      shortFormOf "dsAlert" = ["al"]-      shortFormOf "dsFunction" = ["fu"]-      shortFormOf "dsRegionMarker" = ["re"]-      shortFormOf "dsError" = ["er"]-      shortFormOf _ = []-      styles = text ("styles = " ++ (show [(typ, shortsty) | (typ, sty) <- synItemDatas syntax, shortsty <- shortFormOf sty]))       withAttr = text "withAttribute attr txt = do" $$ (nest 2 $                    text "when (null txt) $ fail \"Parser matched no text\"" $$-                   text "let labs = attr : maybeToList (lookup attr styles)" $$-                   text "st <- getState" $$-                   text "let oldCharsParsed = synStCharsParsedInLine st" $$-                   text "let prevchar = if null txt then '\\n' else last txt" $$-                   text "updateState $ \\st -> st { synStCharsParsedInLine = oldCharsParsed + length txt, synStPrevChar = prevchar } " $$-                   text "return (labs, txt)")-      parseExpressionInternal = text "parseExpressionInternal = do" $$ (nest 2 $ +                   text "updateState $ \\st -> st { synStPrevChar = last txt" $$+                   text "                        , synStPrevNonspace = synStPrevNonspace st || not (all isSpace txt) }" $$+                   text "return (attr, txt)")+      parseExpressionInternal = text "parseExpressionInternal = do" $$ (nest 2 $                                   text "context <- currentContext" $$-                                  text "parseRules context <|> (pDefault >>= withAttribute (fromMaybe \"\" $ lookup context defaultAttributes))")+                                  text "parseRules context <|> (pDefault >>= withAttribute (fromMaybe NormalTok $ lookup context defaultAttributes))")       parseExpression = text "-- | Parse an expression using appropriate local context." $$-                        text "parseExpression :: GenParser Char SyntaxState LabeledSource" $$-                        text "parseExpression = do" $$ (nest 2 $ +                        text "parseExpression :: KateParser Token" $$+                        text "parseExpression = do" $$ (nest 2 $                           text "st <- getState" $$                           text "let oldLang = synStLanguage st" $$                           text ("setState $ st { synStLanguage = " ++ show (synLanguage syntax) ++ " }") $$                           text ("context <- currentContext <|> (pushContext " ++ show (contName $ head $ synContexts syntax) ++                                 " >> currentContext)") $$                           text "result <- parseRules context" $$+                          text "optional $ eof >> pEndLine" $$                           text "updateState $ \\st -> st { synStLanguage = oldLang }" $$                           text "return result")-      defaultAttributes = text $ "defaultAttributes = " ++ (show $ map (\cont -> (contName cont, contAttribute cont)) $ synContexts syntax)+      defaultAttributes = text $ "defaultAttributes = " ++ (show $ map (\cont -> (contName cont, labelFor syntax $ contAttribute cont)) $ synContexts syntax)       -- Note: lineBeginContexts seems not to be used in any of the xml files-      -- lineBeginContexts = +      -- lineBeginContexts =       --   text $ "lineBeginContexts = " ++ (show $ map (\cont -> (contName cont, contLineBeginContext cont)) $ synContexts syntax)       startingContext = head (synContexts syntax)       contextNull = text $ "parseRules \"\" = parseRules " ++ show (contName startingContext)@@ -203,37 +234,27 @@       initialContextStack = Map.fromList [(synLanguage syntax, [contName startingContext])]       startingState = SyntaxState { synStContexts = initialContextStack                                   , synStLanguage = synLanguage syntax-                                  , synStCurrentLine = ""-                                  , synStCharsParsedInLine = 0+                                  , synStLineNumber = 0+                                  , synStPrevNonspace = False                                   , synStPrevChar = '\n'                                   , synStCaseSensitive = synCaseSensitive syntax                                   , synStKeywordCaseSensitive = keywordCaseSensitive (synKeywordAttr syntax)                                   , synStCaptures = [] }       initState = text $ "startingState = " ++ show startingState-      sourceLineParser = text "parseSourceLine = manyTill parseExpressionInternal pEndLine"-      mainParser = text "parseSource = do " $$  -                   (nest 2 $ text "lineContents <- lookAhead wholeLine" $$-                             text "updateState $ \\st -> st { synStCurrentLine = lineContents }" $$-                             -- text "context <- currentContext" $$-                             -- text "pushContext (fromMaybe \"#stay\" $ lookup context lineBeginContexts)" $$-                             text "result <- manyTill parseSourceLine eof" $$-                             text "return $ map normalizeHighlighting result")       mainFunction = text $ "-- | Highlight source code using this syntax definition.\n\-                            \highlight :: String -> Either String [SourceLine]\n\-                            \highlight input =\n\-                            \  case runParser parseSource startingState \"source\" input of\n\-                            \    Left err     -> Left $ show err\n\-                            \    Right result -> Right result"+                            \highlight :: String -> [SourceLine]\n\+                            \highlight input = evalState (mapM parseSourceLine $ lines input) startingState"+      lineParser = text   $ "parseSourceLine :: String -> State SyntaxState SourceLine\n\+                            \parseSourceLine = mkParseSourceLine parseExpressionInternal pEndLine"       endLineParser = text "pEndLine = do" $$-                      (nest 2 $ text "lookAhead $ newline <|> (eof >> return '\\n')" $$-                                text "context <- currentContext" $$+                      (nest 2 $ text "context <- currentContext" $$                                 text "case context of" $$-                                (nest 2 $ (vcat $ map (\cont -> text (show $ contName cont) <> text " -> " <> -                                            switchContext (contLineEndContext cont) <>+                                (nest 2 $ (vcat $ map (\cont -> text (show $ contName cont) <> text " -> " <>+                                            switchContext (contLineEndContext cont) (<> text " >> ") <>                                             if "#pop" `isPrefixOf` (contLineEndContext cont)-                                               then text " >> pEndLine"-                                               else text " >> pHandleEndLine") $ synContexts syntax) $$-                                          (text $ "_ -> pHandleEndLine")))+                                               then text "pEndLine"+                                               else text "return ()") $ synContexts syntax) $$+                                          (text $ "_ -> return ()")))                                 {- text "pushContext (fromMaybe \"#stay\" $ lookup context lineBeginContexts)" $$ -}       -- we use 'words "blah blah2 blah3"' to keep ghc from inlining the list, which makes compiling take a long time       listDef (n, list) = text $ listName n ++ " = Set.fromList $ words $ " ++@@ -244,12 +265,12 @@       regexDef re = text $ compiledRegexName re ++ " = compileRegex " ++ show re       regexes = vcat $ map regexDef $ nub $ [parserString x | x <- concatMap contParsers (synContexts syntax),                                                               parserType x == "RegExpr", parserDynamic x == False]-  in  vcat $ intersperse (text "") $ [name, exts, mainFunction, parseExpression, mainParser, initState, sourceLineParser, -                                      endLineParser, withAttr, styles, parseExpressionInternal, lists, regexes,+  in  vcat $ intersperse (text "") $ [name, exts, mainFunction, lineParser, parseExpression, initState,+                                      endLineParser, withAttr, parseExpressionInternal, lists, regexes,                                       defaultAttributes {- , lineBeginContexts -}] ++ contexts ++ [contextNull, contextCatchAll]  mkAlternatives :: [Doc] -> Doc-mkAlternatives docs = +mkAlternatives docs =   let contents = vcat $ intersperse (text "<|>") docs   in  if length docs > 1          then char '(' <> contents <> char ')'@@ -258,24 +279,25 @@ mkRules :: SyntaxDefinition -> SyntaxContext -> Doc mkRules syntax context =   let fallthroughParser = if contFallthrough context-                             then [parens (switchContext (contFallthroughContext context) <> -                                   text " >> return ([], \"\")")]+                             then [parens (switchContext (contFallthroughContext context) (<> text " >> ") <>+                                   text "currentContext >>= parseRules")]                              else []-  in  text ("parseRules " ++ show (contName context) ++ " = ") $$ +  in  text ("parseRules " ++ show (contName context) ++ " =") $$       if null (contParsers context) && null fallthroughParser          then nest 2 (text "pzero")-         else nest 2 $ (text "do (attr, result) <- " <> -                       (mkAlternatives $ (map (mkSyntaxParser syntax context) $ contParsers context) ++ fallthroughParser)) $$-                       text ("   return (attr, result)")+         else nest 2 $ mkAlternatives $ (map (mkSyntaxParser syntax context) $ contParsers context) ++ fallthroughParser  mkSyntaxParser :: SyntaxDefinition -> SyntaxContext -> SyntaxParser -> Doc-mkSyntaxParser syntax context parser = -  let mainParser = text $ case parserType parser of+mkSyntaxParser syntax context parser =+  let attr' = case parserAttribute parser of+                   "" -> labelFor syntax $ contAttribute context+                   x  -> labelFor syntax x+      mainParser = text $ case parserType parser of             "DetectChar"       -> "pDetectChar " ++ show (parserDynamic parser) ++ " " ++ show (parserChar parser)-            "Detect2Chars"     -> "pDetect2Chars " ++ show (parserDynamic parser) ++ " " ++ +            "Detect2Chars"     -> "pDetect2Chars " ++ show (parserDynamic parser) ++ " " ++                                     show (parserChar parser) ++ " " ++ show (parserChar1 parser)             "AnyChar"          -> "pAnyChar " ++ show (parserString parser)-            "StringDetect"     -> "pString " ++ show (parserDynamic parser) ++ " " ++ show (parserString parser) +            "StringDetect"     -> "pString " ++ show (parserDynamic parser) ++ " " ++ show (parserString parser)             "RegExpr"          -> if parserDynamic parser                                      then "pRegExprDynamic " ++ show (parserString parser)                                      else "pRegExpr " ++ compiledRegexName (parserString parser)@@ -294,9 +316,9 @@             "LineContinue"     -> "pLineContinue"             "IncludeRules"     -> case parserContext parser of                                       ('#':'#':xs) -> langNameToModule xs ++ ".parseExpression" ++-                                                      if parserIncludeAttrib parser || null (parserAttribute parser)+                                                      if parserIncludeAttrib parser || attr' == NormalTok                                                          then ""-                                                         else " >>= ((withAttribute " ++ show (parserAttribute parser) ++ ") . snd)" +                                                         else " >>= ((withAttribute " ++ show attr' ++ ") . snd)"                                       xs           -> "parseRules " ++ show xs             "DetectSpaces"     -> "pDetectSpaces"             "DetectIdentifier" -> "pDetectIdentifier"@@ -311,15 +333,9 @@                   if parserType parser == "IncludeRules"                      then mainParser <> char ')'                      else (if parserLookAhead parser-                             then text "lookAhead (" <> mainParser <> text ") >> return ([],\"\") " -                             else mainParser <> text " >>= withAttribute " <> -                                  text (if null (parserAttribute parser)-                                           then show (contAttribute context)-                                           else show (parserAttribute parser))) <> -                          char ')' <>-                          (if parserContext parser `elem` ["", "#stay"]-                              then empty -                              else text " >>~ " <> switchContext (parserContext parser))+                             then text "lookAhead (" <> mainParser <> text ") >> return (NormalTok,\"\") "+                             else mainParser <> text " >>= withAttribute " <> text (show attr')) <>+                          char ')' <> switchContext (parserContext parser) (text " >>~ " <>)       childParsers = parserChildren parser   in  char '(' <>       (if null childParsers@@ -327,13 +343,17 @@           else text "withChildren " <> parserDoc <> char ' ' <> (mkAlternatives $ map (mkSyntaxParser syntax context) childParsers)) <>       char ')' -switchContext next =+switchContext :: String -> (Doc -> Doc) -> Doc+switchContext next finalizer =   case next of-     x | "#pop" `isPrefixOf` x -> char '(' <>-          text (concat $ intersperse " >> " $ replicate (length (filter (=='#') x)) "popContext") <> char ')'-     "#stay" -> text "return ()"-     x -> text ("pushContext " ++ show x) +     x | "#pop" `isPrefixOf` x -> finalizer $+          char '(' <> text (concat $ intersperse " >> "+                                   $ replicate (length (filter (=='#') x)) "popContext") <> char ')'+     "#stay" -> empty+     ""      -> empty+     x       -> finalizer $ text ("pushContext " ++ show x) +langNameToModule :: String -> String langNameToModule str =  "Text.Highlighting.Kate.Syntax." ++   case str of     "Alerts" -> "Alert"@@ -356,7 +376,7 @@  normalize :: String -> String normalize "" = ""-normalize (x:xs) | isAlphaNum x = x : normalize xs +normalize (x:xs) | isAlphaNum x = x : normalize xs normalize (' ':xs)              = '_':normalize xs normalize (x:xs)                = printf "'%2x" (ord x) ++ normalize xs @@ -365,8 +385,8 @@ capitalize [] = []  nameFromPath :: FilePath -> String-nameFromPath = concat . map capitalize . words . -               (map (\c -> if c == '-' then ' ' else c)) . takeFileName . +nameFromPath = concat . map capitalize . words .+               (map (\c -> if c == '-' then ' ' else c)) . takeFileName .                dropExtension  application :: String -> IOSArrow b SyntaxDefinition@@ -389,14 +409,14 @@                              lists <- getLists -< x                              contexts <- getContexts -< x                              keywordAttr <- getKeywordAttrs -< x-                             returnA -< SyntaxDefinition { synLanguage      = lang +                             returnA -< SyntaxDefinition { synLanguage      = lang                                                          , synAuthor        = author                                                          , synVersion       = version-                                                         , synLicense       = license +                                                         , synLicense       = license                                                          , synExtensions    = sources                                                          , synCaseSensitive = vBool True caseSensitive                                                          , synLists         = lists-                                                         , synContexts      = contexts +                                                         , synContexts      = contexts                                                          , synItemDatas     = itemdatas                                                          , synKeywordAttr   = if null keywordAttr                                                                                  then defaultKeywordAttr@@ -413,12 +433,12 @@  getLists :: IOSArrow XmlTree [(String, [String])] getLists = listA $ multi (hasName "list")-                   >>> +                   >>>                    getAttrValue "name" &&& getListContents  getListContents :: IOSArrow XmlTree [String] getListContents = listA $ getChildren-                          >>> +                          >>>                           hasName "item"                           >>>                           getChildren@@ -439,7 +459,7 @@                           fallthroughContext <- getAttrValue "fallthroughContext" -< x                           dynamic <- getAttrValue "dynamic" -< x                           parsers <- getParsers -< x-                          returnA -< SyntaxContext +                          returnA -< SyntaxContext                                            { contName = name                                            , contAttribute = attribute                                            , contLineEndContext = if null lineEndContext then "#stay" else lineEndContext@@ -450,7 +470,7 @@                                            , contParsers = parsers }  getParsers :: IOSArrow XmlTree [SyntaxParser]-getParsers = listA $ getChildren +getParsers = listA $ getChildren                      >>>                      proc x -> do                        name <- getName -< x@@ -466,7 +486,7 @@                        dynamic <- getAttrValue "dynamic" -< x                        children <- getParsers -< x                        let tildeRegex = name == "RegExpr" && length str > 0 && head str == '^'-                       returnA -< SyntaxParser +                       returnA -< SyntaxParser                                     { parserType = name                                     , parserAttribute = attribute                                     , parserContext = context@@ -475,8 +495,8 @@                                     , parserFirstNonSpace = vBool False firstNonSpace                                     , parserColumn = if tildeRegex                                                         then Just 0-                                                        else if null column -                                                                then Nothing +                                                        else if null column+                                                                then Nothing                                                                 else Just (read column)                                     , parserDynamic = vBool False dynamic                                     , parserString = if tildeRegex then drop 1 str else str@@ -491,18 +511,21 @@                                     caseSensitive <- getAttrValue "casesensitive" -< x                                     weakDelim <- getAttrValue "weakDeliminator" -< x                                     additionalDelim <- getAttrValue "additionalDeliminator" -< x-                                    returnA -< SyntaxKeywordAttr +                                    returnA -< SyntaxKeywordAttr                                                       { keywordCaseSensitive = vBool True caseSensitive                                                       , keywordDelims = (standardDelims ++ additionalDelim) \\ weakDelim } -standardDelims = " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" +standardDelims :: [Char]+standardDelims = " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" +defaultKeywordAttr :: SyntaxKeywordAttr defaultKeywordAttr = SyntaxKeywordAttr { keywordCaseSensitive = True                                        , keywordDelims = standardDelims } -stripWhitespaceLeft = dropWhile isWhitespace -isWhitespace x = elem x [' ', '\t', '\n']+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@@ -515,7 +538,7 @@ fillTemplate :: Int -> [(String,String)] -> String -> String fillTemplate _ _ [] = [] fillTemplate _ [] lst = lst-fillTemplate n subs ('\n':xs) = '\n' : fillTemplate 0 subs xs+fillTemplate _ subs ('\n':xs) = '\n' : fillTemplate 0 subs xs fillTemplate n subs ('@':xs) =   let (pref, suff) = break (=='@') xs   in  if length pref > 0 && all isAlphaNum pref && length suff > 0

@@ -14,6 +14,7 @@ - Boo - C - Changelog+- Clojure - Cmake - Coffeescript - Coldfusion@@ -86,7 +87,6 @@ - Texinfo - Verilog - Vhdl-- Xharbour - Xml - Xorg - Xslt@@ -149,10 +149,7 @@      runghc ParseSyntaxFiles.hs xml -Note that ParseSyntaxFiles.hs requires the HXT package (>= 9.0.0). If you-added or removed a syntax definition, you will also need to-update the Extra-Source-Files and Exposed-Modules sections of-highlighting-kate.cabal before recompiling using 'cabal install'.+Note that ParseSyntaxFiles.hs requires the HXT package (>= 9.0.0).  To get the current Kate syntax highlighting files, clone the kate repository:@@ -174,8 +171,6 @@  - javascript.xml:  Fixed regex \s* (which matches empty string) by changes to DetectSpaces - perl.xml:  Fixed regexes - needed backslash-escapes before ] and ^-- bash.xml: Changed "\\" to "\" in two Detect2Char rules in FindString--NOTE: Known bugs are recorded in the file BUGS. Please send bug reports (or-better, patches) to the author (jgm at berkeley dot edu).+- base report bugs on the github issue tracker:+<https://github.com/jgm/highlighting-kate/issues>. 

@@ -1,23 +1,30 @@ {- |    Module      : Text.Highlighting.Kate-   Copyright   : Copyright (C) 2008 John MacFarlane-   License     : GNU GPL, version 2 or above +   Copyright   : Copyright (C) 2008-2011 John MacFarlane+   License     : GNU GPL, version 2 or above     Maintainer  : John MacFarlane <jgm@berkeley.edu>-   Stability   : alpha +   Stability   : alpha    Portability : portable  This helper module exports the main highlighting and formatting functions.-  -A typical application will combine a highlighter and a formatter: +A typical application will combine a highlighter and a formatter.+This one reads ruby code from stdin and writes HTML:++> import Text.Highlighting.Kate+> import Text.Blaze.Renderer.String (renderHtml)+> import Text.Blaze (toHtml)+> import Text.Blaze.Html5 as H+> > main = do >   code <- getContents->   case highlightAs "ruby" code of->         Right result -> putStrLn $ renderHtmlFragment $ ->                         formatAsXHtml [OptNumberLines] "ruby" result->         Left  err    -> error $ "Could not parse input: " ++ err+>   putStrLn $ renderHtml+>            $ do H.head (styleToHtml tango)+>                 H.body $ toHtml+>                        $ formatBlock defaultFormatOpts+>                        $ highlightAs "ruby" code  -} @@ -25,16 +32,17 @@                               , languages                               , languagesByExtension                               , languagesByFilename-                              , formatAsXHtml-                              , FormatOption (..)-                              , defaultHighlightingCss-                              , SourceLine-                              , LabeledSource                               , highlightingKateVersion+                              , module Text.Highlighting.Kate.Types+                              , module Text.Highlighting.Kate.Styles+                              , module Text.Highlighting.Kate.Format.HTML+                              , module Text.Highlighting.Kate.Format.LaTeX                               ) where-import Text.Highlighting.Kate.Format ( formatAsXHtml, FormatOption (..), defaultHighlightingCss )-import Text.Highlighting.Kate.Syntax ( highlightAs, languages, languagesByExtension, languagesByFilename )-import Text.Highlighting.Kate.Definitions ( SourceLine, LabeledSource )+import Text.Highlighting.Kate.Syntax+import Text.Highlighting.Kate.Types+import Text.Highlighting.Kate.Styles+import Text.Highlighting.Kate.Format.HTML+import Text.Highlighting.Kate.Format.LaTeX import Data.Version (showVersion) import Paths_highlighting_kate (version) 

@@ -2,10 +2,10 @@ {- |    Module      : Text.Highlighting.Kate.Common    Copyright   : Copyright (C) 2008 John MacFarlane-   License     : GNU GPL, version 2 or above +   License     : GNU GPL, version 2 or above     Maintainer  : John MacFarlane <jgm@berkeley.edu>-   Stability   : alpha +   Stability   : alpha    Portability : portable  Parsers used in all the individual syntax parsers.@@ -18,10 +18,11 @@ import System.IO.Unsafe (unsafePerformIO) import Text.Regex.PCRE.String #endif-import Text.Highlighting.Kate.Definitions-import Text.ParserCombinators.Parsec-import Data.Char (isDigit, chr, toLower)+import Text.Highlighting.Kate.Types+import Text.ParserCombinators.Parsec hiding (State)+import Data.Char (isDigit, toLower, isSpace) import Data.List (tails)+import Control.Monad.State import qualified Data.Map as Map import qualified Data.Set as Set @@ -52,13 +53,16 @@ (>>~) :: (Monad m) => m a -> m b -> m a a >>~ b = a >>= \x -> b >> return x -normalizeHighlighting :: [LabeledSource] -> [LabeledSource]+normalizeHighlighting :: [Token] -> [Token] normalizeHighlighting [] = [] normalizeHighlighting ((_,""):xs) = normalizeHighlighting xs-normalizeHighlighting ((a,x):(b,y):xs) | a == b = normalizeHighlighting ((a, x++y):xs)+normalizeHighlighting ((NormalTok,x):xs)+  | all isSpace x = (NormalTok,x) : normalizeHighlighting xs+normalizeHighlighting ((a,x):(b,y):xs)+  | a == b = normalizeHighlighting ((a, x++y):xs) normalizeHighlighting (x:xs) = x : normalizeHighlighting xs -pushContext :: [Char] -> GenParser tok SyntaxState ()+pushContext :: [Char] -> KateParser () pushContext context = if context == "#stay"                          then return ()                          else do st <- getState@@ -67,10 +71,10 @@                                  let addContext c x = case x of                                                        Nothing -> Just [c]                                                        Just cs -> Just (c:cs)-                                 let newContexts = Map.alter (addContext context) lang contexts +                                 let newContexts = Map.alter (addContext context) lang contexts                                  updateState $ \st -> st { synStContexts = newContexts } -popContext :: GenParser tok SyntaxState ()+popContext :: KateParser () popContext = do st <- getState                 let contexts = synStContexts st                 let lang = synStLanguage st@@ -78,9 +82,9 @@                     Just (_:_) -> updateState $ \st ->                                     st{ synStContexts = Map.adjust tail lang contexts }                     Just []    -> fail $ "Stack empty for language " ++ lang-                    Nothing    -> fail $ "No context stack for language " ++ lang +                    Nothing    -> fail $ "No context stack for language " ++ lang -currentContext :: GenParser tok SyntaxState String+currentContext :: KateParser String currentContext = do st <- getState                     let contexts = synStContexts st                     let lang = synStLanguage st@@ -89,215 +93,225 @@                          Just (c:_) -> return c                          Nothing    -> fail $ "No context stack for language " ++ lang -withChildren :: GenParser tok SyntaxState LabeledSource-             -> GenParser tok SyntaxState LabeledSource-             -> GenParser tok SyntaxState LabeledSource+withChildren :: KateParser Token+             -> KateParser Token+             -> KateParser Token withChildren parent child = do   (pAttr, pResult) <- parent-  (_, cResult) <- option ([],"") child+  (_, cResult) <- option (NormalTok,"") child   return (pAttr, pResult ++ cResult) -wholeLine :: GenParser Char st [Char]-wholeLine = manyTill anyChar (newline <|> (eof >> return '\n'))--pFirstNonSpace :: GenParser tok SyntaxState ()+pFirstNonSpace :: KateParser () pFirstNonSpace = do-  curLine <- currentLine-  charsParsedInLine <- getState >>= return . synStCharsParsedInLine-  let (sps, nonSps) = span (`elem` " \t") curLine-  if length sps == charsParsedInLine && length nonSps > 0 -     then return ()-     else fail "Not first nonspace"+  rest <- getInput+  prevNonspace <- fromState synStPrevNonspace+  guard $ not $ prevNonspace || null rest || isSpace (head rest)  currentColumn :: GenParser tok st Column-currentColumn = getPosition >>= return . sourceColumn--currentLine :: GenParser tok SyntaxState String-currentLine = getState >>= return . synStCurrentLine+currentColumn = sourceColumn `fmap` getPosition  pColumn :: Column -> GenParser tok st () pColumn col = do   curCol <- currentColumn-  if col == (curCol - 1) -- parsec's columns start with 1-     then return ()-     else fail $ "Not column " ++ show col+  guard $ col == (curCol - 1) -- parsec's columns start with 1 -pGetCapture :: Int -> GenParser tok SyntaxState String+pGetCapture :: Int -> KateParser String pGetCapture capNum = do   captures <- getState >>= return . synStCaptures   if length captures < capNum      then fail "Not enough captures"      else return $ captures !! (capNum - 1) -pDetectChar :: Bool -> Char -> GenParser Char SyntaxState String-pDetectChar dynamic ch = do +pDetectChar :: Bool -> Char -> KateParser String+pDetectChar dynamic ch = do   if dynamic && isDigit ch      then pGetCapture (read [ch]) >>= try . string      else char ch >>= return . (:[]) -pDetect2Chars :: Bool -> Char -> Char -> GenParser Char SyntaxState [Char]+pDetect2Chars :: Bool -> Char -> Char -> KateParser [Char] pDetect2Chars dynamic ch1 ch2 = try $ do   [c1] <- pDetectChar dynamic ch1   [c2] <- pDetectChar dynamic ch2   return [c1, c2] -pKeyword :: [Char] -> Set.Set [Char] -> GenParser Char SyntaxState [Char]+pKeyword :: [Char] -> Set.Set [Char] -> KateParser [Char] pKeyword delims kws = try $ do-  st <- getState-  let prevChar = synStPrevChar st-  case prevChar of-         x | not (x `elem` delims) -> fail "Not preceded by a delimiter"-         _ -> return ()+  notFollowedBy (oneOf delims)+  prevChar <- fromState synStPrevChar+  caseSensitive <- fromState synStKeywordCaseSensitive+  guard $ prevChar `elem` delims   word <- many1 (noneOf delims)-  let word' = if synStKeywordCaseSensitive st+  let word' = if caseSensitive                  then word                  else map toLower word   if word' `Set.member` kws      then return word      else fail "Keyword not in list" -pString :: Bool -> [Char] -> GenParser Char SyntaxState String+pString :: Bool -> [Char] -> KateParser String pString dynamic str =   if dynamic      then subDynamic str >>= try . string      else try $ string str -pAnyChar :: [Char] -> GenParser Char st [Char]+pAnyChar :: [Char] -> KateParser [Char] pAnyChar chars = oneOf chars >>= return . (:[]) -pDefault :: GenParser Char st [Char]-pDefault = noneOf "\n" >>= return . (:[])---- The following alternative gives a 25% speed improvement, but it's possible--- that it won't work for all syntaxes:--- pDefault = (many1 alphaNum) <|> (noneOf "\n" >>= return . (:[]))+pDefault :: KateParser [Char]+pDefault = (:[]) `fmap` anyChar -subDynamic :: [Char] -> GenParser tok SyntaxState [Char]+subDynamic :: [Char] -> KateParser [Char] subDynamic ('%':x:xs) | isDigit x = do   captures <- getState >>= return . synStCaptures   let capNum = read [x]+  let escapeRegexChar c | c `elem` "^$\\[](){}*+.?" = ['\\',c]+                        | otherwise = [c]+  let escapeRegex = concatMap escapeRegexChar   let replacement = if length captures < capNum                        then ['%',x]                        else captures !! (capNum - 1)-  subDynamic xs >>= return . (replacement ++)+  subDynamic xs >>= return . (escapeRegex replacement ++) subDynamic (x:xs) = subDynamic xs >>= return . (x:) subDynamic "" = return "" -compileRegex :: String -> Regex+convertOctal :: String -> String+convertOctal [] = ""+convertOctal ('\\':'0':x:y:z:rest) | isOctalDigit x && isOctalDigit y && isOctalDigit z =+  case reads ['\\','o',x,y,z] of+        ((x,rest):_) -> x : convertOctal rest+        _            -> '\\':'o':x:y:z: convertOctal rest+convertOctal ('\\':x:y:z:rest) | isOctalDigit x && isOctalDigit y && isOctalDigit z =+  case reads ['\\','o',x,y,z] of+        ((x,rest):_) -> x : convertOctal rest+        _            -> '\\':'o':x:y:z: convertOctal rest+convertOctal (x:xs) = x : convertOctal xs++isOctalDigit :: Char -> Bool+isOctalDigit c = c == '0' || c == '1' || c == '2' || c == '3'+              || c == '4' || c == '5' || c == '6' || c == '7'++compileRegex :: String -> KateParser Regex #ifdef _PCRE_LIGHT-compileRegex regexpStr = compile ('.' : escapeRegex regexpStr) [anchored]+compileRegex regexpStr = return $ compile ('.' : convertOctal regexpStr) [anchored] #else compileRegex regexpStr =-  case unsafePerformIO $ compile (compAnchored) (execNotEmpty) ('.' : escapeRegex regexpStr) of-        Left _ -> error $ "Error compiling regex: " ++ show regexpStr-        Right r -> r+  case unsafePerformIO $ compile (compAnchored) (execNotEmpty)+       ('.' : convertOctal regexpStr) of+        Left _  -> fail $ "Error compiling regex: " ++ show regexpStr+        Right r -> return r #endif -matchRegex :: Regex -> String -> Maybe [String]+matchRegex :: Regex -> String -> KateParser (Maybe [String]) #ifdef _PCRE_LIGHT-matchRegex r s = match r s [exec_notempty] +matchRegex r s = match r s [exec_notempty] #else-matchRegex r s = case unsafePerformIO (regexec r s) of -                      Right (Just (_, mat, _ , capts)) -> Just (mat : capts)-                      Right Nothing -> Nothing-                      Left matchError -> error $ show matchError+matchRegex r s = case unsafePerformIO (regexec r s) of+                      Right (Just (_, mat, _ , capts)) -> return $ Just (mat : capts)+                      Right Nothing -> return Nothing+                      Left matchError -> fail $ show matchError #endif -pRegExpr :: Regex -> GenParser Char SyntaxState String+pRegExpr :: KateParser Regex -> KateParser String pRegExpr compiledRegex = do-  st <- getState-  let curLine = synStCurrentLine st-  let charsParsedInLine = synStCharsParsedInLine st+  rest <- getInput+  prevChar <- fromState synStPrevChar   -- Note: we keep one preceding character, so initial \b can match or not...-  let remaining = if charsParsedInLine == 0-                     then ' ':curLine-                     else drop (charsParsedInLine - 1) curLine -  case matchRegex compiledRegex remaining of-        Just (x:xs) -> do if null xs-                             then return ()-                             else updateState (\st -> st {synStCaptures = xs})-                          string (drop 1 x) +  let target = if prevChar == '\n'+                  then ' ':rest+                  else prevChar:rest+  regex <- compiledRegex+  matches <- matchRegex regex target+  case matches of+        Just (x:xs) | null x -> fail "Regex matched null string!"+                    | otherwise -> do+                          unless (null xs) $+                            updateState (\st -> st {synStCaptures = xs})+                          count (length x - 1) anyChar         _           -> pzero -pRegExprDynamic :: [Char] -> GenParser Char SyntaxState String+pRegExprDynamic :: [Char] -> KateParser String pRegExprDynamic regexpStr = do   regexpStr' <- subDynamic regexpStr-  let compiledRegex = compileRegex regexpStr'-  pRegExpr compiledRegex --escapeRegex :: String -> String-escapeRegex [] = ""-escapeRegex ('\\':'0':x:y:z:rest) | isDigit x && isDigit y && isDigit z =-  chr (read ['0','o',x,y,z]) : escapeRegex rest-escapeRegex ('\\':x:y:z:rest) | isDigit x && isDigit y && isDigit z =-  chr (read ['0','o',x,y,z]) : escapeRegex rest-escapeRegex (x:xs) = x : escapeRegex xs +  pRegExpr $ compileRegex regexpStr' -integerRegex :: Regex+integerRegex :: KateParser Regex integerRegex = compileRegex "\\b[-+]?(0[Xx][0-9A-Fa-f]+|0[Oo][0-7]+|[0-9]+)\\b" -pInt :: GenParser Char SyntaxState String-pInt = pRegExpr integerRegex +pInt :: KateParser String+pInt = pRegExpr integerRegex -floatRegex :: Regex+floatRegex :: KateParser Regex floatRegex = compileRegex "\\b[-+]?(([0-9]+\\.[0-9]*|[0-9]*\\.[0-9]+)([Ee][-+]?[0-9]+)?|[0-9]+[Ee][-+]?[0-9]+)\\b" -pFloat :: GenParser Char SyntaxState String+pFloat :: KateParser String pFloat = pRegExpr floatRegex -octRegex :: Regex+octRegex :: KateParser Regex octRegex = compileRegex "\\b[-+]?0[Oo][0-7]+\\b" -pHlCOct :: GenParser Char SyntaxState String+pHlCOct :: KateParser String pHlCOct = pRegExpr octRegex -hexRegex :: Regex+hexRegex :: KateParser Regex hexRegex = compileRegex "\\b[-+]?0[Xx][0-9A-Fa-f]+\\b" -pHlCHex :: GenParser Char SyntaxState String+pHlCHex :: KateParser String pHlCHex = pRegExpr hexRegex -pHlCStringChar :: GenParser Char st [Char]-pHlCStringChar = try $ do +pHlCStringChar :: KateParser [Char]+pHlCStringChar = try $ do   char '\\'   (oneOf "abefnrtv\"'?\\" >>= return  . (\x -> ['\\',x]))-    <|> (do a <- oneOf "xX"+    <|> (do a <- satisfy (\c -> c == 'x' || c == 'X')             b <- many1 hexDigit             return ('\\':a:b))     <|> (do a <- char '0'             b <- many1 octDigit             return ('\\':a:b)) -pHlCChar :: GenParser Char st [Char]+pHlCChar :: KateParser [Char] pHlCChar = try $ do   char '\''   c <- pHlCStringChar   char '\''   return ('\'' : c ++ "'") -pRangeDetect :: Char -> Char -> GenParser Char st [Char]+pRangeDetect :: Char -> Char -> KateParser [Char] pRangeDetect startChar endChar = try $ do   char startChar-  body <- manyTill (noneOf ['\n', endChar]) (char endChar)+  body <- manyTill (satisfy (/= endChar)) (char endChar)   return $ startChar : (body ++ [endChar]) -pLineContinue :: GenParser Char st String-pLineContinue = try $ string "\\\n"+pLineContinue :: KateParser String+pLineContinue = try $ char '\\' >> eof >> return "\\" -pDetectSpaces :: GenParser Char st [Char]-pDetectSpaces = many1 (oneOf "\t ")+pDetectSpaces :: KateParser [Char]+pDetectSpaces = many1 (satisfy $ \c -> c == ' ' || c == '\t') -pDetectIdentifier :: GenParser Char st [Char]+pDetectIdentifier :: KateParser [Char] pDetectIdentifier = do   first <- letter   rest <- many alphaNum   return (first:rest) -pHandleEndLine :: GenParser Char SyntaxState ()-pHandleEndLine = do-  newline <|> (eof >> return '\n')-  lineContents <- lookAhead wholeLine-  updateState $ \st -> st { synStCurrentLine = lineContents-                          , synStCharsParsedInLine = 0-                          , synStPrevChar = '\n' }+fromState :: (SyntaxState -> a) -> KateParser a+fromState f = f `fmap` getState +mkParseSourceLine :: KateParser Token    -- ^ parseExpressionInternal+                  -> KateParser ()       -- ^ pEndline+                  -> String+                  -> State SyntaxState SourceLine+mkParseSourceLine parseExpressionInternal pEndLine ln = do+  modify $ \st -> st{ synStLineNumber = synStLineNumber st + 1 }+  st <- get+  let lineName = "line " ++ show (synStLineNumber st)+  let pline = do ts <- many parseExpressionInternal+                 updateState $ \st -> st{ synStPrevChar = '\n' }+                 pEndLine+                 s  <- getState+                 return (s, ts)+  let (newst, result) = case runParser pline st lineName ln of+                              Left _      -> (st, [(ErrorTok,ln)])+                              Right (s,r) -> (s,r)+  put $! newst+  return $! normalizeHighlighting result

@@ -1,37 +0,0 @@-{- |-   Module      : Text.Highlighting.Kate.Definitions-   Copyright   : Copyright (C) 2008 John MacFarlane-   License     : GNU GPL, version 2 or above --   Maintainer  : John MacFarlane <jgm@berkeley.edu>-   Stability   : alpha -   Portability : portable--Definitions for data structures needed by highlighting-kate.--}--module Text.Highlighting.Kate.Definitions where-import qualified Data.Map as Map---- | A stack of context names for each language.  (Language-specific context--- stacks must be maintained because of IncludeRules.)-type ContextStack = Map.Map String [String]---- | State for syntax parser.-data SyntaxState = SyntaxState-  { synStContexts             :: ContextStack -- ^ Stack of contexts-  , synStLanguage             :: String       -- ^ Language being parsed -  , synStCurrentLine          :: String       -- ^ Contents of current line-  , synStCharsParsedInLine    :: Int          -- ^ Num characters parsed in line-  , synStPrevChar             :: Char         -- ^ Last character parsed-  , synStCaseSensitive        :: Bool         -- ^ Language is case-sensitive-  , synStKeywordCaseSensitive :: Bool         -- ^ Keywords are case-sensitive-  , synStCaptures             :: [String]     -- ^ List of regex captures from-                                              --   last capturing match-  } deriving (Read, Show)---- | A pair consisting of a list of attributes and some text.-type LabeledSource = ([String], String)---- | A line of source, list of labeled source items.-type SourceLine = [LabeledSource]

@@ -1,95 +0,0 @@-{- |-   Module      : Text.Highlighting.Kate.Format-   Copyright   : Copyright (C) 2008 John MacFarlane-   License     : GNU GPL, version 2 or above --   Maintainer  : John MacFarlane <jgm@berkeley.edu>-   Stability   : alpha -   Portability : portable--Formatters that convert a list of annotated source lines to various output formats.--}--module Text.Highlighting.Kate.Format ( formatAsXHtml, FormatOption (..), defaultHighlightingCss ) where-import Text.Highlighting.Kate.Definitions-import Text.XHtml.Transitional-import Data.List (intersperse)---- | Options for formatters.-data FormatOption = OptNumberLines     -- ^ Number lines-                  | OptNumberFrom Int  -- ^ Number of first line-                  | OptLineAnchors     -- ^ Anchors on each line number -                  | OptTitleAttributes -- ^ Include title attributes-                  | OptDetailed        -- ^ Include detailed lexical information in classes.-                                       --   (By default, only the default style is included. This-                                       --   option causes output to be more verbose.)-                  | OptInline          -- ^ Format as span-level, not block-level element-                  deriving (Eq, Show, Read)---- | Format a list of highlighted @SourceLine@s as XHtml.-formatAsXHtml :: [FormatOption]  -- ^ Options-              -> String          -- ^ Language-              -> [SourceLine]    -- ^ Source lines to format-              -> Html-formatAsXHtml opts lang lines =-  let startNum = getStartNum opts-      numberOfLines = length lines-      code = thecode ! [theclass $ unwords ["sourceCode", lang]] << intersperse br (map (sourceLineToHtml opts) lines)-  in  if OptInline `elem` opts-         then code-         else if OptNumberLines `elem` opts-                 then let lnTitle = title "Click to toggle line numbers"-                          lnOnClick = strAttr "onclick" "with (this.firstChild.style) { display = (display == '') ? 'none' : '' }"-                          nums = td ! [theclass "lineNumbers", lnTitle, lnOnClick] $ pre <<-                                             (intersperse br $ map lineNum [startNum..(startNum + numberOfLines - 1)])-                          lineNum n = if OptLineAnchors `elem` opts-                                         then anchor ! [identifier $ show n] << show n-                                         else stringToHtml $ show n-                          sourceCode = td ! [theclass "sourceCode"] $ pre ! [theclass "sourceCode"] << code-                      in  table ! [theclass "sourceCode"] $ tr << [nums, sourceCode]-                 else pre ! [theclass "sourceCode"] << code--labeledSourceToHtml :: [FormatOption] -> LabeledSource -> Html-labeledSourceToHtml _ ([], txt)    = toHtml txt-labeledSourceToHtml opts (labs, txt)  =-  if null attribs-     then toHtml txt-     else thespan ! attribs << txt-   where classes = unwords $-                   if OptDetailed `elem` opts-                      then map removeSpaces labs-                      else drop 1 labs  -- first is specific-         attribs = [theclass classes | not (null classes)] ++-                   [title classes | OptTitleAttributes `elem` opts]--sourceLineToHtml :: [FormatOption] -> SourceLine -> Html-sourceLineToHtml opts contents =-  concatHtml $ map (labeledSourceToHtml opts) contents--removeSpaces :: String -> String-removeSpaces = filter (/= ' ')--getStartNum :: [FormatOption] -> Int-getStartNum [] = 1-getStartNum (OptNumberFrom n : _) = n-getStartNum (_:xs) = getStartNum xs--defaultHighlightingCss :: String-defaultHighlightingCss = -  "table.sourceCode, tr.sourceCode, td.lineNumbers, td.sourceCode, table.sourceCode pre \n\ -  \   { margin: 0; padding: 0; border: 0; vertical-align: baseline; border: none; }\n\ -  \td.lineNumbers { border-right: 1px solid #AAAAAA; text-align: right; color: #AAAAAA; padding-right: 5px; padding-left: 5px; }\n\  -  \td.sourceCode { padding-left: 5px; }\n\ -  \code.sourceCode span.kw { color: #007020; font-weight: bold; } \n\ -  \code.sourceCode span.dt { color: #902000; }\n\ -  \code.sourceCode span.dv { color: #40a070; }\n\ -  \code.sourceCode span.bn { color: #40a070; }\n\ -  \code.sourceCode span.fl { color: #40a070; }\n\ -  \code.sourceCode span.ch { color: #4070a0; }\n\ -  \code.sourceCode span.st { color: #4070a0; }\n\ -  \code.sourceCode span.co { color: #60a0b0; font-style: italic; }\n\ -  \code.sourceCode span.ot { color: #007020; }\n\ -  \code.sourceCode span.al { color: red; font-weight: bold; }\n\ -  \code.sourceCode span.fu { color: #06287e; }\n\ -  \code.sourceCode span.re { }\n\ -  \code.sourceCode span.er { color: red; font-weight: bold; }"

@@ -0,0 +1,127 @@+{- |+   Module      : Text.Highlighting.Kate.Format.HTML+   Copyright   : Copyright (C) 2008-2011 John MacFarlane+   License     : GNU GPL, version 2 or above++   Maintainer  : John MacFarlane <jgm@berkeley.edu>+   Stability   : alpha+   Portability : portable++Formatters that convert a list of annotated source lines to HTML.+-}++module Text.Highlighting.Kate.Format.HTML (+      formatHtmlInline, formatHtmlBlock, styleToHtml+   ) where+import Text.Highlighting.Kate.Types+import Text.Blaze+import qualified Text.Blaze.Html5 as H+import qualified Text.Blaze.Html5.Attributes as A+import Data.Monoid+import Data.List (intersperse)++-- | 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@, 'CommontTok' = @co@,+-- 'OtherTok' = @ot@, 'AlertTok' = @al@, 'FunctionTok' = @fu@,+-- 'RegionMarkerTok' = @re@, 'ErrorTok' = @er@. A 'NormalTok'+-- is not marked up at all.+formatHtmlInline :: FormatOptions -> [SourceLine] -> Html+formatHtmlInline opts = (H.code ! A.class_ (toValue $ unwords+                                                    $ "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 NormalTok         = ""++sourceLineToHtml :: FormatOptions -> SourceLine -> Html+sourceLineToHtml opts contents = mapM_ (tokenToHtml opts) contents++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.+formatHtmlBlock :: FormatOptions -> [SourceLine] -> Html+formatHtmlBlock opts ls = container ! A.class_ (toValue $ unwords classes)+  where  container = if numberLines opts+                        then H.table $ H.tr ! A.class_ sourceCode+                                     $ nums >> source+                        else pre+         sourceCode = toValue "sourceCode"+         classes = "sourceCode" :+                   [x | x <- containerClasses opts, x /= "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 $ show n) $ toHtml $ show n)+                              >> toHtml "\n"+                        else toHtml $ show n ++ "\n"++-- | Returns an HTML @style@ block with definitions for+-- formatting highlighted code according to the given style.+styleToHtml :: Style -> Html+styleToHtml f = H.style ! A.type_ (toValue "text/css") $ toHtml+  $ unlines $ 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 { " +++             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; }"+          ]++toCss :: (TokenType, TokenStyle) -> String+toCss (t,tf) = "code > span." ++ short t ++ " { "+                ++ colorspec ++ backgroundspec ++ weightspec ++ stylespec+                ++ decorationspec ++ "}"+  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 ""++

@@ -0,0 +1,125 @@+{- |+   Module      : Text.Highlighting.Kate.Format.LaTeX+   Copyright   : Copyright (C) 2008-2011 John MacFarlane+   License     : GNU GPL, version 2 or above++   Maintainer  : John MacFarlane <jgm@berkeley.edu>+   Stability   : alpha+   Portability : portable++Formatters that convert a list of annotated source lines to LaTeX.+-}++module Text.Highlighting.Kate.Format.LaTeX (+         formatLaTeXInline, formatLaTeXBlock, styleToLaTeX+         ) where+import Text.Highlighting.Kate.Types+import Text.Printf+import Data.List (intercalate)+import Control.Monad (mplus)+import Data.Char (isSpace)++formatLaTeX :: FormatOptions -> [SourceLine] -> String+formatLaTeX _ = intercalate "\n" . map sourceLineToLaTeX++-- | Formats tokens as LaTeX using custom commands inside+-- a @\\Highlight@ command.  A @KeywordTok@ is rendered+-- using @\\KeywordTok{..}@, and so on.+formatLaTeXInline :: FormatOptions -> [SourceLine] -> String+formatLaTeXInline opts ls = "\\Verb{" ++ formatLaTeX opts ls ++ "}"++sourceLineToLaTeX :: SourceLine -> String+sourceLineToLaTeX contents = concatMap tokenToLaTeX contents++tokenToLaTeX :: Token -> String+tokenToLaTeX (NormalTok, txt) | all isSpace txt = escapeLaTeX txt+tokenToLaTeX (toktype, txt)   = '\\':(show toktype ++ "{" ++ escapeLaTeX txt ++ "}")++escapeLaTeX :: String -> String+escapeLaTeX = concatMap escapeLaTeXChar+  where escapeLaTeXChar '\\' = "\\textbackslash{}"+        escapeLaTeXChar '{'  = "\\{"+        escapeLaTeXChar '}'  = "\\}"+        escapeLaTeXChar '|'  = "\\textbar{}" -- used in inline verbatim+        escapeLaTeXChar x    = [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] -> String+formatLaTeXBlock opts ls = unlines+  ["\\begin{Shaded}"+  ,"\\begin{Highlighting}[" +++   (if numberLines opts+       then "numbers=left," +++            (if startNumber opts == 1+                then ""+                else ",firstnumber=" ++ show (startNumber opts)) ++ ","+       else "") ++ "]"+  ,formatLaTeX opts 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 -> String+styleToLaTeX f = unlines $+  [ "\\usepackage{color}"+  , "\\usepackage{fancyvrb}"+  , "\\DefineShortVerb[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}"+                            ,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 -> String+macrodef defaultcol tokstyles tokt = "\\newcommand{\\" ++ 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) -> 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) -> printf "\\textcolor[rgb]{%0.2f,%0.2f,%0.2f}{%s}" r g b x+

@@ -0,0 +1,140 @@+{- |+   Module      : Text.Highlighting.Kate.Styles+   Copyright   : Copyright (C) 2011 John MacFarlane+   License     : GNU GPL, version 2 or above++   Maintainer  : John MacFarlane <jgm@berkeley.edu>+   Stability   : alpha+   Portability : portable++Styles for rendering annotated source lines.+-}++module Text.Highlighting.Kate.Styles ( pygments, kate, espresso, tango,+                                       haddock, monochrome )+where+import Text.Highlighting.Kate.Types++-- | Style based on pygments's default colors.+pygments :: Style+pygments = Style{+    backgroundColor = Nothing+  , defaultColor = Nothing+  , lineNumberColor = toColor "#aaaaaa"+  , lineNumberBackgroundColor = Nothing+  , tokenStyles =+    [ (KeywordTok, defStyle{ tokenColor = toColor "#007020", tokenBold = True })+    , (DataTypeTok, defStyle{ tokenColor = toColor "#902000" })+    , (DecValTok, defStyle{ tokenColor = toColor "#40a070" })+    , (BaseNTok, defStyle{ tokenColor = toColor "#40a070" })+    , (FloatTok, defStyle{ tokenColor = toColor "#40a070" })+    , (CharTok, defStyle{ tokenColor = toColor "#4070a0" })+    , (StringTok, defStyle{ tokenColor = toColor "#4070a0" })+    , (CommentTok, defStyle{ tokenColor = toColor "#60a0b0", tokenItalic = True })+    , (OtherTok, defStyle{ tokenColor = toColor "#007020" })+    , (AlertTok, defStyle{ tokenColor = toColor "#ff0000", tokenBold = True })+    , (FunctionTok, defStyle{ tokenColor = toColor "#06287e" })+    , (ErrorTok, defStyle{ tokenColor = toColor "#ff0000", tokenBold = True })+    ]+  }++-- | Style based on kate's default colors.+kate :: Style+kate = Style{+    backgroundColor = Nothing+  , defaultColor = Nothing+  , lineNumberColor = Nothing+  , lineNumberBackgroundColor = toColor "#dddddd"+  , tokenStyles =+    [ (KeywordTok, defStyle{ tokenBold = True })+    , (DataTypeTok, defStyle{ tokenColor = toColor "#800000" })+    , (DecValTok, defStyle{ tokenColor = toColor "#0000FF" })+    , (BaseNTok, defStyle{ tokenColor = toColor "#0000FF" })+    , (FloatTok, defStyle{ tokenColor = toColor "#800080" })+    , (CharTok, defStyle{ tokenColor = toColor "#FF00FF" })+    , (StringTok, defStyle{ tokenColor = toColor "#DD0000" })+    , (CommentTok, defStyle{ tokenColor = toColor "#808080", tokenItalic = True })+    , (AlertTok, defStyle{ tokenColor = toColor "#00ff00", tokenBold = True })+    , (FunctionTok, defStyle{ tokenColor = toColor "#000080" })+    , (ErrorTok, defStyle{ tokenColor = toColor "#ff0000", tokenBold = True })+    ]+  }++-- | Style based on pygments's tango colors.+tango :: Style+tango = Style{+    backgroundColor = toColor "#f8f8f8"+  , defaultColor = Nothing+  , lineNumberColor = toColor "#aaaaaa"+  , lineNumberBackgroundColor = Nothing+  , tokenStyles =+    [ (KeywordTok, defStyle{ tokenColor = toColor "#204a87", tokenBold = True })+    , (DataTypeTok, defStyle{ tokenColor = toColor "#204a87" })+    , (DecValTok, defStyle{ tokenColor = toColor "#0000cf" })+    , (BaseNTok, defStyle{ tokenColor = toColor "#0000cf" })+    , (FloatTok, defStyle{ tokenColor = toColor "#0000cf" })+    , (CharTok, defStyle{ tokenColor = toColor "#4e9a06" })+    , (StringTok, defStyle{ tokenColor = toColor "#4e9a06" })+    , (CommentTok, defStyle{ tokenColor = toColor "#8f5902", tokenItalic = True })+    , (OtherTok, defStyle{ tokenColor = toColor "#8f5902" })+    , (AlertTok, defStyle{ tokenColor = toColor "#ef2929" })+    , (FunctionTok, defStyle{ tokenColor = toColor "#000000" })+    , (ErrorTok, defStyle{ tokenColor = toColor "a40000", tokenBold = True })+    ]+  }++-- | Style based on ultraviolet's espresso_libre.css (dark background).+espresso :: Style+espresso = Style{+    backgroundColor = toColor "#2A211C"+  , defaultColor = toColor "#BDAE9D"+  , lineNumberColor = toColor "#BDAE9D"+  , lineNumberBackgroundColor = toColor "#2A211C"+  , tokenStyles =+    [ (KeywordTok, defStyle{ tokenColor = toColor "#43A8ED", tokenBold = True })+    , (DataTypeTok, defStyle{ tokenUnderline = True })+    , (DecValTok, defStyle{ tokenColor = toColor "#44AA43" })+    , (BaseNTok, defStyle{ tokenColor = toColor "#44AA43" })+    , (FloatTok, defStyle{ tokenColor = toColor "#44AA43" })+    , (CharTok, defStyle{ tokenColor = toColor "#049B0A" })+    , (StringTok, defStyle{ tokenColor = toColor "#049B0A" })+    , (CommentTok, defStyle{ tokenColor = toColor "#0066FF", tokenItalic = True })+    , (AlertTok, defStyle{ tokenColor = toColor "#ffff00" })+    , (FunctionTok, defStyle{ tokenColor = toColor "#FF9358", tokenBold = True })+    , (ErrorTok, defStyle{ tokenColor = toColor "ffff00", tokenBold = True })+    ]+  }++-- | Style based on haddock's source highlighting.+haddock :: Style+haddock = Style{+    backgroundColor = Nothing+  , defaultColor = Nothing+  , lineNumberColor = toColor "#aaaaaa"+  , lineNumberBackgroundColor = Nothing+  , tokenStyles =+    [ (KeywordTok, defStyle{ tokenColor = toColor "#0000FF" })+    , (CharTok, defStyle{ tokenColor = toColor "#008080" })+    , (StringTok, defStyle{ tokenColor = toColor "#008080" })+    , (CommentTok, defStyle{ tokenColor = toColor "#008000" })+    , (OtherTok, defStyle{ tokenColor = toColor "#ff4000" })+    , (AlertTok, defStyle{ tokenColor = toColor "#ff0000" })+    , (ErrorTok, defStyle{ tokenColor = toColor "ff0000", tokenBold = True })+    ]+  }++-- | 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 })+    ]+  }

@@ -1,7 +1,19 @@+{- |+   Module      : Text.Highlighting.Kate.Syntax+   Copyright   : Copyright (C) 2008-2011 John MacFarlane+   License     : GNU GPL, version 2 or above++   Maintainer  : John MacFarlane <jgm@berkeley.edu>+   Stability   : alpha+   Portability : portable++Token lexer for various languages.+-}+ module Text.Highlighting.Kate.Syntax ( highlightAs, languages, languagesByExtension,                                        languagesByFilename ) where import Data.Char (toLower)-import Text.Highlighting.Kate.Definitions+import Text.Highlighting.Kate.Types import Text.Highlighting.Kate.Common (matchGlobs) import qualified Text.Highlighting.Kate.Syntax.Actionscript as Actionscript import qualified Text.Highlighting.Kate.Syntax.Ada as Ada@@ -28,7 +40,6 @@ import qualified Text.Highlighting.Kate.Syntax.Diff as Diff import qualified Text.Highlighting.Kate.Syntax.Djangotemplate as Djangotemplate import qualified Text.Highlighting.Kate.Syntax.Doxygen as Doxygen-import qualified Text.Highlighting.Kate.Syntax.Doxygenlua as Doxygenlua import qualified Text.Highlighting.Kate.Syntax.Dtd as Dtd import qualified Text.Highlighting.Kate.Syntax.Eiffel as Eiffel import qualified Text.Highlighting.Kate.Syntax.Email as Email@@ -40,7 +51,6 @@ import qualified Text.Highlighting.Kate.Syntax.Haskell as Haskell import qualified Text.Highlighting.Kate.Syntax.Haxe as Haxe import qualified Text.Highlighting.Kate.Syntax.Html as Html-import qualified Text.Highlighting.Kate.Syntax.Ilerpg as Ilerpg import qualified Text.Highlighting.Kate.Syntax.Ini as Ini import qualified Text.Highlighting.Kate.Syntax.Java as Java import qualified Text.Highlighting.Kate.Syntax.Javadoc as Javadoc@@ -55,7 +65,6 @@ import qualified Text.Highlighting.Kate.Syntax.Mandoc as Mandoc import qualified Text.Highlighting.Kate.Syntax.Matlab as Matlab import qualified Text.Highlighting.Kate.Syntax.Maxima as Maxima-import qualified Text.Highlighting.Kate.Syntax.Mediawiki as Mediawiki import qualified Text.Highlighting.Kate.Syntax.Metafont as Metafont import qualified Text.Highlighting.Kate.Syntax.Mips as Mips import qualified Text.Highlighting.Kate.Syntax.Modula2 as Modula2@@ -90,7 +99,6 @@ import qualified Text.Highlighting.Kate.Syntax.Texinfo as Texinfo import qualified Text.Highlighting.Kate.Syntax.Verilog as Verilog import qualified Text.Highlighting.Kate.Syntax.Vhdl as Vhdl-import qualified Text.Highlighting.Kate.Syntax.Xharbour as Xharbour import qualified Text.Highlighting.Kate.Syntax.Xml as Xml import qualified Text.Highlighting.Kate.Syntax.Xorg as Xorg import qualified Text.Highlighting.Kate.Syntax.Xslt as Xslt@@ -100,11 +108,11 @@  -- | List of supported languages. languages :: [String]-languages = ["Actionscript","Ada","Alert","Alert_indent","Apache","Asn1","Asp","Awk","Bash","Bibtex","Boo","C","Changelog","Clojure","Cmake","Coffeescript","Coldfusion","Commonlisp","Cpp","Cs","Css","D","Diff","Djangotemplate","Doxygen","Doxygenlua","Dtd","Eiffel","Email","Erlang","Fortran","Fsharp","Gnuassembler","Go","Haskell","Haxe","Html","Ilerpg","Ini","Java","Javadoc","Javascript","Json","Jsp","Latex","Lex","LiterateHaskell","Lua","Makefile","Mandoc","Matlab","Maxima","Mediawiki","Metafont","Mips","Modula2","Modula3","Monobasic","Nasm","Noweb","Objectivec","Objectivecpp","Ocaml","Octave","Pascal","Perl","Php","Pike","Postscript","Prolog","Python","R","Relaxngcompact","Rhtml","Ruby","Scala","Scheme","Sci","Sed","Sgml","Sql","SqlMysql","SqlPostgresql","Tcl","Texinfo","Verilog","Vhdl","Xharbour","Xml","Xorg","Xslt","Xul","Yacc","Yaml"]+languages = ["Actionscript","Ada","Alert","Alert_indent","Apache","Asn1","Asp","Awk","Bash","Bibtex","Boo","C","Changelog","Clojure","Cmake","Coffeescript","Coldfusion","Commonlisp","Cpp","Cs","Css","D","Diff","Djangotemplate","Doxygen","Dtd","Eiffel","Email","Erlang","Fortran","Fsharp","Gnuassembler","Go","Haskell","Haxe","Html","Ini","Java","Javadoc","Javascript","Json","Jsp","Latex","Lex","LiterateHaskell","Lua","Makefile","Mandoc","Matlab","Maxima","Metafont","Mips","Modula2","Modula3","Monobasic","Nasm","Noweb","Objectivec","Objectivecpp","Ocaml","Octave","Pascal","Perl","Php","Pike","Postscript","Prolog","Python","R","Relaxngcompact","Rhtml","Ruby","Scala","Scheme","Sci","Sed","Sgml","Sql","SqlMysql","SqlPostgresql","Tcl","Texinfo","Verilog","Vhdl","Xml","Xorg","Xslt","Xul","Yacc","Yaml"]  -- | List of language extensions. languageExtensions :: [(String, String)]-languageExtensions = [("Actionscript", Actionscript.syntaxExtensions), ("Ada", Ada.syntaxExtensions), ("Alert", Alert.syntaxExtensions), ("Alert_indent", Alert_indent.syntaxExtensions), ("Apache", Apache.syntaxExtensions), ("Asn1", Asn1.syntaxExtensions), ("Asp", Asp.syntaxExtensions), ("Awk", Awk.syntaxExtensions), ("Bash", Bash.syntaxExtensions), ("Bibtex", Bibtex.syntaxExtensions), ("Boo", Boo.syntaxExtensions), ("C", C.syntaxExtensions), ("Changelog", Changelog.syntaxExtensions), ("Clojure", Clojure.syntaxExtensions), ("Cmake", Cmake.syntaxExtensions), ("Coffeescript", Coffeescript.syntaxExtensions), ("Coldfusion", Coldfusion.syntaxExtensions), ("Commonlisp", Commonlisp.syntaxExtensions), ("Cpp", Cpp.syntaxExtensions), ("Cs", Cs.syntaxExtensions), ("Css", Css.syntaxExtensions), ("D", D.syntaxExtensions), ("Diff", Diff.syntaxExtensions), ("Djangotemplate", Djangotemplate.syntaxExtensions), ("Doxygen", Doxygen.syntaxExtensions), ("Doxygenlua", Doxygenlua.syntaxExtensions), ("Dtd", Dtd.syntaxExtensions), ("Eiffel", Eiffel.syntaxExtensions), ("Email", Email.syntaxExtensions), ("Erlang", Erlang.syntaxExtensions), ("Fortran", Fortran.syntaxExtensions), ("Fsharp", Fsharp.syntaxExtensions), ("Gnuassembler", Gnuassembler.syntaxExtensions), ("Go", Go.syntaxExtensions), ("Haskell", Haskell.syntaxExtensions), ("Haxe", Haxe.syntaxExtensions), ("Html", Html.syntaxExtensions), ("Ilerpg", Ilerpg.syntaxExtensions), ("Ini", Ini.syntaxExtensions), ("Java", Java.syntaxExtensions), ("Javadoc", Javadoc.syntaxExtensions), ("Javascript", Javascript.syntaxExtensions), ("Json", Json.syntaxExtensions), ("Jsp", Jsp.syntaxExtensions), ("Latex", Latex.syntaxExtensions), ("Lex", Lex.syntaxExtensions), ("LiterateHaskell", LiterateHaskell.syntaxExtensions), ("Lua", Lua.syntaxExtensions), ("Makefile", Makefile.syntaxExtensions), ("Mandoc", Mandoc.syntaxExtensions), ("Matlab", Matlab.syntaxExtensions), ("Maxima", Maxima.syntaxExtensions), ("Mediawiki", Mediawiki.syntaxExtensions), ("Metafont", Metafont.syntaxExtensions), ("Mips", Mips.syntaxExtensions), ("Modula2", Modula2.syntaxExtensions), ("Modula3", Modula3.syntaxExtensions), ("Monobasic", Monobasic.syntaxExtensions), ("Nasm", Nasm.syntaxExtensions), ("Noweb", Noweb.syntaxExtensions), ("Objectivec", Objectivec.syntaxExtensions), ("Objectivecpp", Objectivecpp.syntaxExtensions), ("Ocaml", Ocaml.syntaxExtensions), ("Octave", Octave.syntaxExtensions), ("Pascal", Pascal.syntaxExtensions), ("Perl", Perl.syntaxExtensions), ("Php", Php.syntaxExtensions), ("Pike", Pike.syntaxExtensions), ("Postscript", Postscript.syntaxExtensions), ("Prolog", Prolog.syntaxExtensions), ("Python", Python.syntaxExtensions), ("R", R.syntaxExtensions), ("Relaxngcompact", Relaxngcompact.syntaxExtensions), ("Rhtml", Rhtml.syntaxExtensions), ("Ruby", Ruby.syntaxExtensions), ("Scala", Scala.syntaxExtensions), ("Scheme", Scheme.syntaxExtensions), ("Sci", Sci.syntaxExtensions), ("Sed", Sed.syntaxExtensions), ("Sgml", Sgml.syntaxExtensions), ("Sql", Sql.syntaxExtensions), ("SqlMysql", SqlMysql.syntaxExtensions), ("SqlPostgresql", SqlPostgresql.syntaxExtensions), ("Tcl", Tcl.syntaxExtensions), ("Texinfo", Texinfo.syntaxExtensions), ("Verilog", Verilog.syntaxExtensions), ("Vhdl", Vhdl.syntaxExtensions), ("Xharbour", Xharbour.syntaxExtensions), ("Xml", Xml.syntaxExtensions), ("Xorg", Xorg.syntaxExtensions), ("Xslt", Xslt.syntaxExtensions), ("Xul", Xul.syntaxExtensions), ("Yacc", Yacc.syntaxExtensions), ("Yaml", Yaml.syntaxExtensions)]+languageExtensions = [("Actionscript", Actionscript.syntaxExtensions), ("Ada", Ada.syntaxExtensions), ("Alert", Alert.syntaxExtensions), ("Alert_indent", Alert_indent.syntaxExtensions), ("Apache", Apache.syntaxExtensions), ("Asn1", Asn1.syntaxExtensions), ("Asp", Asp.syntaxExtensions), ("Awk", Awk.syntaxExtensions), ("Bash", Bash.syntaxExtensions), ("Bibtex", Bibtex.syntaxExtensions), ("Boo", Boo.syntaxExtensions), ("C", C.syntaxExtensions), ("Changelog", Changelog.syntaxExtensions), ("Clojure", Clojure.syntaxExtensions), ("Cmake", Cmake.syntaxExtensions), ("Coffeescript", Coffeescript.syntaxExtensions), ("Coldfusion", Coldfusion.syntaxExtensions), ("Commonlisp", Commonlisp.syntaxExtensions), ("Cpp", Cpp.syntaxExtensions), ("Cs", Cs.syntaxExtensions), ("Css", Css.syntaxExtensions), ("D", D.syntaxExtensions), ("Diff", Diff.syntaxExtensions), ("Djangotemplate", Djangotemplate.syntaxExtensions), ("Doxygen", Doxygen.syntaxExtensions), ("Dtd", Dtd.syntaxExtensions), ("Eiffel", Eiffel.syntaxExtensions), ("Email", Email.syntaxExtensions), ("Erlang", Erlang.syntaxExtensions), ("Fortran", Fortran.syntaxExtensions), ("Fsharp", Fsharp.syntaxExtensions), ("Gnuassembler", Gnuassembler.syntaxExtensions), ("Go", Go.syntaxExtensions), ("Haskell", Haskell.syntaxExtensions), ("Haxe", Haxe.syntaxExtensions), ("Html", Html.syntaxExtensions), ("Ini", Ini.syntaxExtensions), ("Java", Java.syntaxExtensions), ("Javadoc", Javadoc.syntaxExtensions), ("Javascript", Javascript.syntaxExtensions), ("Json", Json.syntaxExtensions), ("Jsp", Jsp.syntaxExtensions), ("Latex", Latex.syntaxExtensions), ("Lex", Lex.syntaxExtensions), ("LiterateHaskell", LiterateHaskell.syntaxExtensions), ("Lua", Lua.syntaxExtensions), ("Makefile", Makefile.syntaxExtensions), ("Mandoc", Mandoc.syntaxExtensions), ("Matlab", Matlab.syntaxExtensions), ("Maxima", Maxima.syntaxExtensions), ("Metafont", Metafont.syntaxExtensions), ("Mips", Mips.syntaxExtensions), ("Modula2", Modula2.syntaxExtensions), ("Modula3", Modula3.syntaxExtensions), ("Monobasic", Monobasic.syntaxExtensions), ("Nasm", Nasm.syntaxExtensions), ("Noweb", Noweb.syntaxExtensions), ("Objectivec", Objectivec.syntaxExtensions), ("Objectivecpp", Objectivecpp.syntaxExtensions), ("Ocaml", Ocaml.syntaxExtensions), ("Octave", Octave.syntaxExtensions), ("Pascal", Pascal.syntaxExtensions), ("Perl", Perl.syntaxExtensions), ("Php", Php.syntaxExtensions), ("Pike", Pike.syntaxExtensions), ("Postscript", Postscript.syntaxExtensions), ("Prolog", Prolog.syntaxExtensions), ("Python", Python.syntaxExtensions), ("R", R.syntaxExtensions), ("Relaxngcompact", Relaxngcompact.syntaxExtensions), ("Rhtml", Rhtml.syntaxExtensions), ("Ruby", Ruby.syntaxExtensions), ("Scala", Scala.syntaxExtensions), ("Scheme", Scheme.syntaxExtensions), ("Sci", Sci.syntaxExtensions), ("Sed", Sed.syntaxExtensions), ("Sgml", Sgml.syntaxExtensions), ("Sql", Sql.syntaxExtensions), ("SqlMysql", SqlMysql.syntaxExtensions), ("SqlPostgresql", SqlPostgresql.syntaxExtensions), ("Tcl", Tcl.syntaxExtensions), ("Texinfo", Texinfo.syntaxExtensions), ("Verilog", Verilog.syntaxExtensions), ("Vhdl", Vhdl.syntaxExtensions), ("Xml", Xml.syntaxExtensions), ("Xorg", Xorg.syntaxExtensions), ("Xslt", Xslt.syntaxExtensions), ("Xul", Xul.syntaxExtensions), ("Yacc", Yacc.syntaxExtensions), ("Yaml", Yaml.syntaxExtensions)]  -- | Returns a list of languages appropriate for the given file extension. languagesByExtension :: String -> [String]@@ -115,10 +123,15 @@ languagesByFilename :: FilePath -> [String] languagesByFilename fn = [lang | (lang, globs) <- languageExtensions, matchGlobs fn globs] --- | Highlight source code using a specified syntax definition.-highlightAs :: String                        -- ^ Language syntax-            -> String                        -- ^ Source code to highlight-            -> Either String [SourceLine]    -- ^ Either error message or result+-- | Highlight source code. The source language may be specified+-- by its canonical name (case-insensitive) or by a canonical+-- extension (if unique).+-- The parsers read the input lazily and parse line by line;+-- results are returned immediately.+-- Supported languages: @actionscript@, @ada@, @alert@, @alert_indent@, @apache@, @asn1@, @asp@, @awk@, @bash@, @bibtex@, @boo@, @c@, @changelog@, @clojure@, @cmake@, @coffeescript@, @coldfusion@, @commonlisp@, @cpp@, @cs@, @css@, @d@, @diff@, @djangotemplate@, @doxygen@, @dtd@, @eiffel@, @email@, @erlang@, @fortran@, @fsharp@, @gnuassembler@, @go@, @haskell@, @haxe@, @html@, @ini@, @java@, @javadoc@, @javascript@, @json@, @jsp@, @latex@, @lex@, @literatehaskell@, @lua@, @makefile@, @mandoc@, @matlab@, @maxima@, @metafont@, @mips@, @modula2@, @modula3@, @monobasic@, @nasm@, @noweb@, @objectivec@, @objectivecpp@, @ocaml@, @octave@, @pascal@, @perl@, @php@, @pike@, @postscript@, @prolog@, @python@, @r@, @relaxngcompact@, @rhtml@, @ruby@, @scala@, @scheme@, @sci@, @sed@, @sgml@, @sql@, @sqlmysql@, @sqlpostgresql@, @tcl@, @texinfo@, @verilog@, @vhdl@, @xml@, @xorg@, @xslt@, @xul@, @yacc@, @yaml@.+highlightAs :: String         -- ^ Language syntax (e.g. "haskell") or extension (e.g. "hs").+            -> String         -- ^ Source code to highlight+            -> [SourceLine]   -- ^ List of highlighted source lines highlightAs lang =   let lang'  = map toLower lang       lang'' = if lang' `elem` map (map toLower) languages@@ -152,7 +165,6 @@         "diff" -> Diff.highlight         "djangotemplate" -> Djangotemplate.highlight         "doxygen" -> Doxygen.highlight-        "doxygenlua" -> Doxygenlua.highlight         "dtd" -> Dtd.highlight         "eiffel" -> Eiffel.highlight         "email" -> Email.highlight@@ -164,7 +176,6 @@         "haskell" -> Haskell.highlight         "haxe" -> Haxe.highlight         "html" -> Html.highlight-        "ilerpg" -> Ilerpg.highlight         "ini" -> Ini.highlight         "java" -> Java.highlight         "javadoc" -> Javadoc.highlight@@ -179,7 +190,6 @@         "mandoc" -> Mandoc.highlight         "matlab" -> Matlab.highlight         "maxima" -> Maxima.highlight-        "mediawiki" -> Mediawiki.highlight         "metafont" -> Metafont.highlight         "mips" -> Mips.highlight         "modula2" -> Modula2.highlight@@ -214,11 +224,10 @@         "texinfo" -> Texinfo.highlight         "verilog" -> Verilog.highlight         "vhdl" -> Vhdl.highlight-        "xharbour" -> Xharbour.highlight         "xml" -> Xml.highlight         "xorg" -> Xorg.highlight         "xslt" -> Xslt.highlight         "xul" -> Xul.highlight         "yacc" -> Yacc.highlight         "yaml" -> Yaml.highlight-        _ -> (\_ -> Left ("Unknown language: " ++ lang))+        _ -> map (\l -> [(NormalTok, l)]) . lines

@@ -1,7 +1,19 @@+{- |+   Module      : Text.Highlighting.Kate.Syntax+   Copyright   : Copyright (C) 2008-2011 John MacFarlane+   License     : GNU GPL, version 2 or above++   Maintainer  : John MacFarlane <jgm@berkeley.edu>+   Stability   : alpha+   Portability : portable++Token lexer for various languages.+-}+ module Text.Highlighting.Kate.Syntax ( highlightAs, languages, languagesByExtension,                                        languagesByFilename ) where import Data.Char (toLower)-import Text.Highlighting.Kate.Definitions+import Text.Highlighting.Kate.Types import Text.Highlighting.Kate.Common (matchGlobs) @imports@ @@ -22,10 +34,15 @@ languagesByFilename :: FilePath -> [String] languagesByFilename fn = [lang | (lang, globs) <- languageExtensions, matchGlobs fn globs] --- | Highlight source code using a specified syntax definition.-highlightAs :: String                        -- ^ Language syntax-            -> String                        -- ^ Source code to highlight-            -> Either String [SourceLine]    -- ^ Either error message or result+-- | Highlight source code. The source language may be specified+-- by its canonical name (case-insensitive) or by a canonical+-- extension (if unique).+-- The parsers read the input lazily and parse line by line;+-- results are returned immediately.+-- Supported languages: @supportedlanguages@.+highlightAs :: String         -- ^ Language syntax (e.g. "haskell") or extension (e.g. "hs").+            -> String         -- ^ Source code to highlight+            -> [SourceLine]   -- ^ List of highlighted source lines highlightAs lang =   let lang'  = map toLower lang       lang'' = if lang' `elem` map (map toLower) languages@@ -35,4 +52,4 @@                             _    -> lang'   in  case lang'' of         @cases@-        _ -> (\_ -> Left ("Unknown language: " ++ lang))+        _ -> map (\l -> [(NormalTok, l)]) . lines

@@ -1,16 +1,19 @@-{- This module was generated from data in the Kate syntax highlighting file actionscript.xml, version 1.0,-   by  Aaron Miller (armantic101@gmail.com) -}+{- This module was generated from data in the Kate syntax+   highlighting file actionscript.xml, version 1.0, by Aaron Miller (armantic101@gmail.com) -} -module Text.Highlighting.Kate.Syntax.Actionscript ( highlight, parseExpression, syntaxName, syntaxExtensions ) where-import Text.Highlighting.Kate.Definitions+module Text.Highlighting.Kate.Syntax.Actionscript+          (highlight, parseExpression, syntaxName, syntaxExtensions)+where+import Text.Highlighting.Kate.Types import Text.Highlighting.Kate.Common import qualified Text.Highlighting.Kate.Syntax.Javadoc-import Text.ParserCombinators.Parsec-import Control.Monad (when)+import Text.ParserCombinators.Parsec hiding (State) import Data.Map (fromList)-import Data.Maybe (fromMaybe, maybeToList)-+import Control.Monad.State+import Data.Char (isSpace)+import Data.Maybe (fromMaybe) import qualified Data.Set as Set+ -- | Full name of language. syntaxName :: String syntaxName = "ActionScript 2.0"@@ -20,60 +23,47 @@ syntaxExtensions = "*.as"  -- | Highlight source code using this syntax definition.-highlight :: String -> Either String [SourceLine]-highlight input =-  case runParser parseSource startingState "source" input of-    Left err     -> Left $ show err-    Right result -> Right result+highlight :: String -> [SourceLine]+highlight input = evalState (mapM parseSourceLine $ lines input) startingState +parseSourceLine :: String -> State SyntaxState SourceLine+parseSourceLine = mkParseSourceLine parseExpressionInternal pEndLine+ -- | Parse an expression using appropriate local context.-parseExpression :: GenParser Char SyntaxState LabeledSource+parseExpression :: KateParser Token parseExpression = do   st <- getState   let oldLang = synStLanguage st   setState $ st { synStLanguage = "ActionScript 2.0" }   context <- currentContext <|> (pushContext "Normal" >> currentContext)   result <- parseRules context+  optional $ eof >> pEndLine   updateState $ \st -> st { synStLanguage = oldLang }   return result -parseSource = do -  lineContents <- lookAhead wholeLine-  updateState $ \st -> st { synStCurrentLine = lineContents }-  result <- manyTill parseSourceLine eof-  return $ map normalizeHighlighting result--startingState = SyntaxState {synStContexts = fromList [("ActionScript 2.0",["Normal"])], synStLanguage = "ActionScript 2.0", synStCurrentLine = "", synStCharsParsedInLine = 0, synStPrevChar = '\n', synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}--parseSourceLine = manyTill parseExpressionInternal pEndLine+startingState = SyntaxState {synStContexts = fromList [("ActionScript 2.0",["Normal"])], synStLanguage = "ActionScript 2.0", synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do-  lookAhead $ newline <|> (eof >> return '\n')   context <- currentContext   case context of-    "Normal" -> return () >> pHandleEndLine+    "Normal" -> return ()     "String" -> (popContext) >> pEndLine     "Member" -> (popContext) >> pEndLine     "StaticImports" -> (popContext) >> pEndLine     "Imports" -> (popContext) >> pEndLine     "Commentar 1" -> (popContext) >> pEndLine-    "Commentar 2" -> return () >> pHandleEndLine-    _ -> pHandleEndLine+    "Commentar 2" -> return ()+    _ -> return ()  withAttribute attr txt = do   when (null txt) $ fail "Parser matched no text"-  let labs = attr : maybeToList (lookup attr styles)-  st <- getState-  let oldCharsParsed = synStCharsParsedInLine st-  let prevchar = if null txt then '\n' else last txt-  updateState $ \st -> st { synStCharsParsedInLine = oldCharsParsed + length txt, synStPrevChar = prevchar } -  return (labs, txt)--styles = [("Keyword","kw"),("Function","fu"),("StaticImports","kw"),("Imports","kw"),("Data Type","dt"),("Decimal","dv"),("Octal","bn"),("Hex","bn"),("Float","fl"),("Char","ch"),("String","st"),("String Char","ch"),("Comment","co")]+  updateState $ \st -> st { synStPrevChar = last txt+                          , synStPrevNonspace = synStPrevNonspace st || not (all isSpace txt) }+  return (attr, txt)  parseExpressionInternal = do   context <- currentContext-  parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes))+  parseRules context <|> (pDefault >>= withAttribute (fromMaybe NormalTok $ lookup context defaultAttributes))  list_properties = Set.fromList $ words $ "_accProps _focusrect _global _highquality _level _parent _quality _root _soundbuftime maxscroll scroll this" list_global'5ffunctions = Set.fromList $ words $ "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"@@ -92,102 +82,96 @@ regex_'5cb'5b'5fa'2dzA'2dZ'5d'5cw'2a'28'3f'3d'5b'5cs'5d'2a'29 = compileRegex "\\b[_a-zA-Z]\\w*(?=[\\s]*)" regex_'5cs'2a'2e'2a'24 = compileRegex "\\s*.*$" -defaultAttributes = [("Normal","Normal Text"),("String","String"),("Member","Normal Text"),("StaticImports","Normal Text"),("Imports","Normal Text"),("Commentar 1","Comment"),("Commentar 2","Comment")]+defaultAttributes = [("Normal",NormalTok),("String",StringTok),("Member",NormalTok),("StaticImports",NormalTok),("Imports",NormalTok),("Commentar 1",CommentTok),("Commentar 2",CommentTok)] -parseRules "Normal" = -  do (attr, result) <- (((Text.Highlighting.Kate.Syntax.Javadoc.parseExpression))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_properties >>= withAttribute "Properties"))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_global'5ffunctions >>= withAttribute "Global Functions"))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_classes >>= withAttribute "Classes"))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_keywords >>= withAttribute "Keyword"))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_const >>= withAttribute "Constants"))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_types >>= withAttribute "Data Type"))-                        <|>-                        (withChildren (pFloat >>= withAttribute "Float") ((pAnyChar "fF" >>= withAttribute "Float")))-                        <|>-                        ((pHlCOct >>= withAttribute "Octal"))-                        <|>-                        ((pHlCHex >>= withAttribute "Hex"))-                        <|>-                        (withChildren (pInt >>= withAttribute "Decimal") (((pString False "ULL" >>= withAttribute "Decimal"))-                                                                          <|>-                                                                          ((pString False "LUL" >>= withAttribute "Decimal"))-                                                                          <|>-                                                                          ((pString False "LLU" >>= withAttribute "Decimal"))-                                                                          <|>-                                                                          ((pString False "UL" >>= withAttribute "Decimal"))-                                                                          <|>-                                                                          ((pString False "LU" >>= withAttribute "Decimal"))-                                                                          <|>-                                                                          ((pString False "LL" >>= withAttribute "Decimal"))-                                                                          <|>-                                                                          ((pString False "U" >>= withAttribute "Decimal"))-                                                                          <|>-                                                                          ((pString False "L" >>= withAttribute "Decimal"))))-                        <|>-                        ((pHlCChar >>= withAttribute "Char"))-                        <|>-                        ((pRegExpr regex_'2f'2f'5cs'2aBEGIN'2e'2a'24 >>= withAttribute "Decimal"))-                        <|>-                        ((pRegExpr regex_'2f'2f'5cs'2aEND'2e'2a'24 >>= withAttribute "Decimal"))-                        <|>-                        ((pDetectChar False '"' >>= withAttribute "String") >>~ pushContext "String")-                        <|>-                        ((pDetect2Chars False '/' '/' >>= withAttribute "Comment") >>~ pushContext "Commentar 1")-                        <|>-                        ((pDetect2Chars False '/' '*' >>= withAttribute "Comment") >>~ pushContext "Commentar 2")-                        <|>-                        ((pDetectChar False '{' >>= withAttribute "Symbol"))-                        <|>-                        ((pDetectChar False '}' >>= withAttribute "Symbol"))-                        <|>-                        ((pRegExpr regex_'5c'2e'7b3'2c3'7d'5cs'2b >>= withAttribute "Keyword"))-                        <|>-                        ((pRegExpr regex_'5cb'28import'5cs'2bstatic'29'5cb >>= withAttribute "Keyword") >>~ pushContext "StaticImports")-                        <|>-                        ((pRegExpr regex_'5cb'28package'7cimport'29'5cb >>= withAttribute "Keyword") >>~ pushContext "Imports")-                        <|>-                        ((pRegExpr regex_'5cb'5b'5f'5cw'5d'5b'5f'5cw'5cd'5d'2a'28'3f'3d'5b'5cs'5d'2a'28'2f'5c'2a'5cs'2a'5cd'2b'5cs'2a'5c'2a'2f'5cs'2a'29'3f'5b'28'5d'29 >>= withAttribute "Function"))-                        <|>-                        ((pRegExpr regex_'5b'2e'5d'7b1'2c1'7d >>= withAttribute "Symbol") >>~ pushContext "Member")-                        <|>-                        ((pAnyChar ":!%&()+,-/.*<=>?[]|~^;" >>= withAttribute "Symbol")))-     return (attr, result)+parseRules "Normal" =+  (((Text.Highlighting.Kate.Syntax.Javadoc.parseExpression))+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_properties >>= withAttribute NormalTok))+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_global'5ffunctions >>= withAttribute NormalTok))+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_classes >>= withAttribute NormalTok))+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_keywords >>= withAttribute KeywordTok))+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_const >>= withAttribute NormalTok))+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_types >>= withAttribute DataTypeTok))+   <|>+   (withChildren (pFloat >>= withAttribute FloatTok) ((pAnyChar "fF" >>= withAttribute FloatTok)))+   <|>+   ((pHlCOct >>= withAttribute BaseNTok))+   <|>+   ((pHlCHex >>= withAttribute BaseNTok))+   <|>+   (withChildren (pInt >>= withAttribute DecValTok) (((pString False "ULL" >>= withAttribute DecValTok))+                                                     <|>+                                                     ((pString False "LUL" >>= withAttribute DecValTok))+                                                     <|>+                                                     ((pString False "LLU" >>= withAttribute DecValTok))+                                                     <|>+                                                     ((pString False "UL" >>= withAttribute DecValTok))+                                                     <|>+                                                     ((pString False "LU" >>= withAttribute DecValTok))+                                                     <|>+                                                     ((pString False "LL" >>= withAttribute DecValTok))+                                                     <|>+                                                     ((pString False "U" >>= withAttribute DecValTok))+                                                     <|>+                                                     ((pString False "L" >>= withAttribute DecValTok))))+   <|>+   ((pHlCChar >>= withAttribute CharTok))+   <|>+   ((pRegExpr regex_'2f'2f'5cs'2aBEGIN'2e'2a'24 >>= withAttribute DecValTok))+   <|>+   ((pRegExpr regex_'2f'2f'5cs'2aEND'2e'2a'24 >>= withAttribute DecValTok))+   <|>+   ((pDetectChar False '"' >>= withAttribute StringTok) >>~ pushContext "String")+   <|>+   ((pDetect2Chars False '/' '/' >>= withAttribute CommentTok) >>~ pushContext "Commentar 1")+   <|>+   ((pDetect2Chars False '/' '*' >>= withAttribute CommentTok) >>~ pushContext "Commentar 2")+   <|>+   ((pDetectChar False '{' >>= withAttribute NormalTok))+   <|>+   ((pDetectChar False '}' >>= withAttribute NormalTok))+   <|>+   ((pRegExpr regex_'5c'2e'7b3'2c3'7d'5cs'2b >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5cb'28import'5cs'2bstatic'29'5cb >>= withAttribute KeywordTok) >>~ pushContext "StaticImports")+   <|>+   ((pRegExpr regex_'5cb'28package'7cimport'29'5cb >>= withAttribute KeywordTok) >>~ pushContext "Imports")+   <|>+   ((pRegExpr regex_'5cb'5b'5f'5cw'5d'5b'5f'5cw'5cd'5d'2a'28'3f'3d'5b'5cs'5d'2a'28'2f'5c'2a'5cs'2a'5cd'2b'5cs'2a'5c'2a'2f'5cs'2a'29'3f'5b'28'5d'29 >>= withAttribute FunctionTok))+   <|>+   ((pRegExpr regex_'5b'2e'5d'7b1'2c1'7d >>= withAttribute NormalTok) >>~ pushContext "Member")+   <|>+   ((pAnyChar ":!%&()+,-/.*<=>?[]|~^;" >>= withAttribute NormalTok))) -parseRules "String" = -  do (attr, result) <- (((pLineContinue >>= withAttribute "String"))-                        <|>-                        ((pHlCStringChar >>= withAttribute "String Char"))-                        <|>-                        ((pDetectChar False '"' >>= withAttribute "String") >>~ (popContext)))-     return (attr, result)+parseRules "String" =+  (((pLineContinue >>= withAttribute StringTok))+   <|>+   ((pHlCStringChar >>= withAttribute CharTok))+   <|>+   ((pDetectChar False '"' >>= withAttribute StringTok) >>~ (popContext))) -parseRules "Member" = -  do (attr, result) <- (((pRegExpr regex_'5cb'5b'5fa'2dzA'2dZ'5d'5cw'2a'28'3f'3d'5b'5cs'5d'2a'29 >>= withAttribute "Function") >>~ (popContext))-                        <|>-                        ((popContext) >> return ([], "")))-     return (attr, result)+parseRules "Member" =+  (((pRegExpr regex_'5cb'5b'5fa'2dzA'2dZ'5d'5cw'2a'28'3f'3d'5b'5cs'5d'2a'29 >>= withAttribute FunctionTok) >>~ (popContext))+   <|>+   ((popContext) >> currentContext >>= parseRules)) -parseRules "StaticImports" = -  do (attr, result) <- ((pRegExpr regex_'5cs'2a'2e'2a'24 >>= withAttribute "StaticImports") >>~ (popContext))-     return (attr, result)+parseRules "StaticImports" =+  ((pRegExpr regex_'5cs'2a'2e'2a'24 >>= withAttribute KeywordTok) >>~ (popContext)) -parseRules "Imports" = -  do (attr, result) <- ((pRegExpr regex_'5cs'2a'2e'2a'24 >>= withAttribute "Imports") >>~ (popContext))-     return (attr, result)+parseRules "Imports" =+  ((pRegExpr regex_'5cs'2a'2e'2a'24 >>= withAttribute KeywordTok) >>~ (popContext)) -parseRules "Commentar 1" = +parseRules "Commentar 1" =   pzero -parseRules "Commentar 2" = -  do (attr, result) <- ((pDetect2Chars False '*' '/' >>= withAttribute "Comment") >>~ (popContext))-     return (attr, result)+parseRules "Commentar 2" =+  ((pDetect2Chars False '*' '/' >>= withAttribute CommentTok) >>~ (popContext))  parseRules "" = parseRules "Normal" 

@@ -1,15 +1,18 @@-{- This module was generated from data in the Kate syntax highlighting file ada.xml, version 1.07,-   by   -}+{- This module was generated from data in the Kate syntax+   highlighting file ada.xml, version 1.07, by  -} -module Text.Highlighting.Kate.Syntax.Ada ( highlight, parseExpression, syntaxName, syntaxExtensions ) where-import Text.Highlighting.Kate.Definitions+module Text.Highlighting.Kate.Syntax.Ada+          (highlight, parseExpression, syntaxName, syntaxExtensions)+where+import Text.Highlighting.Kate.Types import Text.Highlighting.Kate.Common-import Text.ParserCombinators.Parsec-import Control.Monad (when)+import Text.ParserCombinators.Parsec hiding (State) import Data.Map (fromList)-import Data.Maybe (fromMaybe, maybeToList)-+import Control.Monad.State+import Data.Char (isSpace)+import Data.Maybe (fromMaybe) import qualified Data.Set as Set+ -- | Full name of language. syntaxName :: String syntaxName = "Ada"@@ -19,57 +22,44 @@ syntaxExtensions = "*.adb;*.ads;*.ada;*.a"  -- | Highlight source code using this syntax definition.-highlight :: String -> Either String [SourceLine]-highlight input =-  case runParser parseSource startingState "source" input of-    Left err     -> Left $ show err-    Right result -> Right result+highlight :: String -> [SourceLine]+highlight input = evalState (mapM parseSourceLine $ lines input) startingState +parseSourceLine :: String -> State SyntaxState SourceLine+parseSourceLine = mkParseSourceLine parseExpressionInternal pEndLine+ -- | Parse an expression using appropriate local context.-parseExpression :: GenParser Char SyntaxState LabeledSource+parseExpression :: KateParser Token parseExpression = do   st <- getState   let oldLang = synStLanguage st   setState $ st { synStLanguage = "Ada" }   context <- currentContext <|> (pushContext "Default" >> currentContext)   result <- parseRules context+  optional $ eof >> pEndLine   updateState $ \st -> st { synStLanguage = oldLang }   return result -parseSource = do -  lineContents <- lookAhead wholeLine-  updateState $ \st -> st { synStCurrentLine = lineContents }-  result <- manyTill parseSourceLine eof-  return $ map normalizeHighlighting result--startingState = SyntaxState {synStContexts = fromList [("Ada",["Default"])], synStLanguage = "Ada", synStCurrentLine = "", synStCharsParsedInLine = 0, synStPrevChar = '\n', synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}--parseSourceLine = manyTill parseExpressionInternal pEndLine+startingState = SyntaxState {synStContexts = fromList [("Ada",["Default"])], synStLanguage = "Ada", synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}  pEndLine = do-  lookAhead $ newline <|> (eof >> return '\n')   context <- currentContext   case context of-    "Default" -> return () >> pHandleEndLine+    "Default" -> return ()     "Region Marker" -> (popContext) >> pEndLine     "String" -> (popContext) >> pEndLine     "Comment" -> (popContext) >> pEndLine-    _ -> pHandleEndLine+    _ -> return ()  withAttribute attr txt = do   when (null txt) $ fail "Parser matched no text"-  let labs = attr : maybeToList (lookup attr styles)-  st <- getState-  let oldCharsParsed = synStCharsParsedInLine st-  let prevchar = if null txt then '\n' else last txt-  updateState $ \st -> st { synStCharsParsedInLine = oldCharsParsed + length txt, synStPrevChar = prevchar } -  return (labs, txt)--styles = [("Keyword","kw"),("Pragmas","kw"),("Data Type","dt"),("Decimal","dv"),("Base-N","bn"),("Float","fl"),("Char","ch"),("String","st"),("Comment","co"),("Region Marker","re")]+  updateState $ \st -> st { synStPrevChar = last txt+                          , synStPrevNonspace = synStPrevNonspace st || not (all isSpace txt) }+  return (attr, txt)  parseExpressionInternal = do   context <- currentContext-  parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes))+  parseRules context <|> (pDefault >>= withAttribute (fromMaybe NormalTok $ lookup context defaultAttributes))  list_keywords = Set.fromList $ words $ "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 rem record renames requeue return reverse separate subtype tagged task terminate then type until use when while with xor" list_pragmas = Set.fromList $ words $ "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"@@ -89,64 +79,62 @@ regex_'5cbend'5cb = compileRegex "\\bend\\b" regex_'27'2e'27 = compileRegex "'.'" -defaultAttributes = [("Default","Normal Text"),("Region Marker","Region Marker"),("String","String"),("Comment","Comment")]+defaultAttributes = [("Default",NormalTok),("Region Marker",RegionMarkerTok),("String",StringTok),("Comment",CommentTok)] -parseRules "Default" = -  do (attr, result) <- (((pRegExpr regex_'5cbrecord'5cb >>= withAttribute "Keyword"))-                        <|>-                        ((pRegExpr regex_'5cbend'5cs'2brecord'5cb >>= withAttribute "Keyword"))-                        <|>-                        ((pRegExpr regex_'5cbcase'5cb >>= withAttribute "Keyword"))-                        <|>-                        ((pRegExpr regex_'5cbend'5cs'2bcase'5cb >>= withAttribute "Keyword"))-                        <|>-                        ((pRegExpr regex_'5cbif'5cb >>= withAttribute "Keyword"))-                        <|>-                        ((pRegExpr regex_'5cbend'5cs'2bif'5cb >>= withAttribute "Keyword"))-                        <|>-                        ((pRegExpr regex_'5cbloop'5cb >>= withAttribute "Keyword"))-                        <|>-                        ((pRegExpr regex_'5cbend'5cs'2bloop'5cb >>= withAttribute "Keyword"))-                        <|>-                        ((pRegExpr regex_'5cbselect'5cb >>= withAttribute "Keyword"))-                        <|>-                        ((pRegExpr regex_'5cbend'5cs'2bselect'5cb >>= withAttribute "Keyword"))-                        <|>-                        ((pRegExpr regex_'5cbbegin'5cb >>= withAttribute "Keyword"))-                        <|>-                        ((pRegExpr regex_'5cbend'5cb >>= withAttribute "Keyword"))-                        <|>-                        ((pFirstNonSpace >> pString False "--  BEGIN" >>= withAttribute "Region Marker") >>~ pushContext "Region Marker")-                        <|>-                        ((pFirstNonSpace >> pString False "--  END" >>= withAttribute "Region Marker") >>~ pushContext "Region Marker")-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_keywords >>= withAttribute "Keyword"))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_pragmas >>= withAttribute "Pragmas"))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_types >>= withAttribute "Data Type"))-                        <|>-                        ((pFloat >>= withAttribute "Float"))-                        <|>-                        ((pInt >>= withAttribute "Decimal"))-                        <|>-                        ((pRegExpr regex_'27'2e'27 >>= withAttribute "Char"))-                        <|>-                        ((pDetectChar False '"' >>= withAttribute "String") >>~ pushContext "String")-                        <|>-                        ((pDetect2Chars False '-' '-' >>= withAttribute "Comment") >>~ pushContext "Comment")-                        <|>-                        ((pAnyChar ":!%&()+,-/.*<=>|" >>= withAttribute "Symbol")))-     return (attr, result)+parseRules "Default" =+  (((pRegExpr regex_'5cbrecord'5cb >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5cbend'5cs'2brecord'5cb >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5cbcase'5cb >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5cbend'5cs'2bcase'5cb >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5cbif'5cb >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5cbend'5cs'2bif'5cb >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5cbloop'5cb >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5cbend'5cs'2bloop'5cb >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5cbselect'5cb >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5cbend'5cs'2bselect'5cb >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5cbbegin'5cb >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5cbend'5cb >>= withAttribute KeywordTok))+   <|>+   ((pFirstNonSpace >> pString False "--  BEGIN" >>= withAttribute RegionMarkerTok) >>~ pushContext "Region Marker")+   <|>+   ((pFirstNonSpace >> pString False "--  END" >>= withAttribute RegionMarkerTok) >>~ pushContext "Region Marker")+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_keywords >>= withAttribute KeywordTok))+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_pragmas >>= withAttribute KeywordTok))+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_types >>= withAttribute DataTypeTok))+   <|>+   ((pFloat >>= withAttribute FloatTok))+   <|>+   ((pInt >>= withAttribute DecValTok))+   <|>+   ((pRegExpr regex_'27'2e'27 >>= withAttribute CharTok))+   <|>+   ((pDetectChar False '"' >>= withAttribute StringTok) >>~ pushContext "String")+   <|>+   ((pDetect2Chars False '-' '-' >>= withAttribute CommentTok) >>~ pushContext "Comment")+   <|>+   ((pAnyChar ":!%&()+,-/.*<=>|" >>= withAttribute NormalTok))) -parseRules "Region Marker" = +parseRules "Region Marker" =   pzero -parseRules "String" = -  do (attr, result) <- ((pDetectChar False '"' >>= withAttribute "String") >>~ (popContext))-     return (attr, result)+parseRules "String" =+  ((pDetectChar False '"' >>= withAttribute StringTok) >>~ (popContext)) -parseRules "Comment" = +parseRules "Comment" =   pzero  parseRules "" = parseRules "Default"

@@ -1,15 +1,18 @@-{- This module was generated from data in the Kate syntax highlighting file alert.xml, version 1.08,-   by  Dominik Haumann (dhdev@gmx.de) -}+{- This module was generated from data in the Kate syntax+   highlighting file alert.xml, version 1.08, by Dominik Haumann (dhdev@gmx.de) -} -module Text.Highlighting.Kate.Syntax.Alert ( highlight, parseExpression, syntaxName, syntaxExtensions ) where-import Text.Highlighting.Kate.Definitions+module Text.Highlighting.Kate.Syntax.Alert+          (highlight, parseExpression, syntaxName, syntaxExtensions)+where+import Text.Highlighting.Kate.Types import Text.Highlighting.Kate.Common-import Text.ParserCombinators.Parsec-import Control.Monad (when)+import Text.ParserCombinators.Parsec hiding (State) import Data.Map (fromList)-import Data.Maybe (fromMaybe, maybeToList)-+import Control.Monad.State+import Data.Char (isSpace)+import Data.Maybe (fromMaybe) import qualified Data.Set as Set+ -- | Full name of language. syntaxName :: String syntaxName = "Alerts"@@ -19,63 +22,49 @@ syntaxExtensions = ""  -- | Highlight source code using this syntax definition.-highlight :: String -> Either String [SourceLine]-highlight input =-  case runParser parseSource startingState "source" input of-    Left err     -> Left $ show err-    Right result -> Right result+highlight :: String -> [SourceLine]+highlight input = evalState (mapM parseSourceLine $ lines input) startingState +parseSourceLine :: String -> State SyntaxState SourceLine+parseSourceLine = mkParseSourceLine parseExpressionInternal pEndLine+ -- | Parse an expression using appropriate local context.-parseExpression :: GenParser Char SyntaxState LabeledSource+parseExpression :: KateParser Token parseExpression = do   st <- getState   let oldLang = synStLanguage st   setState $ st { synStLanguage = "Alerts" }   context <- currentContext <|> (pushContext "Normal Text" >> currentContext)   result <- parseRules context+  optional $ eof >> pEndLine   updateState $ \st -> st { synStLanguage = oldLang }   return result -parseSource = do -  lineContents <- lookAhead wholeLine-  updateState $ \st -> st { synStCurrentLine = lineContents }-  result <- manyTill parseSourceLine eof-  return $ map normalizeHighlighting result--startingState = SyntaxState {synStContexts = fromList [("Alerts",["Normal Text"])], synStLanguage = "Alerts", synStCurrentLine = "", synStCharsParsedInLine = 0, synStPrevChar = '\n', synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}--parseSourceLine = manyTill parseExpressionInternal pEndLine+startingState = SyntaxState {synStContexts = fromList [("Alerts",["Normal Text"])], synStLanguage = "Alerts", synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do-  lookAhead $ newline <|> (eof >> return '\n')   context <- currentContext   case context of     "Normal Text" -> (popContext) >> pEndLine-    _ -> pHandleEndLine+    _ -> return ()  withAttribute attr txt = do   when (null txt) $ fail "Parser matched no text"-  let labs = attr : maybeToList (lookup attr styles)-  st <- getState-  let oldCharsParsed = synStCharsParsedInLine st-  let prevchar = if null txt then '\n' else last txt-  updateState $ \st -> st { synStCharsParsedInLine = oldCharsParsed + length txt, synStPrevChar = prevchar } -  return (labs, txt)--styles = [("Alert","al")]+  updateState $ \st -> st { synStPrevChar = last txt+                          , synStPrevNonspace = synStPrevNonspace st || not (all isSpace txt) }+  return (attr, txt)  parseExpressionInternal = do   context <- currentContext-  parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes))+  parseRules context <|> (pDefault >>= withAttribute (fromMaybe NormalTok $ lookup context defaultAttributes))  list_alerts = Set.fromList $ words $ "### ALERT BUG DANGER DEPRECATED FIXME HACK NOTE NOTICE SECURITY TASK TEST TESTING TODO WARNING"  -defaultAttributes = [("Normal Text","Normal Text")]+defaultAttributes = [("Normal Text",NormalTok)] -parseRules "Normal Text" = -  do (attr, result) <- ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_alerts >>= withAttribute "Alert"))-     return (attr, result)+parseRules "Normal Text" =+  ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_alerts >>= withAttribute AlertTok))  parseRules "" = parseRules "Normal Text" 

@@ -1,15 +1,18 @@-{- This module was generated from data in the Kate syntax highlighting file alert_indent.xml, version 1.08,-   by  Dominik Haumann (dhdev@gmx.de) -}+{- This module was generated from data in the Kate syntax+   highlighting file alert_indent.xml, version 1.08, by Dominik Haumann (dhdev@gmx.de) -} -module Text.Highlighting.Kate.Syntax.Alert_indent ( highlight, parseExpression, syntaxName, syntaxExtensions ) where-import Text.Highlighting.Kate.Definitions+module Text.Highlighting.Kate.Syntax.Alert_indent+          (highlight, parseExpression, syntaxName, syntaxExtensions)+where+import Text.Highlighting.Kate.Types import Text.Highlighting.Kate.Common-import Text.ParserCombinators.Parsec-import Control.Monad (when)+import Text.ParserCombinators.Parsec hiding (State) import Data.Map (fromList)-import Data.Maybe (fromMaybe, maybeToList)-+import Control.Monad.State+import Data.Char (isSpace)+import Data.Maybe (fromMaybe) import qualified Data.Set as Set+ -- | Full name of language. syntaxName :: String syntaxName = "Alerts_indent"@@ -19,63 +22,49 @@ syntaxExtensions = ""  -- | Highlight source code using this syntax definition.-highlight :: String -> Either String [SourceLine]-highlight input =-  case runParser parseSource startingState "source" input of-    Left err     -> Left $ show err-    Right result -> Right result+highlight :: String -> [SourceLine]+highlight input = evalState (mapM parseSourceLine $ lines input) startingState +parseSourceLine :: String -> State SyntaxState SourceLine+parseSourceLine = mkParseSourceLine parseExpressionInternal pEndLine+ -- | Parse an expression using appropriate local context.-parseExpression :: GenParser Char SyntaxState LabeledSource+parseExpression :: KateParser Token parseExpression = do   st <- getState   let oldLang = synStLanguage st   setState $ st { synStLanguage = "Alerts_indent" }   context <- currentContext <|> (pushContext "Normal Text" >> currentContext)   result <- parseRules context+  optional $ eof >> pEndLine   updateState $ \st -> st { synStLanguage = oldLang }   return result -parseSource = do -  lineContents <- lookAhead wholeLine-  updateState $ \st -> st { synStCurrentLine = lineContents }-  result <- manyTill parseSourceLine eof-  return $ map normalizeHighlighting result--startingState = SyntaxState {synStContexts = fromList [("Alerts_indent",["Normal Text"])], synStLanguage = "Alerts_indent", synStCurrentLine = "", synStCharsParsedInLine = 0, synStPrevChar = '\n', synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}--parseSourceLine = manyTill parseExpressionInternal pEndLine+startingState = SyntaxState {synStContexts = fromList [("Alerts_indent",["Normal Text"])], synStLanguage = "Alerts_indent", synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do-  lookAhead $ newline <|> (eof >> return '\n')   context <- currentContext   case context of     "Normal Text" -> (popContext) >> pEndLine-    _ -> pHandleEndLine+    _ -> return ()  withAttribute attr txt = do   when (null txt) $ fail "Parser matched no text"-  let labs = attr : maybeToList (lookup attr styles)-  st <- getState-  let oldCharsParsed = synStCharsParsedInLine st-  let prevchar = if null txt then '\n' else last txt-  updateState $ \st -> st { synStCharsParsedInLine = oldCharsParsed + length txt, synStPrevChar = prevchar } -  return (labs, txt)--styles = [("Alert","al")]+  updateState $ \st -> st { synStPrevChar = last txt+                          , synStPrevNonspace = synStPrevNonspace st || not (all isSpace txt) }+  return (attr, txt)  parseExpressionInternal = do   context <- currentContext-  parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes))+  parseRules context <|> (pDefault >>= withAttribute (fromMaybe NormalTok $ lookup context defaultAttributes))  list_alerts = Set.fromList $ words $ "### ALERT BUG DANGER DEPRECATED FIXME HACK NOTE NOTICE SECURITY TASK TEST TESTING TODO WARNING"  -defaultAttributes = [("Normal Text","Normal Text")]+defaultAttributes = [("Normal Text",NormalTok)] -parseRules "Normal Text" = -  do (attr, result) <- ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_alerts >>= withAttribute "Alert"))-     return (attr, result)+parseRules "Normal Text" =+  ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_alerts >>= withAttribute AlertTok))  parseRules "" = parseRules "Normal Text" 

@@ -1,16 +1,19 @@-{- This module was generated from data in the Kate syntax highlighting file apache.xml, version 1.11,-   by  Jan Janssen (medhefgo@googlemail.com) -}+{- This module was generated from data in the Kate syntax+   highlighting file apache.xml, version 1.11, by Jan Janssen (medhefgo@googlemail.com) -} -module Text.Highlighting.Kate.Syntax.Apache ( highlight, parseExpression, syntaxName, syntaxExtensions ) where-import Text.Highlighting.Kate.Definitions+module Text.Highlighting.Kate.Syntax.Apache+          (highlight, parseExpression, syntaxName, syntaxExtensions)+where+import Text.Highlighting.Kate.Types import Text.Highlighting.Kate.Common import qualified Text.Highlighting.Kate.Syntax.Alert-import Text.ParserCombinators.Parsec-import Control.Monad (when)+import Text.ParserCombinators.Parsec hiding (State) import Data.Map (fromList)-import Data.Maybe (fromMaybe, maybeToList)-+import Control.Monad.State+import Data.Char (isSpace)+import Data.Maybe (fromMaybe) import qualified Data.Set as Set+ -- | Full name of language. syntaxName :: String syntaxName = "Apache Configuration"@@ -20,38 +23,30 @@ syntaxExtensions = "httpd.conf;httpd2.conf;apache.conf;apache2.conf;.htaccess*;.htpasswd*"  -- | Highlight source code using this syntax definition.-highlight :: String -> Either String [SourceLine]-highlight input =-  case runParser parseSource startingState "source" input of-    Left err     -> Left $ show err-    Right result -> Right result+highlight :: String -> [SourceLine]+highlight input = evalState (mapM parseSourceLine $ lines input) startingState +parseSourceLine :: String -> State SyntaxState SourceLine+parseSourceLine = mkParseSourceLine parseExpressionInternal pEndLine+ -- | Parse an expression using appropriate local context.-parseExpression :: GenParser Char SyntaxState LabeledSource+parseExpression :: KateParser Token parseExpression = do   st <- getState   let oldLang = synStLanguage st   setState $ st { synStLanguage = "Apache Configuration" }   context <- currentContext <|> (pushContext "apache" >> currentContext)   result <- parseRules context+  optional $ eof >> pEndLine   updateState $ \st -> st { synStLanguage = oldLang }   return result -parseSource = do -  lineContents <- lookAhead wholeLine-  updateState $ \st -> st { synStCurrentLine = lineContents }-  result <- manyTill parseSourceLine eof-  return $ map normalizeHighlighting result--startingState = SyntaxState {synStContexts = fromList [("Apache Configuration",["apache"])], synStLanguage = "Apache Configuration", synStCurrentLine = "", synStCharsParsedInLine = 0, synStPrevChar = '\n', synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}--parseSourceLine = manyTill parseExpressionInternal pEndLine+startingState = SyntaxState {synStContexts = fromList [("Apache Configuration",["apache"])], synStLanguage = "Apache Configuration", synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}  pEndLine = do-  lookAhead $ newline <|> (eof >> return '\n')   context <- currentContext   case context of-    "apache" -> return () >> pHandleEndLine+    "apache" -> return ()     "String Directives" -> (popContext) >> pEndLine     "Integer Directives" -> (popContext) >> pEndLine     "Alternative Directives" -> (popContext) >> pEndLine@@ -60,22 +55,17 @@     "Container Close" -> (popContext) >> pEndLine     "Comment Alert" -> (popContext) >> pEndLine     "Alert" -> (popContext) >> pEndLine-    _ -> pHandleEndLine+    _ -> return ()  withAttribute attr txt = do   when (null txt) $ fail "Parser matched no text"-  let labs = attr : maybeToList (lookup attr styles)-  st <- getState-  let oldCharsParsed = synStCharsParsedInLine st-  let prevchar = if null txt then '\n' else last txt-  updateState $ \st -> st { synStCharsParsedInLine = oldCharsParsed + length txt, synStPrevChar = prevchar } -  return (labs, txt)--styles = [("Comment","co"),("Directives","ot"),("String","st"),("Float","fl"),("Int","fl"),("Alternates","kw"),("Alert","er"),("Container","fu"),("Attribute","ot"),("Other","ch")]+  updateState $ \st -> st { synStPrevChar = last txt+                          , synStPrevNonspace = synStPrevNonspace st || not (all isSpace txt) }+  return (attr, txt)  parseExpressionInternal = do   context <- currentContext-  parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes))+  parseRules context <|> (pDefault >>= withAttribute (fromMaybe NormalTok $ lookup context defaultAttributes))  list_String_Directives = Set.fromList $ words $ "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" list_Integer_Directives = Set.fromList $ words $ "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"@@ -87,71 +77,63 @@ regex_'5b'5e'23'5d'2a = compileRegex "[^#]*" regex_'5b'5e'23'3e'5d'2a = compileRegex "[^#>]*" -defaultAttributes = [("apache","Normal Text"),("String Directives","Directives"),("Integer Directives","Other"),("Alternative Directives","Other"),("Comment","Comment"),("Container Open","Container"),("Container Close","Container"),("Comment Alert","Normal Text"),("Alert","Alert")]+defaultAttributes = [("apache",NormalTok),("String Directives",OtherTok),("Integer Directives",CharTok),("Alternative Directives",CharTok),("Comment",CommentTok),("Container Open",FunctionTok),("Container Close",FunctionTok),("Comment Alert",NormalTok),("Alert",ErrorTok)] -parseRules "apache" = -  do (attr, result) <- (((pKeyword " \n\t.():!+-<=>%&*/;?[]^{|}~\\" list_String_Directives >>= withAttribute "Normal Text") >>~ pushContext "String Directives")-                        <|>-                        ((pKeyword " \n\t.():!+-<=>%&*/;?[]^{|}~\\" list_Integer_Directives >>= withAttribute "Directives") >>~ pushContext "Integer Directives")-                        <|>-                        ((pKeyword " \n\t.():!+-<=>%&*/;?[]^{|}~\\" list_Alternative_Directives >>= withAttribute "Directives") >>~ pushContext "Alternative Directives")-                        <|>-                        ((pRegExpr regex_'3c'5cw'2b >>= withAttribute "Container") >>~ pushContext "Container Open")-                        <|>-                        ((pRegExpr regex_'3c'2f'5cw'2b >>= withAttribute "Container") >>~ pushContext "Container Close")-                        <|>-                        ((pFirstNonSpace >> pDetectChar False '#' >>= withAttribute "Comment") >>~ pushContext "Comment"))-     return (attr, result)+parseRules "apache" =+  (((pKeyword " \n\t.():!+-<=>%&*/;?[]^{|}~\\" list_String_Directives >>= withAttribute NormalTok) >>~ pushContext "String Directives")+   <|>+   ((pKeyword " \n\t.():!+-<=>%&*/;?[]^{|}~\\" list_Integer_Directives >>= withAttribute OtherTok) >>~ pushContext "Integer Directives")+   <|>+   ((pKeyword " \n\t.():!+-<=>%&*/;?[]^{|}~\\" list_Alternative_Directives >>= withAttribute OtherTok) >>~ pushContext "Alternative Directives")+   <|>+   ((pRegExpr regex_'3c'5cw'2b >>= withAttribute FunctionTok) >>~ pushContext "Container Open")+   <|>+   ((pRegExpr regex_'3c'2f'5cw'2b >>= withAttribute FunctionTok) >>~ pushContext "Container Close")+   <|>+   ((pFirstNonSpace >> pDetectChar False '#' >>= withAttribute CommentTok) >>~ pushContext "Comment")) -parseRules "String Directives" = -  do (attr, result) <- (((pRegExpr regex_'5b'5e'23'5d'2a >>= withAttribute "String"))-                        <|>-                        ((parseRules "Comment Alert")))-     return (attr, result)+parseRules "String Directives" =+  (((pRegExpr regex_'5b'5e'23'5d'2a >>= withAttribute StringTok))+   <|>+   ((parseRules "Comment Alert"))) -parseRules "Integer Directives" = -  do (attr, result) <- (((pFloat >>= withAttribute "Float") >>~ pushContext "Integer Directives")-                        <|>-                        ((pInt >>= withAttribute "Int") >>~ pushContext "Integer Directives")-                        <|>-                        ((parseRules "Comment Alert")))-     return (attr, result)+parseRules "Integer Directives" =+  (((pFloat >>= withAttribute FloatTok) >>~ pushContext "Integer Directives")+   <|>+   ((pInt >>= withAttribute FloatTok) >>~ pushContext "Integer Directives")+   <|>+   ((parseRules "Comment Alert"))) -parseRules "Alternative Directives" = -  do (attr, result) <- (((pKeyword " \n\t.():!+-<=>%&*/;?[]^{|}~\\" list_Alternates >>= withAttribute "Alternates"))-                        <|>-                        ((pDetectChar False '-' >>= withAttribute "Alternates"))-                        <|>-                        ((pDetectChar False '+' >>= withAttribute "Alternates"))-                        <|>-                        ((parseRules "Comment Alert")))-     return (attr, result)+parseRules "Alternative Directives" =+  (((pKeyword " \n\t.():!+-<=>%&*/;?[]^{|}~\\" list_Alternates >>= withAttribute KeywordTok))+   <|>+   ((pDetectChar False '-' >>= withAttribute KeywordTok))+   <|>+   ((pDetectChar False '+' >>= withAttribute KeywordTok))+   <|>+   ((parseRules "Comment Alert"))) -parseRules "Comment" = -  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Comment"))-                        <|>-                        ((Text.Highlighting.Kate.Syntax.Alert.parseExpression))-                        <|>-                        ((pDetectIdentifier >>= withAttribute "Comment")))-     return (attr, result)+parseRules "Comment" =+  (((pDetectSpaces >>= withAttribute CommentTok))+   <|>+   ((Text.Highlighting.Kate.Syntax.Alert.parseExpression >>= ((withAttribute CommentTok) . snd)))+   <|>+   ((pDetectIdentifier >>= withAttribute CommentTok))) -parseRules "Container Open" = -  do (attr, result) <- (((pDetectChar False '>' >>= withAttribute "Container") >>~ pushContext "Alert")-                        <|>-                        ((pRegExpr regex_'5b'5e'23'3e'5d'2a >>= withAttribute "Attribute"))-                        <|>-                        ((parseRules "Comment Alert")))-     return (attr, result)+parseRules "Container Open" =+  (((pDetectChar False '>' >>= withAttribute FunctionTok) >>~ pushContext "Alert")+   <|>+   ((pRegExpr regex_'5b'5e'23'3e'5d'2a >>= withAttribute OtherTok))+   <|>+   ((parseRules "Comment Alert"))) -parseRules "Container Close" = -  do (attr, result) <- ((pDetectChar False '>' >>= withAttribute "Container") >>~ pushContext "Alert")-     return (attr, result)+parseRules "Container Close" =+  ((pDetectChar False '>' >>= withAttribute FunctionTok) >>~ pushContext "Alert") -parseRules "Comment Alert" = -  do (attr, result) <- ((pDetectChar False '#' >>= withAttribute "Alert") >>~ pushContext "Alert")-     return (attr, result)+parseRules "Comment Alert" =+  ((pDetectChar False '#' >>= withAttribute ErrorTok) >>~ pushContext "Alert") -parseRules "Alert" = +parseRules "Alert" =   pzero  parseRules "" = parseRules "apache"

@@ -1,15 +1,18 @@-{- This module was generated from data in the Kate syntax highlighting file asn1.xml, version 1.00,-   by  Philippe Rigault -}+{- This module was generated from data in the Kate syntax+   highlighting file asn1.xml, version 1.00, by Philippe Rigault -} -module Text.Highlighting.Kate.Syntax.Asn1 ( highlight, parseExpression, syntaxName, syntaxExtensions ) where-import Text.Highlighting.Kate.Definitions+module Text.Highlighting.Kate.Syntax.Asn1+          (highlight, parseExpression, syntaxName, syntaxExtensions)+where+import Text.Highlighting.Kate.Types import Text.Highlighting.Kate.Common-import Text.ParserCombinators.Parsec-import Control.Monad (when)+import Text.ParserCombinators.Parsec hiding (State) import Data.Map (fromList)-import Data.Maybe (fromMaybe, maybeToList)-+import Control.Monad.State+import Data.Char (isSpace)+import Data.Maybe (fromMaybe) import qualified Data.Set as Set+ -- | Full name of language. syntaxName :: String syntaxName = "ASN.1"@@ -19,71 +22,57 @@ syntaxExtensions = "*.asn*.asn1"  -- | Highlight source code using this syntax definition.-highlight :: String -> Either String [SourceLine]-highlight input =-  case runParser parseSource startingState "source" input of-    Left err     -> Left $ show err-    Right result -> Right result+highlight :: String -> [SourceLine]+highlight input = evalState (mapM parseSourceLine $ lines input) startingState +parseSourceLine :: String -> State SyntaxState SourceLine+parseSourceLine = mkParseSourceLine parseExpressionInternal pEndLine+ -- | Parse an expression using appropriate local context.-parseExpression :: GenParser Char SyntaxState LabeledSource+parseExpression :: KateParser Token parseExpression = do   st <- getState   let oldLang = synStLanguage st   setState $ st { synStLanguage = "ASN.1" }   context <- currentContext <|> (pushContext "Normal Text" >> currentContext)   result <- parseRules context+  optional $ eof >> pEndLine   updateState $ \st -> st { synStLanguage = oldLang }   return result -parseSource = do -  lineContents <- lookAhead wholeLine-  updateState $ \st -> st { synStCurrentLine = lineContents }-  result <- manyTill parseSourceLine eof-  return $ map normalizeHighlighting result--startingState = SyntaxState {synStContexts = fromList [("ASN.1",["Normal Text"])], synStLanguage = "ASN.1", synStCurrentLine = "", synStCharsParsedInLine = 0, synStPrevChar = '\n', synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}--parseSourceLine = manyTill parseExpressionInternal pEndLine+startingState = SyntaxState {synStContexts = fromList [("ASN.1",["Normal Text"])], synStLanguage = "ASN.1", synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do-  lookAhead $ newline <|> (eof >> return '\n')   context <- currentContext   case context of-    "Normal Text" -> return () >> pHandleEndLine+    "Normal Text" -> return ()     "Comment" -> (popContext) >> pEndLine-    _ -> pHandleEndLine+    _ -> return ()  withAttribute attr txt = do   when (null txt) $ fail "Parser matched no text"-  let labs = attr : maybeToList (lookup attr styles)-  st <- getState-  let oldCharsParsed = synStCharsParsedInLine st-  let prevchar = if null txt then '\n' else last txt-  updateState $ \st -> st { synStCharsParsedInLine = oldCharsParsed + length txt, synStPrevChar = prevchar } -  return (labs, txt)--styles = [("Keyword","kw"),("Comment","co"),("Data Type","dt")]+  updateState $ \st -> st { synStPrevChar = last txt+                          , synStPrevNonspace = synStPrevNonspace st || not (all isSpace txt) }+  return (attr, txt)  parseExpressionInternal = do   context <- currentContext-  parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes))+  parseRules context <|> (pDefault >>= withAttribute (fromMaybe NormalTok $ lookup context defaultAttributes))  list_keywords = Set.fromList $ words $ "DEFINITIONS BEGIN END EXPORTS IMPORTS FROM APPLICATION PRIVATE UNIVERSAL DEFAULT OPTIONAL FALSE TRUE" list_types = Set.fromList $ words $ "BOOLEAN INTEGER OCTET STRING NULL REAL ENUMERATED SEQUENCE SET CHOICE OF VisibleString StringStore"  -defaultAttributes = [("Normal Text","Normal Text"),("Comment","Comment")]+defaultAttributes = [("Normal Text",NormalTok),("Comment",CommentTok)] -parseRules "Normal Text" = -  do (attr, result) <- (((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_keywords >>= withAttribute "Keyword"))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_types >>= withAttribute "Data Type"))-                        <|>-                        ((pDetect2Chars False '-' '-' >>= withAttribute "Comment") >>~ pushContext "Comment"))-     return (attr, result)+parseRules "Normal Text" =+  (((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_keywords >>= withAttribute KeywordTok))+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_types >>= withAttribute DataTypeTok))+   <|>+   ((pDetect2Chars False '-' '-' >>= withAttribute CommentTok) >>~ pushContext "Comment")) -parseRules "Comment" = +parseRules "Comment" =   pzero  parseRules "" = parseRules "Normal Text"

@@ -1,15 +1,18 @@-{- This module was generated from data in the Kate syntax highlighting file asp.xml, version 1.04,-   by  Antonio Salazar (savedfastcool@gmail.com) -}+{- This module was generated from data in the Kate syntax+   highlighting file asp.xml, version 1.04, by Antonio Salazar (savedfastcool@gmail.com) -} -module Text.Highlighting.Kate.Syntax.Asp ( highlight, parseExpression, syntaxName, syntaxExtensions ) where-import Text.Highlighting.Kate.Definitions+module Text.Highlighting.Kate.Syntax.Asp+          (highlight, parseExpression, syntaxName, syntaxExtensions)+where+import Text.Highlighting.Kate.Types import Text.Highlighting.Kate.Common-import Text.ParserCombinators.Parsec-import Control.Monad (when)+import Text.ParserCombinators.Parsec hiding (State) import Data.Map (fromList)-import Data.Maybe (fromMaybe, maybeToList)-+import Control.Monad.State+import Data.Char (isSpace)+import Data.Maybe (fromMaybe) import qualified Data.Set as Set+ -- | Full name of language. syntaxName :: String syntaxName = "ASP"@@ -19,66 +22,53 @@ syntaxExtensions = "*.asp;"  -- | Highlight source code using this syntax definition.-highlight :: String -> Either String [SourceLine]-highlight input =-  case runParser parseSource startingState "source" input of-    Left err     -> Left $ show err-    Right result -> Right result+highlight :: String -> [SourceLine]+highlight input = evalState (mapM parseSourceLine $ lines input) startingState +parseSourceLine :: String -> State SyntaxState SourceLine+parseSourceLine = mkParseSourceLine parseExpressionInternal pEndLine+ -- | Parse an expression using appropriate local context.-parseExpression :: GenParser Char SyntaxState LabeledSource+parseExpression :: KateParser Token parseExpression = do   st <- getState   let oldLang = synStLanguage st   setState $ st { synStLanguage = "ASP" }   context <- currentContext <|> (pushContext "nosource" >> currentContext)   result <- parseRules context+  optional $ eof >> pEndLine   updateState $ \st -> st { synStLanguage = oldLang }   return result -parseSource = do -  lineContents <- lookAhead wholeLine-  updateState $ \st -> st { synStCurrentLine = lineContents }-  result <- manyTill parseSourceLine eof-  return $ map normalizeHighlighting result--startingState = SyntaxState {synStContexts = fromList [("ASP",["nosource"])], synStLanguage = "ASP", synStCurrentLine = "", synStCharsParsedInLine = 0, synStPrevChar = '\n', synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}--parseSourceLine = manyTill parseExpressionInternal pEndLine+startingState = SyntaxState {synStContexts = fromList [("ASP",["nosource"])], synStLanguage = "ASP", synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}  pEndLine = do-  lookAhead $ newline <|> (eof >> return '\n')   context <- currentContext   case context of-    "nosource" -> return () >> pHandleEndLine-    "aspsource" -> return () >> pHandleEndLine+    "nosource" -> return ()+    "aspsource" -> return ()     "asp_onelinecomment" -> (popContext) >> pEndLine-    "doublequotestring" -> return () >> pHandleEndLine-    "singlequotestring" -> return () >> pHandleEndLine-    "htmltag" -> return () >> pHandleEndLine-    "htmlcomment" -> return () >> pHandleEndLine-    "identifiers" -> return () >> pHandleEndLine-    "types1" -> return () >> pHandleEndLine-    "types2" -> return () >> pHandleEndLine-    "scripts" -> return () >> pHandleEndLine+    "doublequotestring" -> return ()+    "singlequotestring" -> return ()+    "htmltag" -> return ()+    "htmlcomment" -> return ()+    "identifiers" -> return ()+    "types1" -> return ()+    "types2" -> return ()+    "scripts" -> return ()     "scripts_onelinecomment" -> (popContext) >> pEndLine-    "twolinecomment" -> return () >> pHandleEndLine-    _ -> pHandleEndLine+    "twolinecomment" -> return ()+    _ -> return ()  withAttribute attr txt = do   when (null txt) $ fail "Parser matched no text"-  let labs = attr : maybeToList (lookup attr styles)-  st <- getState-  let oldCharsParsed = synStCharsParsedInLine st-  let prevchar = if null txt then '\n' else last txt-  updateState $ \st -> st { synStCharsParsedInLine = oldCharsParsed + length txt, synStPrevChar = prevchar } -  return (labs, txt)--styles = [("Keyword","kw"),("Function","kw"),("Decimal","dv"),("Octal","bn"),("Hex","bn"),("Float","fl"),("String","st"),("Comment","co"),("Variable","kw"),("Control Structures","kw"),("Escape Code","kw"),("Other","ot"),("HTML Tag","kw"),("HTML Comment","co"),("Identifier","ot"),("Types","dt")]+  updateState $ \st -> st { synStPrevChar = last txt+                          , synStPrevNonspace = synStPrevNonspace st || not (all isSpace txt) }+  return (attr, txt)  parseExpressionInternal = do   context <- currentContext-  parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes))+  parseRules context <|> (pDefault >>= withAttribute (fromMaybe NormalTok $ lookup context defaultAttributes))  list_control_structures = Set.fromList $ words $ "select case end select if then else elseif end if while do until loop wend for each to in next exit continue" list_keywords = Set.fromList $ words $ "dim redim preserve const erase nothing set new me function sub call class private public with randomize open close movenext execute eof not true false or and xor"@@ -118,211 +108,198 @@ regex_'5cs'2a'3d'5cs'2a = compileRegex "\\s*=\\s*" regex_'5cs'2a'23'3f'5ba'2dzA'2dZ0'2d9'5d'2a = compileRegex "\\s*#?[a-zA-Z0-9]*" -defaultAttributes = [("nosource","Normal Text"),("aspsource","ASP Text"),("asp_onelinecomment","Comment"),("doublequotestring","String"),("singlequotestring","String"),("htmltag","Identifier"),("htmlcomment","HTML Comment"),("identifiers","Identifier"),("types1","Types"),("types2","Types"),("scripts","Normal Text"),("scripts_onelinecomment","Comment"),("twolinecomment","Comment")]+defaultAttributes = [("nosource",NormalTok),("aspsource",NormalTok),("asp_onelinecomment",CommentTok),("doublequotestring",StringTok),("singlequotestring",StringTok),("htmltag",OtherTok),("htmlcomment",CommentTok),("identifiers",OtherTok),("types1",DataTypeTok),("types2",DataTypeTok),("scripts",NormalTok),("scripts_onelinecomment",CommentTok),("twolinecomment",CommentTok)] -parseRules "nosource" = -  do (attr, result) <- (((pString False "<%" >>= withAttribute "Keyword") >>~ pushContext "aspsource")-                        <|>-                        ((pRegExpr regex_'3c'5cs'2ascript'5cs'2alanguage'3d'22VBScript'22'5b'5e'3e'5d'2a'3e >>= withAttribute "HTML Tag") >>~ pushContext "aspsource")-                        <|>-                        ((pRegExpr regex_'3c'5cs'2ascript'28'5cs'7c'3e'29 >>= withAttribute "HTML Tag") >>~ pushContext "scripts")-                        <|>-                        ((pRegExpr regex_'3c'5cs'2a'5c'2f'3f'5cs'2a'5ba'2dzA'2dZ'5f'3a'5d'5ba'2dzA'2dZ0'2d9'2e'5f'3a'2d'5d'2a >>= withAttribute "HTML Tag") >>~ pushContext "htmltag")-                        <|>-                        ((pString False "<!--" >>= withAttribute "HTML Comment") >>~ pushContext "htmlcomment"))-     return (attr, result)+parseRules "nosource" =+  (((pString False "<%" >>= withAttribute KeywordTok) >>~ pushContext "aspsource")+   <|>+   ((pRegExpr regex_'3c'5cs'2ascript'5cs'2alanguage'3d'22VBScript'22'5b'5e'3e'5d'2a'3e >>= withAttribute KeywordTok) >>~ pushContext "aspsource")+   <|>+   ((pRegExpr regex_'3c'5cs'2ascript'28'5cs'7c'3e'29 >>= withAttribute KeywordTok) >>~ pushContext "scripts")+   <|>+   ((pRegExpr regex_'3c'5cs'2a'5c'2f'3f'5cs'2a'5ba'2dzA'2dZ'5f'3a'5d'5ba'2dzA'2dZ0'2d9'2e'5f'3a'2d'5d'2a >>= withAttribute KeywordTok) >>~ pushContext "htmltag")+   <|>+   ((pString False "<!--" >>= withAttribute CommentTok) >>~ pushContext "htmlcomment")) -parseRules "aspsource" = -  do (attr, result) <- (((pString False "%>" >>= withAttribute "Keyword") >>~ (popContext))-                        <|>-                        ((pRegExpr regex_'3c'5cs'2a'5c'2f'5cs'2ascript'5cs'2a'3e >>= withAttribute "HTML Tag") >>~ (popContext))-                        <|>-                        ((pDetectChar False '\'' >>= withAttribute "Comment") >>~ pushContext "asp_onelinecomment")-                        <|>-                        ((pDetectChar False '"' >>= withAttribute "String") >>~ pushContext "doublequotestring")-                        <|>-                        ((pDetectChar False '\'' >>= withAttribute "String") >>~ pushContext "singlequotestring")-                        <|>-                        ((pDetectChar False '&' >>= withAttribute "Keyword"))-                        <|>-                        ((pRegExpr regex_ >>= withAttribute "String"))-                        <|>-                        ((pRegExpr regex_'5b0123456789'5d'2a'5c'2e'5c'2e'5c'2e'5b0123456789'5d'2a >>= withAttribute "String"))-                        <|>-                        ((pHlCOct >>= withAttribute "Octal"))-                        <|>-                        ((pHlCHex >>= withAttribute "Hex"))-                        <|>-                        ((pFloat >>= withAttribute "Float"))-                        <|>-                        ((pInt >>= withAttribute "Decimal"))-                        <|>-                        ((pAnyChar ";()}{:,[]" >>= withAttribute "Other"))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" Set.empty >>= withAttribute "Other"))-                        <|>-                        ((pRegExpr regex_'5cbelseif'5cb >>= withAttribute "Control Structures"))-                        <|>-                        ((pRegExpr regex_'5cbelse'5cb >>= withAttribute "Control Structures"))-                        <|>-                        ((pRegExpr regex_'5cbif'5cb >>= withAttribute "Control Structures"))-                        <|>-                        ((pRegExpr regex_'5cbend_if'5cb >>= withAttribute "Control Structures"))-                        <|>-                        ((pRegExpr regex_'5cbexit_function'5cb >>= withAttribute "Keyword"))-                        <|>-                        ((pRegExpr regex_'5cbfunction'5cb >>= withAttribute "Keyword"))-                        <|>-                        ((pRegExpr regex_'5cbend_function'5cb >>= withAttribute "Keyword"))-                        <|>-                        ((pRegExpr regex_'5cbexit_sub'5cb >>= withAttribute "Keyword"))-                        <|>-                        ((pRegExpr regex_'5cbsub'5cb >>= withAttribute "Keyword"))-                        <|>-                        ((pRegExpr regex_'5cbend_sub'5cb >>= withAttribute "Keyword"))-                        <|>-                        ((pRegExpr regex_'5cbclass'5cb >>= withAttribute "Keyword"))-                        <|>-                        ((pRegExpr regex_'5cbend_class'5cb >>= withAttribute "Keyword"))-                        <|>-                        ((pRegExpr regex_'5cbexit_do'5cb >>= withAttribute "Control Structures"))-                        <|>-                        ((pRegExpr regex_'5cbdo'28'5cs'2b'28while'29'29'3f'5cb >>= withAttribute "Control Structures"))-                        <|>-                        ((pRegExpr regex_'5cbloop'5cb >>= withAttribute "Control Structures"))-                        <|>-                        ((pRegExpr regex_'5cbexit_while'5cb >>= withAttribute "Control Structures"))-                        <|>-                        ((pRegExpr regex_'5cbwhile'5cb >>= withAttribute "Control Structures"))-                        <|>-                        ((pRegExpr regex_'5cbwend'5cb >>= withAttribute "Control Structures"))-                        <|>-                        ((pRegExpr regex_'5cbexit_for'5cb >>= withAttribute "Control Structures"))-                        <|>-                        ((pRegExpr regex_'5cbfor'5cb >>= withAttribute "Control Structures"))-                        <|>-                        ((pRegExpr regex_'5cbnext'5cb >>= withAttribute "Control Structures"))-                        <|>-                        ((pRegExpr regex_'5cbselect_case'5cb >>= withAttribute "Control Structures"))-                        <|>-                        ((pRegExpr regex_'5cbend_select'5cb >>= withAttribute "Control Structures"))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_keywords >>= withAttribute "Keyword"))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_control_structures >>= withAttribute "Control Structures"))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_functions >>= withAttribute "Function")))-     return (attr, result)+parseRules "aspsource" =+  (((pString False "%>" >>= withAttribute KeywordTok) >>~ (popContext))+   <|>+   ((pRegExpr regex_'3c'5cs'2a'5c'2f'5cs'2ascript'5cs'2a'3e >>= withAttribute KeywordTok) >>~ (popContext))+   <|>+   ((pDetectChar False '\'' >>= withAttribute CommentTok) >>~ pushContext "asp_onelinecomment")+   <|>+   ((pDetectChar False '"' >>= withAttribute StringTok) >>~ pushContext "doublequotestring")+   <|>+   ((pDetectChar False '\'' >>= withAttribute StringTok) >>~ pushContext "singlequotestring")+   <|>+   ((pDetectChar False '&' >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_ >>= withAttribute StringTok))+   <|>+   ((pRegExpr regex_'5b0123456789'5d'2a'5c'2e'5c'2e'5c'2e'5b0123456789'5d'2a >>= withAttribute StringTok))+   <|>+   ((pHlCOct >>= withAttribute BaseNTok))+   <|>+   ((pHlCHex >>= withAttribute BaseNTok))+   <|>+   ((pFloat >>= withAttribute FloatTok))+   <|>+   ((pInt >>= withAttribute DecValTok))+   <|>+   ((pAnyChar ";()}{:,[]" >>= withAttribute OtherTok))+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" Set.empty >>= withAttribute OtherTok))+   <|>+   ((pRegExpr regex_'5cbelseif'5cb >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5cbelse'5cb >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5cbif'5cb >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5cbend_if'5cb >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5cbexit_function'5cb >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5cbfunction'5cb >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5cbend_function'5cb >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5cbexit_sub'5cb >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5cbsub'5cb >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5cbend_sub'5cb >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5cbclass'5cb >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5cbend_class'5cb >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5cbexit_do'5cb >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5cbdo'28'5cs'2b'28while'29'29'3f'5cb >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5cbloop'5cb >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5cbexit_while'5cb >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5cbwhile'5cb >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5cbwend'5cb >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5cbexit_for'5cb >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5cbfor'5cb >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5cbnext'5cb >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5cbselect_case'5cb >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5cbend_select'5cb >>= withAttribute KeywordTok))+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_keywords >>= withAttribute KeywordTok))+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_control_structures >>= withAttribute KeywordTok))+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_functions >>= withAttribute KeywordTok))) -parseRules "asp_onelinecomment" = -  do (attr, result) <- ((pString False "%>" >>= withAttribute "Keyword") >>~ (popContext >> popContext))-     return (attr, result)+parseRules "asp_onelinecomment" =+  ((pString False "%>" >>= withAttribute KeywordTok) >>~ (popContext >> popContext)) -parseRules "doublequotestring" = -  do (attr, result) <- (((pDetect2Chars False '"' '"' >>= withAttribute "Escape Code"))-                        <|>-                        ((pRegExpr regex_'5c'5c'5b0'2d7'5d'7b1'2c3'7d >>= withAttribute "Escape Code"))-                        <|>-                        ((pRegExpr regex_'5c'5cx'5b0'2d9A'2dFa'2df'5d'7b1'2c2'7d >>= withAttribute "Escape Code"))-                        <|>-                        ((pDetectChar False '"' >>= withAttribute "String") >>~ (popContext)))-     return (attr, result)+parseRules "doublequotestring" =+  (((pDetect2Chars False '"' '"' >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5c'5c'5b0'2d7'5d'7b1'2c3'7d >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5c'5cx'5b0'2d9A'2dFa'2df'5d'7b1'2c2'7d >>= withAttribute KeywordTok))+   <|>+   ((pDetectChar False '"' >>= withAttribute StringTok) >>~ (popContext))) -parseRules "singlequotestring" = -  do (attr, result) <- (((pDetect2Chars False '\'' '\'' >>= withAttribute "Escape Code"))-                        <|>-                        ((pDetectChar False '\'' >>= withAttribute "String") >>~ (popContext)))-     return (attr, result)+parseRules "singlequotestring" =+  (((pDetect2Chars False '\'' '\'' >>= withAttribute KeywordTok))+   <|>+   ((pDetectChar False '\'' >>= withAttribute StringTok) >>~ (popContext))) -parseRules "htmltag" = -  do (attr, result) <- (((pDetect2Chars False '/' '>' >>= withAttribute "HTML Tag") >>~ (popContext))-                        <|>-                        ((pDetectChar False '>' >>= withAttribute "HTML Tag") >>~ (popContext))-                        <|>-                        ((pString False "<%" >>= withAttribute "Keyword") >>~ pushContext "aspsource")-                        <|>-                        ((pString False "<%" >>= withAttribute "Keyword") >>~ pushContext "aspsource")-                        <|>-                        ((pRegExpr regex_'5cs'2a'3d'5cs'2a >>= withAttribute "Identifier") >>~ pushContext "identifiers"))-     return (attr, result)+parseRules "htmltag" =+  (((pDetect2Chars False '/' '>' >>= withAttribute KeywordTok) >>~ (popContext))+   <|>+   ((pDetectChar False '>' >>= withAttribute KeywordTok) >>~ (popContext))+   <|>+   ((pString False "<%" >>= withAttribute KeywordTok) >>~ pushContext "aspsource")+   <|>+   ((pString False "<%" >>= withAttribute KeywordTok) >>~ pushContext "aspsource")+   <|>+   ((pRegExpr regex_'5cs'2a'3d'5cs'2a >>= withAttribute OtherTok) >>~ pushContext "identifiers")) -parseRules "htmlcomment" = -  do (attr, result) <- (((pString False "<%" >>= withAttribute "Keyword") >>~ pushContext "aspsource")-                        <|>-                        ((pString False "<%" >>= withAttribute "Keyword") >>~ pushContext "aspsource")-                        <|>-                        ((pString False "-->" >>= withAttribute "HTML Comment") >>~ (popContext))-                        <|>-                        ((pRegExpr regex_'5cs'2a'3d'5cs'2a >>= withAttribute "Normal Text") >>~ pushContext "identifiers"))-     return (attr, result)+parseRules "htmlcomment" =+  (((pString False "<%" >>= withAttribute KeywordTok) >>~ pushContext "aspsource")+   <|>+   ((pString False "<%" >>= withAttribute KeywordTok) >>~ pushContext "aspsource")+   <|>+   ((pString False "-->" >>= withAttribute CommentTok) >>~ (popContext))+   <|>+   ((pRegExpr regex_'5cs'2a'3d'5cs'2a >>= withAttribute NormalTok) >>~ pushContext "identifiers")) -parseRules "identifiers" = -  do (attr, result) <- (((pRegExpr regex_'5cs'2a'23'3f'5ba'2dzA'2dZ0'2d9'5d'2a >>= withAttribute "String") >>~ (popContext))-                        <|>-                        ((pDetectChar False '\'' >>= withAttribute "Types") >>~ pushContext "types1")-                        <|>-                        ((pDetectChar False '"' >>= withAttribute "Types") >>~ pushContext "types2"))-     return (attr, result)+parseRules "identifiers" =+  (((pRegExpr regex_'5cs'2a'23'3f'5ba'2dzA'2dZ0'2d9'5d'2a >>= withAttribute StringTok) >>~ (popContext))+   <|>+   ((pDetectChar False '\'' >>= withAttribute DataTypeTok) >>~ pushContext "types1")+   <|>+   ((pDetectChar False '"' >>= withAttribute DataTypeTok) >>~ pushContext "types2")) -parseRules "types1" = -  do (attr, result) <- (((pString False "<%" >>= withAttribute "Keyword") >>~ pushContext "aspsource")-                        <|>-                        ((pString False "<%" >>= withAttribute "Keyword") >>~ pushContext "aspsource")-                        <|>-                        ((pDetectChar False '\'' >>= withAttribute "Types") >>~ (popContext >> popContext)))-     return (attr, result)+parseRules "types1" =+  (((pString False "<%" >>= withAttribute KeywordTok) >>~ pushContext "aspsource")+   <|>+   ((pString False "<%" >>= withAttribute KeywordTok) >>~ pushContext "aspsource")+   <|>+   ((pDetectChar False '\'' >>= withAttribute DataTypeTok) >>~ (popContext >> popContext))) -parseRules "types2" = -  do (attr, result) <- (((pString False "<%" >>= withAttribute "Keyword") >>~ pushContext "aspsource")-                        <|>-                        ((pString False "<%" >>= withAttribute "Keyword") >>~ pushContext "aspsource")-                        <|>-                        ((pDetectChar False '"' >>= withAttribute "Types") >>~ (popContext >> popContext)))-     return (attr, result)+parseRules "types2" =+  (((pString False "<%" >>= withAttribute KeywordTok) >>~ pushContext "aspsource")+   <|>+   ((pString False "<%" >>= withAttribute KeywordTok) >>~ pushContext "aspsource")+   <|>+   ((pDetectChar False '"' >>= withAttribute DataTypeTok) >>~ (popContext >> popContext))) -parseRules "scripts" = -  do (attr, result) <- (((pDetect2Chars False '/' '/' >>= withAttribute "Comment") >>~ pushContext "scripts_onelinecomment")-                        <|>-                        ((pDetect2Chars False '/' '*' >>= withAttribute "Comment") >>~ pushContext "twolinecomment")-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_control_structures >>= withAttribute "Control Structures"))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_keywords >>= withAttribute "Keyword"))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_functions >>= withAttribute "Function"))-                        <|>-                        ((pString False "<%" >>= withAttribute "Keyword") >>~ pushContext "aspsource")-                        <|>-                        ((pRegExpr regex_'3c'5cs'2a'5c'2f'5cs'2ascript'5cs'2a'3e >>= withAttribute "HTML Tag") >>~ (popContext))-                        <|>-                        ((pDetectChar False '"' >>= withAttribute "String") >>~ pushContext "doublequotestring")-                        <|>-                        ((pDetectChar False '\'' >>= withAttribute "String") >>~ pushContext "singlequotestring")-                        <|>-                        ((pHlCOct >>= withAttribute "Octal"))-                        <|>-                        ((pHlCHex >>= withAttribute "Hex"))-                        <|>-                        ((pFloat >>= withAttribute "Float"))-                        <|>-                        ((pInt >>= withAttribute "Decimal"))-                        <|>-                        ((pDetectChar False '{' >>= withAttribute "Normal Text"))-                        <|>-                        ((pDetectChar False '}' >>= withAttribute "Normal Text"))-                        <|>-                        ((pAnyChar ";()}{:,[]" >>= withAttribute "Other"))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" Set.empty >>= withAttribute "Other")))-     return (attr, result)+parseRules "scripts" =+  (((pDetect2Chars False '/' '/' >>= withAttribute CommentTok) >>~ pushContext "scripts_onelinecomment")+   <|>+   ((pDetect2Chars False '/' '*' >>= withAttribute CommentTok) >>~ pushContext "twolinecomment")+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_control_structures >>= withAttribute KeywordTok))+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_keywords >>= withAttribute KeywordTok))+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_functions >>= withAttribute KeywordTok))+   <|>+   ((pString False "<%" >>= withAttribute KeywordTok) >>~ pushContext "aspsource")+   <|>+   ((pRegExpr regex_'3c'5cs'2a'5c'2f'5cs'2ascript'5cs'2a'3e >>= withAttribute KeywordTok) >>~ (popContext))+   <|>+   ((pDetectChar False '"' >>= withAttribute StringTok) >>~ pushContext "doublequotestring")+   <|>+   ((pDetectChar False '\'' >>= withAttribute StringTok) >>~ pushContext "singlequotestring")+   <|>+   ((pHlCOct >>= withAttribute BaseNTok))+   <|>+   ((pHlCHex >>= withAttribute BaseNTok))+   <|>+   ((pFloat >>= withAttribute FloatTok))+   <|>+   ((pInt >>= withAttribute DecValTok))+   <|>+   ((pDetectChar False '{' >>= withAttribute NormalTok))+   <|>+   ((pDetectChar False '}' >>= withAttribute NormalTok))+   <|>+   ((pAnyChar ";()}{:,[]" >>= withAttribute OtherTok))+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" Set.empty >>= withAttribute OtherTok))) -parseRules "scripts_onelinecomment" = -  do (attr, result) <- ((pRegExpr regex_'3c'5cs'2a'5c'2f'5cs'2ascript'5cs'2a'3e >>= withAttribute "HTML Tag") >>~ (popContext >> popContext))-     return (attr, result)+parseRules "scripts_onelinecomment" =+  ((pRegExpr regex_'3c'5cs'2a'5c'2f'5cs'2ascript'5cs'2a'3e >>= withAttribute KeywordTok) >>~ (popContext >> popContext)) -parseRules "twolinecomment" = -  do (attr, result) <- ((pDetect2Chars False '*' '/' >>= withAttribute "Comment") >>~ (popContext))-     return (attr, result)+parseRules "twolinecomment" =+  ((pDetect2Chars False '*' '/' >>= withAttribute CommentTok) >>~ (popContext))  parseRules "" = parseRules "nosource" 

@@ -1,16 +1,19 @@-{- This module was generated from data in the Kate syntax highlighting file awk.xml, version 0.91,-   by   -}+{- This module was generated from data in the Kate syntax+   highlighting file awk.xml, version 0.91, by  -} -module Text.Highlighting.Kate.Syntax.Awk ( highlight, parseExpression, syntaxName, syntaxExtensions ) where-import Text.Highlighting.Kate.Definitions+module Text.Highlighting.Kate.Syntax.Awk+          (highlight, parseExpression, syntaxName, syntaxExtensions)+where+import Text.Highlighting.Kate.Types import Text.Highlighting.Kate.Common import qualified Text.Highlighting.Kate.Syntax.Alert-import Text.ParserCombinators.Parsec-import Control.Monad (when)+import Text.ParserCombinators.Parsec hiding (State) import Data.Map (fromList)-import Data.Maybe (fromMaybe, maybeToList)-+import Control.Monad.State+import Data.Char (isSpace)+import Data.Maybe (fromMaybe) import qualified Data.Set as Set+ -- | Full name of language. syntaxName :: String syntaxName = "AWK"@@ -20,56 +23,43 @@ syntaxExtensions = "*.awk"  -- | Highlight source code using this syntax definition.-highlight :: String -> Either String [SourceLine]-highlight input =-  case runParser parseSource startingState "source" input of-    Left err     -> Left $ show err-    Right result -> Right result+highlight :: String -> [SourceLine]+highlight input = evalState (mapM parseSourceLine $ lines input) startingState +parseSourceLine :: String -> State SyntaxState SourceLine+parseSourceLine = mkParseSourceLine parseExpressionInternal pEndLine+ -- | Parse an expression using appropriate local context.-parseExpression :: GenParser Char SyntaxState LabeledSource+parseExpression :: KateParser Token parseExpression = do   st <- getState   let oldLang = synStLanguage st   setState $ st { synStLanguage = "AWK" }   context <- currentContext <|> (pushContext "Base" >> currentContext)   result <- parseRules context+  optional $ eof >> pEndLine   updateState $ \st -> st { synStLanguage = oldLang }   return result -parseSource = do -  lineContents <- lookAhead wholeLine-  updateState $ \st -> st { synStCurrentLine = lineContents }-  result <- manyTill parseSourceLine eof-  return $ map normalizeHighlighting result--startingState = SyntaxState {synStContexts = fromList [("AWK",["Base"])], synStLanguage = "AWK", synStCurrentLine = "", synStCharsParsedInLine = 0, synStPrevChar = '\n', synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}--parseSourceLine = manyTill parseExpressionInternal pEndLine+startingState = SyntaxState {synStContexts = fromList [("AWK",["Base"])], synStLanguage = "AWK", synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do-  lookAhead $ newline <|> (eof >> return '\n')   context <- currentContext   case context of-    "Base" -> return () >> pHandleEndLine-    "String" -> return () >> pHandleEndLine+    "Base" -> return ()+    "String" -> return ()     "Comment" -> (popContext) >> pEndLine-    _ -> pHandleEndLine+    _ -> return ()  withAttribute attr txt = do   when (null txt) $ fail "Parser matched no text"-  let labs = attr : maybeToList (lookup attr styles)-  st <- getState-  let oldCharsParsed = synStCharsParsedInLine st-  let prevchar = if null txt then '\n' else last txt-  updateState $ \st -> st { synStCharsParsedInLine = oldCharsParsed + length txt, synStPrevChar = prevchar } -  return (labs, txt)--styles = [("Keyword","kw"),("Builtin","dt"),("Function","fu"),("Decimal","dv"),("Float","fl"),("String","st"),("Comment","co"),("Pattern","st"),("Field","ot")]+  updateState $ \st -> st { synStPrevChar = last txt+                          , synStPrevNonspace = synStPrevNonspace st || not (all isSpace txt) }+  return (attr, txt)  parseExpressionInternal = do   context <- currentContext-  parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes))+  parseRules context <|> (pDefault >>= withAttribute (fromMaybe NormalTok $ lookup context defaultAttributes))  list_keywords = Set.fromList $ words $ "if else while do for in continue break print printf getline function return next exit" list_builtins = Set.fromList $ words $ "ARGC ARGV CONVFMT ENVIRON FILENAME FNR FS NF NR OFMT OFS ORS RS RSTART RLENGTH SUBSEP"@@ -78,41 +68,38 @@ regex_'5cb'28BEGIN'7cEND'29'5cb = compileRegex "\\b(BEGIN|END)\\b" regex_'5c'24'5bA'2dZa'2dz0'2d9'5f'5d'2b = compileRegex "\\$[A-Za-z0-9_]+" -defaultAttributes = [("Base","Normal"),("String","String"),("Comment","Comment")]+defaultAttributes = [("Base",NormalTok),("String",StringTok),("Comment",CommentTok)] -parseRules "Base" = -  do (attr, result) <- (((pRegExpr regex_'5cb'28BEGIN'7cEND'29'5cb >>= withAttribute "Pattern"))-                        <|>-                        ((pDetectChar False '{' >>= withAttribute "Keyword"))-                        <|>-                        ((pDetectChar False '}' >>= withAttribute "Keyword"))-                        <|>-                        ((pDetectChar False '#' >>= withAttribute "Comment") >>~ pushContext "Comment")-                        <|>-                        ((pDetectChar False '"' >>= withAttribute "String") >>~ pushContext "String")-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_keywords >>= withAttribute "Keyword"))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_builtins >>= withAttribute "Builtin"))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_functions >>= withAttribute "Function"))-                        <|>-                        ((pFloat >>= withAttribute "Float"))-                        <|>-                        ((pInt >>= withAttribute "Decimal"))-                        <|>-                        ((pRegExpr regex_'5c'24'5bA'2dZa'2dz0'2d9'5f'5d'2b >>= withAttribute "Field")))-     return (attr, result)+parseRules "Base" =+  (((pRegExpr regex_'5cb'28BEGIN'7cEND'29'5cb >>= withAttribute StringTok))+   <|>+   ((pDetectChar False '{' >>= withAttribute KeywordTok))+   <|>+   ((pDetectChar False '}' >>= withAttribute KeywordTok))+   <|>+   ((pDetectChar False '#' >>= withAttribute CommentTok) >>~ pushContext "Comment")+   <|>+   ((pDetectChar False '"' >>= withAttribute StringTok) >>~ pushContext "String")+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_keywords >>= withAttribute KeywordTok))+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_builtins >>= withAttribute DataTypeTok))+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_functions >>= withAttribute FunctionTok))+   <|>+   ((pFloat >>= withAttribute FloatTok))+   <|>+   ((pInt >>= withAttribute DecValTok))+   <|>+   ((pRegExpr regex_'5c'24'5bA'2dZa'2dz0'2d9'5f'5d'2b >>= withAttribute OtherTok))) -parseRules "String" = -  do (attr, result) <- (((pDetectChar False '"' >>= withAttribute "String") >>~ (popContext))-                        <|>-                        ((pHlCStringChar >>= withAttribute "String")))-     return (attr, result)+parseRules "String" =+  (((pDetectChar False '"' >>= withAttribute StringTok) >>~ (popContext))+   <|>+   ((pHlCStringChar >>= withAttribute StringTok))) -parseRules "Comment" = -  do (attr, result) <- ((Text.Highlighting.Kate.Syntax.Alert.parseExpression))-     return (attr, result)+parseRules "Comment" =+  ((Text.Highlighting.Kate.Syntax.Alert.parseExpression >>= ((withAttribute CommentTok) . snd)))  parseRules "" = parseRules "Base" 

@@ -1,730 +1,671 @@-{- This module was generated from data in the Kate syntax highlighting file bash.xml, version 2.12,-   by  Wilbert Berendsen (wilbert@kde.nl) -}--module Text.Highlighting.Kate.Syntax.Bash ( highlight, parseExpression, syntaxName, syntaxExtensions ) where-import Text.Highlighting.Kate.Definitions-import Text.Highlighting.Kate.Common-import qualified Text.Highlighting.Kate.Syntax.Alert-import Text.ParserCombinators.Parsec-import Control.Monad (when)-import Data.Map (fromList)-import Data.Maybe (fromMaybe, maybeToList)--import qualified Data.Set as Set--- | Full name of language.-syntaxName :: String-syntaxName = "Bash"---- | Filename extensions for this language.-syntaxExtensions :: String-syntaxExtensions = "*.sh;*.bash;*.ebuild;*.eclass;.bashrc;.bash_profile;.bash_login;.profile"---- | Highlight source code using this syntax definition.-highlight :: String -> Either String [SourceLine]-highlight input =-  case runParser parseSource startingState "source" input of-    Left err     -> Left $ show err-    Right result -> Right result---- | Parse an expression using appropriate local context.-parseExpression :: GenParser Char SyntaxState LabeledSource-parseExpression = do-  st <- getState-  let oldLang = synStLanguage st-  setState $ st { synStLanguage = "Bash" }-  context <- currentContext <|> (pushContext "Start" >> currentContext)-  result <- parseRules context-  updateState $ \st -> st { synStLanguage = oldLang }-  return result--parseSource = do -  lineContents <- lookAhead wholeLine-  updateState $ \st -> st { synStCurrentLine = lineContents }-  result <- manyTill parseSourceLine eof-  return $ map normalizeHighlighting result--startingState = SyntaxState {synStContexts = fromList [("Bash",["Start"])], synStLanguage = "Bash", synStCurrentLine = "", synStCharsParsedInLine = 0, synStPrevChar = '\n', synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}--parseSourceLine = manyTill parseExpressionInternal pEndLine--pEndLine = do-  lookAhead $ newline <|> (eof >> return '\n')-  context <- currentContext-  case context of-    "Start" -> return () >> pHandleEndLine-    "FindAll" -> return () >> pHandleEndLine-    "FindMost" -> return () >> pHandleEndLine-    "FindComments" -> (popContext) >> pEndLine-    "Comment" -> (popContext) >> pEndLine-    "FindCommentsParen" -> (popContext) >> pEndLine-    "CommentParen" -> (popContext) >> pEndLine-    "FindCommentsBackq" -> (popContext) >> pEndLine-    "CommentBackq" -> (popContext) >> pEndLine-    "FindCommands" -> return () >> pHandleEndLine-    "FindOthers" -> return () >> pHandleEndLine-    "FindStrings" -> return () >> pHandleEndLine-    "FindSubstitutions" -> return () >> pHandleEndLine-    "FindTests" -> return () >> pHandleEndLine-    "ExprDblParen" -> return () >> pHandleEndLine-    "ExprDblParenSubst" -> return () >> pHandleEndLine-    "ExprSubParen" -> return () >> pHandleEndLine-    "ExprBracket" -> return () >> pHandleEndLine-    "ExprDblBracket" -> return () >> pHandleEndLine-    "Group" -> return () >> pHandleEndLine-    "SubShell" -> return () >> pHandleEndLine-    "Assign" -> (popContext) >> pEndLine-    "AssignArray" -> (popContext) >> pEndLine-    "AssignSubscr" -> (popContext) >> pEndLine-    "Subscript" -> return () >> pHandleEndLine-    "FunctionDef" -> (popContext) >> pEndLine-    "VarName" -> (popContext) >> pEndLine-    "ProcessSubst" -> return () >> pHandleEndLine-    "StringSQ" -> return () >> pHandleEndLine-    "StringDQ" -> return () >> pHandleEndLine-    "StringEsc" -> return () >> pHandleEndLine-    "VarBrace" -> return () >> pHandleEndLine-    "VarAlt" -> return () >> pHandleEndLine-    "VarSubst" -> return () >> pHandleEndLine-    "VarSubst2" -> return () >> pHandleEndLine-    "VarSub" -> return () >> pHandleEndLine-    "VarSub2" -> return () >> pHandleEndLine-    "SubstFile" -> return () >> pHandleEndLine-    "SubstCommand" -> return () >> pHandleEndLine-    "SubstBackq" -> return () >> pHandleEndLine-    "Case" -> return () >> pHandleEndLine-    "CaseIn" -> return () >> pHandleEndLine-    "CaseExpr" -> return () >> pHandleEndLine-    "HereDoc" -> return () >> pHandleEndLine-    "HereDocRemainder" -> (popContext) >> pEndLine-    "HereDocQ" -> return () >> pHandleEndLine-    "HereDocNQ" -> return () >> pHandleEndLine-    "HereDocIQ" -> return () >> pHandleEndLine-    "HereDocINQ" -> return () >> pHandleEndLine-    _ -> pHandleEndLine--withAttribute attr txt = do-  when (null txt) $ fail "Parser matched no text"-  let labs = attr : maybeToList (lookup attr styles)-  st <- getState-  let oldCharsParsed = synStCharsParsedInLine st-  let prevchar = if null txt then '\n' else last txt-  updateState $ \st -> st { synStCharsParsedInLine = oldCharsParsed + length txt, synStPrevChar = prevchar } -  return (labs, txt)--styles = [("Comment","co"),("Keyword","kw"),("Control","kw"),("Builtin","kw"),("Command","kw"),("Redirection","kw"),("Escape","dt"),("String SingleQ","st"),("String DoubleQ","st"),("Backquote","kw"),("String Transl.","st"),("String Escape","dt"),("Variable","ot"),("Expression","ot"),("Function","fu"),("Error","er")]--parseExpressionInternal = do-  context <- currentContext-  parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes))--list_keywords = Set.fromList $ words $ "else for function in select until while elif then set"-list_builtins = Set.fromList $ words $ ": source alias bg bind break builtin cd caller 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 suspend test time times trap type ulimit umask unalias wait"-list_builtins'5fvar = Set.fromList $ words $ "export unset declare typeset local read readonly"-list_unixcommands = Set.fromList $ words $ "arch awk bash bunzip2 bzcat bzcmp bzdiff bzegrep bzfgrep bzgrep bzip2 bzip2recover bzless bzmore cat chattr chgrp chmod chown chvt cp date dd deallocvt df dir dircolors dmesg dnsdomainname domainname du dumpkeys echo ed egrep false fgconsole fgrep fuser gawk getkeycodes gocr grep groff groups gunzip gzexe gzip hostname igawk install kbd_mode kbdrate killall last lastb link ln loadkeys loadunimap login ls lsattr lsmod lsmod.old lzcat lzcmp lzdiff lzegrep lzfgrep lzgrep lzless lzcat lzma lzmainfo lzmore mapscrn mesg mkdir mkfifo mknod mktemp more mount mv nano netstat nisdomainname nroff openvt pgawk pidof ping ps pstree pwd rbash readlink red resizecons rm rmdir run-parts sash sed setfont setkeycodes setleds setmetamode setserial sh showkey shred sleep ssed stat stty su sync tar tempfile touch troff true umount uname unicode_start unicode_stop unlink unlzma unxz utmpdump uuidgen vdir wall wc xz xzcat ypdomainname zcat zcmp zdiff zegrep zfgrep zforce zgrep zless zmore znew zsh aclocal aconnect aplay apm apmsleep apropos ar arecord as as86 autoconf autoheader automake awk basename bc bison c++ cal cat cc cdda2wav cdparanoia cdrdao cd-read cdrecord chfn chgrp chmod chown chroot chsh clear cmp co col comm cp cpio cpp cut dc dd df diff diff3 dir dircolors directomatic dirname du env expr fbset file find flex flex++ fmt free ftp funzip fuser g++ gawk gc gcc gdb getent getopt gettext gettextize gimp gimp-remote gimptool gmake gs head hexdump id install join kill killall ld ld86 ldd less lex ln locate lockfile logname lp lpr ls lynx m4 make man mkdir mknod msgfmt mv namei nasm nawk nice nl nm nm86 nmap nohup nop od passwd patch pcregrep pcretest perl perror pidof pr printf procmail prune ps2ascii ps2epsi ps2frag ps2pdf ps2ps psbook psmerge psnup psresize psselect pstops rcs rev rm scp sed seq setterm shred size size86 skill slogin snice sort sox split ssh ssh-add ssh-agent ssh-keygen ssh-keyscan stat strings strip sudo suidperl sum tac tail tee test tr uniq unlink unzip updatedb updmap uptime users vmstat w wc wget whatis whereis which who whoami write xargs yacc yes zip zsoelim dcop kdialog kfile xhost xmodmap xset"--regex_'5b'5cs'3b'5d'28'3f'3d'23'29 = compileRegex "[\\s;](?=#)"-regex_'5b'5e'29'5d'28'3f'3d'5c'29'29 = compileRegex "[^)](?=\\))"-regex_'5b'5e'60'5d'28'3f'3d'60'29 = compileRegex "[^`](?=`)"-regex_'5c'5b'5c'5b'28'3f'3d'28'24'7c'5cs'29'29 = compileRegex "\\[\\[(?=($|\\s))"-regex_'5cs'5c'5b'5c'5b'28'3f'3d'28'24'7c'5cs'29'29 = compileRegex "\\s\\[\\[(?=($|\\s))"-regex_'5c'5b'28'3f'3d'28'24'7c'5cs'29'29 = compileRegex "\\[(?=($|\\s))"-regex_'5cs'5c'5b'28'3f'3d'28'24'7c'5cs'29'29 = compileRegex "\\s\\[(?=($|\\s))"-regex_'5c'7b'28'3f'3d'28'24'7c'5cs'29'29 = compileRegex "\\{(?=($|\\s))"-regex_'5cbdo'28'3f'21'5b'5cw'24'2b'2d'5d'29 = compileRegex "\\bdo(?![\\w$+-])"-regex_'5cbdone'28'3f'21'5b'5cw'24'2b'2d'5d'29 = compileRegex "\\bdone(?![\\w$+-])"-regex_'5cbif_'28'3f'21'5b'5cw'24'2b'2d'5d'29 = compileRegex "\\bif (?![\\w$+-])"-regex_'5cbfi'28'3f'21'5b'5cw'24'2b'2d'5d'29 = compileRegex "\\bfi(?![\\w$+-])"-regex_'5cbcase'28'3f'21'5b'5cw'24'2b'2d'5d'29 = compileRegex "\\bcase(?![\\w$+-])"-regex_'2d'5bA'2dZa'2dz0'2d9'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a = compileRegex "-[A-Za-z0-9][A-Za-z0-9_]*"-regex_'2d'2d'5ba'2dz'5d'5bA'2dZa'2dz0'2d9'5f'2d'5d'2a = compileRegex "--[a-z][A-Za-z0-9_-]*"-regex_'5cb'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'5c'2b'3f'3d = compileRegex "\\b[A-Za-z_][A-Za-z0-9_]*\\+?="-regex_'5cb'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'28'3f'3d'5c'5b'2e'2b'5c'5d'5c'2b'3f'3d'29 = compileRegex "\\b[A-Za-z_][A-Za-z0-9_]*(?=\\[.+\\]\\+?=)"-regex_'5cbfunction'5cb = compileRegex "\\bfunction\\b"-regex_'5c'2e'28'3f'3d'5cs'29 = compileRegex "\\.(?=\\s)"-regex_'5cd'2a'3c'3c'3c = compileRegex "\\d*<<<"-regex_'5b'3c'3e'5d'5c'28 = compileRegex "[<>]\\("-regex_'28'5b0'2d9'5d'2a'28'3e'7b1'2c2'7d'7c'3c'29'28'26'5b0'2d9'5d'2b'2d'3f'29'3f'7c'26'3e'7c'3e'26'7c'5b0'2d9'5d'2a'3c'3e'29 = compileRegex "([0-9]*(>{1,2}|<)(&[0-9]+-?)?|&>|>&|[0-9]*<>)"-regex_'28'5b'7c'26'5d'29'5c1'3f = compileRegex "([|&])\\1?"-regex_'5bA'2dZa'2dz'5f'3a'5d'5bA'2dZa'2dz0'2d9'5f'3a'23'25'40'2d'5d'2a'5cs'2a'5c'28'5c'29 = compileRegex "[A-Za-z_:][A-Za-z0-9_:#%@-]*\\s*\\(\\)"-regex_'5c'5c'5b'5d'5b'3b'5c'5c'24'60'7b'7d'28'29'7c'26'3c'3e'2a_'5d = compileRegex "\\\\[][;\\\\$`{}()|&<>* ]"-regex_'5c'5c'24 = compileRegex "\\\\$"-regex_'5c'7b'28'3f'21'28'5cs'7c'24'29'29'5cS'2a'5c'7d = compileRegex "\\{(?!(\\s|$))\\S*\\}"-regex_'28'5b'5cw'5f'40'2e'25'2a'3f'2b'2d'5d'7c'5c'5c_'29'2a'28'3f'3d'2f'29 = compileRegex "([\\w_@.%*?+-]|\\\\ )*(?=/)"-regex_'7e'5cw'2a = compileRegex "~\\w*"-regex_'2f'28'5b'5cw'5f'40'2e'25'2a'3f'2b'2d'5d'7c'5c'5c_'29'2a'28'3f'3d'28'5b'5cs'2f'29'3a'3b'24'60'27'22'5d'7c'24'29'29 = compileRegex "/([\\w_@.%*?+-]|\\\\ )*(?=([\\s/):;$`'\"]|$))"-regex_'5c'24'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'5c'5b = compileRegex "\\$[A-Za-z_][A-Za-z0-9_]*\\["-regex_'5c'24'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a = compileRegex "\\$[A-Za-z_][A-Za-z0-9_]*"-regex_'5c'24'5b'2a'40'23'3f'24'21'5f0'2d9'2d'5d = compileRegex "\\$[*@#?$!_0-9-]"-regex_'5c'24'5c'7b'5b'2a'40'23'3f'24'21'5f0'2d9'2d'5d'5c'7d = compileRegex "\\$\\{[*@#?$!_0-9-]\\}"-regex_'5c'24'5c'7b'23'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'28'5c'5b'5b'2a'40'5d'5c'5d'29'3f'5c'7d = compileRegex "\\$\\{#[A-Za-z_][A-Za-z0-9_]*(\\[[*@]\\])?\\}"-regex_'5c'24'5c'7b'21'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'28'5c'5b'5b'2a'40'5d'5c'5d'7c'5b'2a'40'5d'29'3f'5c'7d = compileRegex "\\$\\{![A-Za-z_][A-Za-z0-9_]*(\\[[*@]\\]|[*@])?\\}"-regex_'5c'24'5c'7b'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a = compileRegex "\\$\\{[A-Za-z_][A-Za-z0-9_]*"-regex_'5c'24'5c'7b'5b'2a'40'23'3f'24'21'5f0'2d9'2d'5d'28'3f'3d'5b'3a'23'25'2f'3d'3f'2b'2d'5d'29 = compileRegex "\\$\\{[*@#?$!_0-9-](?=[:#%/=?+-])"-regex_'5c'5c'5b'60'24'5c'5c'5d = compileRegex "\\\\[`$\\\\]"-regex_'2d'5babcdefghkprstuwxOGLSNozn'5d'28'3f'3d'5cs'29 = compileRegex "-[abcdefghkprstuwxOGLSNozn](?=\\s)"-regex_'2d'28'5bno'5dt'7cef'29'28'3f'3d'5cs'29 = compileRegex "-([no]t|ef)(?=\\s)"-regex_'28'5b'21'3d'5d'3d'3f'7c'5b'3e'3c'5d'29'28'3f'3d'5cs'29 = compileRegex "([!=]=?|[><])(?=\\s)"-regex_'2d'28eq'7cne'7c'5bgl'5d'5bte'5d'29'28'3f'3d'5cs'29 = compileRegex "-(eq|ne|[gl][te])(?=\\s)"-regex_'5cs'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 = compileRegex "\\s\\](?=($|[\\s;|&]))"-regex_'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 = compileRegex "\\](?=($|[\\s;|&]))"-regex_'5cs'5c'5d'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 = compileRegex "\\s\\]\\](?=($|[\\s;|&]))"-regex_'5c'5d'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 = compileRegex "\\]\\](?=($|[\\s;|&]))"-regex_'5b'5cw'3a'2c'2b'5f'2e'2f'2d'5d = compileRegex "[\\w:,+_./-]"-regex_'5cs'2b'5bA'2dZa'2dz'5f'3a'5d'5bA'2dZa'2dz0'2d9'5f'3a'23'25'40'2d'5d'2a'28'5cs'2a'5c'28'5c'29'29'3f = compileRegex "\\s+[A-Za-z_:][A-Za-z0-9_:#%@-]*(\\s*\\(\\))?"-regex_'2d'5bA'2dZa'2dz0'2d9'5d'2b = compileRegex "-[A-Za-z0-9]+"-regex_'5cb'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a = compileRegex "\\b[A-Za-z_][A-Za-z0-9_]*"-regex_'5b'5e'5d'7d'29'7c'3b'60'26'3e'3c'5d = compileRegex "[^]})|;`&><]"-regex_'5c'5c'5b'60'22'5c'5c'24'5cn'5d = compileRegex "\\\\[`\"\\\\$\\n]"-regex_'5c'5c'5babefnrtv'5c'5c'27'5d = compileRegex "\\\\[abefnrtv\\\\']"-regex_'5c'5c'28'5b0'2d7'5d'7b1'2c3'7d'7cx'5bA'2dFa'2df0'2d9'5d'7b1'2c2'7d'7cc'2e'29 = compileRegex "\\\\([0-7]{1,3}|x[A-Fa-f0-9]{1,2}|c.)"-regex_'28'3a'3f'5b'2d'3d'3f'2b'5d'7c'23'23'3f'7c'25'25'3f'29 = compileRegex "(:?[-=?+]|##?|%%?)"-regex_'2f'2f'3f = compileRegex "//?"-regex_'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a = compileRegex "[A-Za-z_][A-Za-z0-9_]*"-regex_'5b0'2d9'5d'2b'28'3f'3d'5b'3a'7d'5d'29 = compileRegex "[0-9]+(?=[:}])"-regex_'5b0'2d9'5d'28'3f'3d'5b'3a'7d'5d'29 = compileRegex "[0-9](?=[:}])"-regex_'5csin'5cb = compileRegex "\\sin\\b"-regex_'5cbesac'28'3f'3d'24'7c'5b'5cs'3b'29'5d'29 = compileRegex "\\besac(?=$|[\\s;)])"-regex_esac'28'3f'3d'24'7c'5b'5cs'3b'29'5d'29 = compileRegex "esac(?=$|[\\s;)])"-regex_'28'3c'3c'2d'5cs'2a'22'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'22'29 = compileRegex "(<<-\\s*\"([^|&;()<>\\s]+)\")"-regex_'28'3c'3c'2d'5cs'2a'27'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'27'29 = compileRegex "(<<-\\s*'([^|&;()<>\\s]+)')"-regex_'28'3c'3c'2d'5cs'2a'5c'5c'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'29 = compileRegex "(<<-\\s*\\\\([^|&;()<>\\s]+))"-regex_'28'3c'3c'2d'5cs'2a'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'29 = compileRegex "(<<-\\s*([^|&;()<>\\s]+))"-regex_'28'3c'3c'5cs'2a'22'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'22'29 = compileRegex "(<<\\s*\"([^|&;()<>\\s]+)\")"-regex_'28'3c'3c'5cs'2a'27'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'27'29 = compileRegex "(<<\\s*'([^|&;()<>\\s]+)')"-regex_'28'3c'3c'5cs'2a'5c'5c'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'29 = compileRegex "(<<\\s*\\\\([^|&;()<>\\s]+))"-regex_'28'3c'3c'5cs'2a'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'29 = compileRegex "(<<\\s*([^|&;()<>\\s]+))"--defaultAttributes = [("Start","Normal Text"),("FindAll","Normal Text"),("FindMost","Normal Text"),("FindComments","Normal Text"),("Comment","Comment"),("FindCommentsParen","Normal Text"),("CommentParen","Comment"),("FindCommentsBackq","Normal Text"),("CommentBackq","Comment"),("FindCommands","Normal Text"),("FindOthers","Normal Text"),("FindStrings","Normal Text"),("FindSubstitutions","Normal Text"),("FindTests","Normal Text"),("ExprDblParen","Normal Text"),("ExprDblParenSubst","Normal Text"),("ExprSubParen","Normal Text"),("ExprBracket","Normal Text"),("ExprDblBracket","Normal Text"),("Group","Normal Text"),("SubShell","Normal Text"),("Assign","Normal Text"),("AssignArray","Normal Text"),("AssignSubscr","Normal Text"),("Subscript","Variable"),("FunctionDef","Function"),("VarName","Normal Text"),("ProcessSubst","Normal Text"),("StringSQ","String SingleQ"),("StringDQ","String DoubleQ"),("StringEsc","String SingleQ"),("VarBrace","Error"),("VarAlt","Normal Text"),("VarSubst","Normal Text"),("VarSubst2","Normal Text"),("VarSub","Error"),("VarSub2","Error"),("SubstFile","Normal Text"),("SubstCommand","Normal Text"),("SubstBackq","Normal Text"),("Case","Normal Text"),("CaseIn","Normal Text"),("CaseExpr","Normal Text"),("HereDoc","Normal Text"),("HereDocRemainder","Normal Text"),("HereDocQ","Normal Text"),("HereDocNQ","Normal Text"),("HereDocIQ","Normal Text"),("HereDocINQ","Normal Text")]--parseRules "Start" = -  do (attr, result) <- ((parseRules "FindAll"))-     return (attr, result)--parseRules "FindAll" = -  do (attr, result) <- (((parseRules "FindComments"))-                        <|>-                        ((parseRules "FindCommands"))-                        <|>-                        ((parseRules "FindStrings"))-                        <|>-                        ((parseRules "FindSubstitutions"))-                        <|>-                        ((parseRules "FindOthers")))-     return (attr, result)--parseRules "FindMost" = -  do (attr, result) <- (((parseRules "FindComments"))-                        <|>-                        ((parseRules "FindStrings"))-                        <|>-                        ((parseRules "FindSubstitutions"))-                        <|>-                        ((parseRules "FindOthers")))-     return (attr, result)--parseRules "FindComments" = -  do (attr, result) <- (((pFirstNonSpace >> pDetectChar False '#' >>= withAttribute "Comment") >>~ pushContext "Comment")-                        <|>-                        ((pRegExpr regex_'5b'5cs'3b'5d'28'3f'3d'23'29 >>= withAttribute "Normal Text") >>~ pushContext "Comment"))-     return (attr, result)--parseRules "Comment" = -  do (attr, result) <- ((Text.Highlighting.Kate.Syntax.Alert.parseExpression))-     return (attr, result)--parseRules "FindCommentsParen" = -  do (attr, result) <- (((pFirstNonSpace >> pDetectChar False '#' >>= withAttribute "Comment") >>~ pushContext "CommentParen")-                        <|>-                        ((pRegExpr regex_'5b'5cs'3b'5d'28'3f'3d'23'29 >>= withAttribute "Normal Text") >>~ pushContext "CommentParen"))-     return (attr, result)--parseRules "CommentParen" = -  do (attr, result) <- (((pRegExpr regex_'5b'5e'29'5d'28'3f'3d'5c'29'29 >>= withAttribute "Comment") >>~ (popContext))-                        <|>-                        ((Text.Highlighting.Kate.Syntax.Alert.parseExpression)))-     return (attr, result)--parseRules "FindCommentsBackq" = -  do (attr, result) <- (((pFirstNonSpace >> pDetectChar False '#' >>= withAttribute "Comment") >>~ pushContext "CommentBackq")-                        <|>-                        ((pRegExpr regex_'5b'5cs'3b'5d'28'3f'3d'23'29 >>= withAttribute "Normal Text") >>~ pushContext "CommentBackq"))-     return (attr, result)--parseRules "CommentBackq" = -  do (attr, result) <- (((pRegExpr regex_'5b'5e'60'5d'28'3f'3d'60'29 >>= withAttribute "Comment") >>~ (popContext))-                        <|>-                        ((Text.Highlighting.Kate.Syntax.Alert.parseExpression)))-     return (attr, result)--parseRules "FindCommands" = -  do (attr, result) <- (((pDetect2Chars False '(' '(' >>= withAttribute "Keyword") >>~ pushContext "ExprDblParen")-                        <|>-                        ((pColumn 0 >> pRegExpr regex_'5c'5b'5c'5b'28'3f'3d'28'24'7c'5cs'29'29 >>= withAttribute "Keyword") >>~ pushContext "ExprDblBracket")-                        <|>-                        ((pRegExpr regex_'5cs'5c'5b'5c'5b'28'3f'3d'28'24'7c'5cs'29'29 >>= withAttribute "Keyword") >>~ pushContext "ExprDblBracket")-                        <|>-                        ((pColumn 0 >> pRegExpr regex_'5c'5b'28'3f'3d'28'24'7c'5cs'29'29 >>= withAttribute "Builtin") >>~ pushContext "ExprBracket")-                        <|>-                        ((pRegExpr regex_'5cs'5c'5b'28'3f'3d'28'24'7c'5cs'29'29 >>= withAttribute "Builtin") >>~ pushContext "ExprBracket")-                        <|>-                        ((pRegExpr regex_'5c'7b'28'3f'3d'28'24'7c'5cs'29'29 >>= withAttribute "Keyword") >>~ pushContext "Group")-                        <|>-                        ((pDetectChar False '(' >>= withAttribute "Keyword") >>~ pushContext "SubShell")-                        <|>-                        ((pRegExpr regex_'5cbdo'28'3f'21'5b'5cw'24'2b'2d'5d'29 >>= withAttribute "Keyword"))-                        <|>-                        ((pRegExpr regex_'5cbdone'28'3f'21'5b'5cw'24'2b'2d'5d'29 >>= withAttribute "Keyword"))-                        <|>-                        ((pRegExpr regex_'5cbif_'28'3f'21'5b'5cw'24'2b'2d'5d'29 >>= withAttribute "Keyword"))-                        <|>-                        ((pRegExpr regex_'5cbfi'28'3f'21'5b'5cw'24'2b'2d'5d'29 >>= withAttribute "Keyword"))-                        <|>-                        ((pRegExpr regex_'5cbcase'28'3f'21'5b'5cw'24'2b'2d'5d'29 >>= withAttribute "Keyword") >>~ pushContext "Case")-                        <|>-                        ((pRegExpr regex_'2d'5bA'2dZa'2dz0'2d9'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a >>= withAttribute "Option"))-                        <|>-                        ((pRegExpr regex_'2d'2d'5ba'2dz'5d'5bA'2dZa'2dz0'2d9'5f'2d'5d'2a >>= withAttribute "Option"))-                        <|>-                        ((pRegExpr regex_'5cb'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'5c'2b'3f'3d >>= withAttribute "Variable") >>~ pushContext "Assign")-                        <|>-                        ((pRegExpr regex_'5cb'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'28'3f'3d'5c'5b'2e'2b'5c'5d'5c'2b'3f'3d'29 >>= withAttribute "Variable") >>~ pushContext "AssignSubscr")-                        <|>-                        ((pString False ":()" >>= withAttribute "Function"))-                        <|>-                        ((pRegExpr regex_'5cbfunction'5cb >>= withAttribute "Keyword") >>~ pushContext "FunctionDef")-                        <|>-                        ((pKeyword " \n\t()!+,<=>&*;?|~\\`" list_keywords >>= withAttribute "Keyword"))-                        <|>-                        ((pRegExpr regex_'5c'2e'28'3f'3d'5cs'29 >>= withAttribute "Builtin"))-                        <|>-                        ((pKeyword " \n\t()!+,<=>&*;?|~\\`" list_builtins >>= withAttribute "Builtin"))-                        <|>-                        ((pKeyword " \n\t()!+,<=>&*;?|~\\`" list_unixcommands >>= withAttribute "Command"))-                        <|>-                        ((pKeyword " \n\t()!+,<=>&*;?|~\\`" list_builtins'5fvar >>= withAttribute "Builtin") >>~ pushContext "VarName")-                        <|>-                        ((pRegExpr regex_'5cd'2a'3c'3c'3c >>= withAttribute "Redirection"))-                        <|>-                        ((lookAhead (pString False "<<") >> return ([],"") ) >>~ pushContext "HereDoc")-                        <|>-                        ((pRegExpr regex_'5b'3c'3e'5d'5c'28 >>= withAttribute "Redirection") >>~ pushContext "ProcessSubst")-                        <|>-                        ((pRegExpr regex_'28'5b0'2d9'5d'2a'28'3e'7b1'2c2'7d'7c'3c'29'28'26'5b0'2d9'5d'2b'2d'3f'29'3f'7c'26'3e'7c'3e'26'7c'5b0'2d9'5d'2a'3c'3e'29 >>= withAttribute "Redirection"))-                        <|>-                        ((pRegExpr regex_'28'5b'7c'26'5d'29'5c1'3f >>= withAttribute "Control"))-                        <|>-                        ((pRegExpr regex_'5bA'2dZa'2dz'5f'3a'5d'5bA'2dZa'2dz0'2d9'5f'3a'23'25'40'2d'5d'2a'5cs'2a'5c'28'5c'29 >>= withAttribute "Function")))-     return (attr, result)--parseRules "FindOthers" = -  do (attr, result) <- (((pRegExpr regex_'5c'5c'5b'5d'5b'3b'5c'5c'24'60'7b'7d'28'29'7c'26'3c'3e'2a_'5d >>= withAttribute "Escape"))-                        <|>-                        ((pRegExpr regex_'5c'5c'24 >>= withAttribute "Keyword"))-                        <|>-                        ((pRegExpr regex_'5c'7b'28'3f'21'28'5cs'7c'24'29'29'5cS'2a'5c'7d >>= withAttribute "Escape"))-                        <|>-                        ((pRegExpr regex_'28'5b'5cw'5f'40'2e'25'2a'3f'2b'2d'5d'7c'5c'5c_'29'2a'28'3f'3d'2f'29 >>= withAttribute "Path"))-                        <|>-                        ((pRegExpr regex_'7e'5cw'2a >>= withAttribute "Path"))-                        <|>-                        ((pRegExpr regex_'2f'28'5b'5cw'5f'40'2e'25'2a'3f'2b'2d'5d'7c'5c'5c_'29'2a'28'3f'3d'28'5b'5cs'2f'29'3a'3b'24'60'27'22'5d'7c'24'29'29 >>= withAttribute "Path")))-     return (attr, result)--parseRules "FindStrings" = -  do (attr, result) <- (((pDetect2Chars False '\\' '\'' >>= withAttribute "Escape"))-                        <|>-                        ((pDetect2Chars False '\\' '"' >>= withAttribute "Escape"))-                        <|>-                        ((pDetectChar False '\'' >>= withAttribute "String SingleQ") >>~ pushContext "StringSQ")-                        <|>-                        ((pDetectChar False '"' >>= withAttribute "String DoubleQ") >>~ pushContext "StringDQ")-                        <|>-                        ((pDetect2Chars False '$' '\'' >>= withAttribute "String SingleQ") >>~ pushContext "StringEsc")-                        <|>-                        ((pDetect2Chars False '$' '"' >>= withAttribute "String Transl.") >>~ pushContext "StringDQ"))-     return (attr, result)--parseRules "FindSubstitutions" = -  do (attr, result) <- (((pRegExpr regex_'5c'24'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'5c'5b >>= withAttribute "Variable") >>~ pushContext "Subscript")-                        <|>-                        ((pRegExpr regex_'5c'24'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a >>= withAttribute "Variable"))-                        <|>-                        ((pRegExpr regex_'5c'24'5b'2a'40'23'3f'24'21'5f0'2d9'2d'5d >>= withAttribute "Variable"))-                        <|>-                        ((pRegExpr regex_'5c'24'5c'7b'5b'2a'40'23'3f'24'21'5f0'2d9'2d'5d'5c'7d >>= withAttribute "Variable"))-                        <|>-                        ((pRegExpr regex_'5c'24'5c'7b'23'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'28'5c'5b'5b'2a'40'5d'5c'5d'29'3f'5c'7d >>= withAttribute "Variable"))-                        <|>-                        ((pRegExpr regex_'5c'24'5c'7b'21'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'28'5c'5b'5b'2a'40'5d'5c'5d'7c'5b'2a'40'5d'29'3f'5c'7d >>= withAttribute "Variable"))-                        <|>-                        ((pRegExpr regex_'5c'24'5c'7b'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a >>= withAttribute "Variable") >>~ pushContext "VarBrace")-                        <|>-                        ((pRegExpr regex_'5c'24'5c'7b'5b'2a'40'23'3f'24'21'5f0'2d9'2d'5d'28'3f'3d'5b'3a'23'25'2f'3d'3f'2b'2d'5d'29 >>= withAttribute "Variable") >>~ pushContext "VarBrace")-                        <|>-                        ((pString False "$((" >>= withAttribute "Variable") >>~ pushContext "ExprDblParenSubst")-                        <|>-                        ((pString False "$(<" >>= withAttribute "Redirection") >>~ pushContext "SubstFile")-                        <|>-                        ((pString False "$(" >>= withAttribute "Variable") >>~ pushContext "SubstCommand")-                        <|>-                        ((pDetectChar False '`' >>= withAttribute "Backquote") >>~ pushContext "SubstBackq")-                        <|>-                        ((pRegExpr regex_'5c'5c'5b'60'24'5c'5c'5d >>= withAttribute "Escape")))-     return (attr, result)--parseRules "FindTests" = -  do (attr, result) <- (((pRegExpr regex_'2d'5babcdefghkprstuwxOGLSNozn'5d'28'3f'3d'5cs'29 >>= withAttribute "Expression"))-                        <|>-                        ((pRegExpr regex_'2d'28'5bno'5dt'7cef'29'28'3f'3d'5cs'29 >>= withAttribute "Expression"))-                        <|>-                        ((pRegExpr regex_'28'5b'21'3d'5d'3d'3f'7c'5b'3e'3c'5d'29'28'3f'3d'5cs'29 >>= withAttribute "Expression"))-                        <|>-                        ((pRegExpr regex_'2d'28eq'7cne'7c'5bgl'5d'5bte'5d'29'28'3f'3d'5cs'29 >>= withAttribute "Expression")))-     return (attr, result)--parseRules "ExprDblParen" = -  do (attr, result) <- (((pDetect2Chars False ')' ')' >>= withAttribute "Keyword") >>~ (popContext))-                        <|>-                        ((pDetectChar False '(' >>= withAttribute "Normal Text") >>~ pushContext "ExprSubParen")-                        <|>-                        ((parseRules "FindMost")))-     return (attr, result)--parseRules "ExprDblParenSubst" = -  do (attr, result) <- (((pDetect2Chars False ')' ')' >>= withAttribute "Variable") >>~ (popContext))-                        <|>-                        ((pDetectChar False '(' >>= withAttribute "Normal Text") >>~ pushContext "ExprSubParen")-                        <|>-                        ((parseRules "FindMost")))-     return (attr, result)--parseRules "ExprSubParen" = -  do (attr, result) <- (((pDetectChar False ')' >>= withAttribute "Normal Text") >>~ (popContext))-                        <|>-                        ((pDetectChar False '(' >>= withAttribute "Normal Text") >>~ pushContext "ExprSubParen")-                        <|>-                        ((parseRules "FindMost")))-     return (attr, result)--parseRules "ExprBracket" = -  do (attr, result) <- (((pRegExpr regex_'5cs'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 >>= withAttribute "Builtin") >>~ (popContext))-                        <|>-                        ((pColumn 0 >> pRegExpr regex_'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 >>= withAttribute "Builtin") >>~ (popContext))-                        <|>-                        ((pDetectChar False '(' >>= withAttribute "Normal Text") >>~ pushContext "ExprSubParen")-                        <|>-                        ((parseRules "FindTests"))-                        <|>-                        ((parseRules "FindMost")))-     return (attr, result)--parseRules "ExprDblBracket" = -  do (attr, result) <- (((pRegExpr regex_'5cs'5c'5d'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 >>= withAttribute "Keyword") >>~ (popContext))-                        <|>-                        ((pColumn 0 >> pRegExpr regex_'5c'5d'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 >>= withAttribute "Keyword") >>~ (popContext))-                        <|>-                        ((pDetectChar False '(' >>= withAttribute "Normal Text") >>~ pushContext "ExprSubParen")-                        <|>-                        ((parseRules "FindTests"))-                        <|>-                        ((parseRules "FindMost")))-     return (attr, result)--parseRules "Group" = -  do (attr, result) <- (((pDetectChar False '}' >>= withAttribute "Keyword") >>~ (popContext))-                        <|>-                        ((parseRules "FindAll")))-     return (attr, result)--parseRules "SubShell" = -  do (attr, result) <- (((pDetectChar False ')' >>= withAttribute "Keyword") >>~ (popContext))-                        <|>-                        ((parseRules "FindAll")))-     return (attr, result)--parseRules "Assign" = -  do (attr, result) <- (((pDetectChar False '(' >>= withAttribute "Variable") >>~ pushContext "AssignArray")-                        <|>-                        ((parseRules "FindStrings"))-                        <|>-                        ((parseRules "FindSubstitutions"))-                        <|>-                        ((parseRules "FindOthers"))-                        <|>-                        ((pRegExpr regex_'5b'5cw'3a'2c'2b'5f'2e'2f'2d'5d >>= withAttribute "Normal Text"))-                        <|>-                        ((popContext) >> return ([], "")))-     return (attr, result)--parseRules "AssignArray" = -  do (attr, result) <- (((pDetectChar False ')' >>= withAttribute "Variable") >>~ (popContext))-                        <|>-                        ((pDetectChar False '[' >>= withAttribute "Variable") >>~ pushContext "Subscript")-                        <|>-                        ((pDetectChar False '=' >>= withAttribute "Variable") >>~ pushContext "Assign")-                        <|>-                        ((parseRules "FindMost")))-     return (attr, result)--parseRules "AssignSubscr" = -  do (attr, result) <- (((pDetectChar False '[' >>= withAttribute "Variable") >>~ pushContext "Subscript")-                        <|>-                        ((pDetect2Chars False '+' '=' >>= withAttribute "Variable") >>~ pushContext "Assign")-                        <|>-                        ((pDetectChar False '=' >>= withAttribute "Variable") >>~ pushContext "Assign")-                        <|>-                        ((parseRules "FindStrings"))-                        <|>-                        ((parseRules "FindSubstitutions"))-                        <|>-                        ((parseRules "FindOthers"))-                        <|>-                        ((popContext) >> return ([], "")))-     return (attr, result)--parseRules "Subscript" = -  do (attr, result) <- (((pDetectChar False ']' >>= withAttribute "Variable") >>~ (popContext))-                        <|>-                        ((parseRules "FindStrings"))-                        <|>-                        ((parseRules "FindSubstitutions"))-                        <|>-                        ((parseRules "FindOthers")))-     return (attr, result)--parseRules "FunctionDef" = -  do (attr, result) <- (((pRegExpr regex_'5cs'2b'5bA'2dZa'2dz'5f'3a'5d'5bA'2dZa'2dz0'2d9'5f'3a'23'25'40'2d'5d'2a'28'5cs'2a'5c'28'5c'29'29'3f >>= withAttribute "Function") >>~ (popContext))-                        <|>-                        ((popContext) >> return ([], "")))-     return (attr, result)--parseRules "VarName" = -  do (attr, result) <- (((pRegExpr regex_'2d'5bA'2dZa'2dz0'2d9'5d'2b >>= withAttribute "Option"))-                        <|>-                        ((pRegExpr regex_'2d'2d'5ba'2dz'5d'5bA'2dZa'2dz0'2d9'5f'2d'5d'2a >>= withAttribute "Option"))-                        <|>-                        ((pRegExpr regex_'5cb'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a >>= withAttribute "Variable"))-                        <|>-                        ((pDetectChar False '[' >>= withAttribute "Variable") >>~ pushContext "Subscript")-                        <|>-                        ((pDetectChar False '=' >>= withAttribute "Variable") >>~ pushContext "Assign")-                        <|>-                        ((parseRules "FindMost"))-                        <|>-                        ((pRegExpr regex_'5b'5e'5d'7d'29'7c'3b'60'26'3e'3c'5d >>= withAttribute "Normal Text"))-                        <|>-                        ((popContext) >> return ([], "")))-     return (attr, result)--parseRules "ProcessSubst" = -  do (attr, result) <- (((pDetectChar False ')' >>= withAttribute "Redirection") >>~ (popContext))-                        <|>-                        ((parseRules "FindCommentsParen"))-                        <|>-                        ((parseRules "FindCommands"))-                        <|>-                        ((parseRules "FindStrings"))-                        <|>-                        ((parseRules "FindSubstitutions"))-                        <|>-                        ((parseRules "FindOthers")))-     return (attr, result)--parseRules "StringSQ" = -  do (attr, result) <- ((pDetectChar False '\'' >>= withAttribute "String SingleQ") >>~ (popContext))-     return (attr, result)--parseRules "StringDQ" = -  do (attr, result) <- (((pDetectChar False '"' >>= withAttribute "String DoubleQ") >>~ (popContext))-                        <|>-                        ((pRegExpr regex_'5c'5c'5b'60'22'5c'5c'24'5cn'5d >>= withAttribute "String Escape"))-                        <|>-                        ((parseRules "FindSubstitutions")))-     return (attr, result)--parseRules "StringEsc" = -  do (attr, result) <- (((pDetectChar False '\'' >>= withAttribute "String SingleQ") >>~ (popContext))-                        <|>-                        ((pRegExpr regex_'5c'5c'5babefnrtv'5c'5c'27'5d >>= withAttribute "String Escape"))-                        <|>-                        ((pRegExpr regex_'5c'5c'28'5b0'2d7'5d'7b1'2c3'7d'7cx'5bA'2dFa'2df0'2d9'5d'7b1'2c2'7d'7cc'2e'29 >>= withAttribute "String Escape")))-     return (attr, result)--parseRules "VarBrace" = -  do (attr, result) <- (((pDetectChar False '}' >>= withAttribute "Variable") >>~ (popContext))-                        <|>-                        ((pDetectChar False '[' >>= withAttribute "Variable") >>~ pushContext "Subscript")-                        <|>-                        ((pRegExpr regex_'28'3a'3f'5b'2d'3d'3f'2b'5d'7c'23'23'3f'7c'25'25'3f'29 >>= withAttribute "Variable") >>~ pushContext "VarAlt")-                        <|>-                        ((pRegExpr regex_'2f'2f'3f >>= withAttribute "Variable") >>~ pushContext "VarSubst")-                        <|>-                        ((pDetectChar False ':' >>= withAttribute "Variable") >>~ pushContext "VarSub"))-     return (attr, result)--parseRules "VarAlt" = -  do (attr, result) <- (((pDetectChar False '}' >>= withAttribute "Variable") >>~ (popContext >> popContext))-                        <|>-                        ((parseRules "FindStrings"))-                        <|>-                        ((parseRules "FindSubstitutions")))-     return (attr, result)--parseRules "VarSubst" = -  do (attr, result) <- (((pDetectChar False '}' >>= withAttribute "Variable") >>~ (popContext >> popContext))-                        <|>-                        ((pDetectChar False '/' >>= withAttribute "Variable") >>~ pushContext "VarSubst2")-                        <|>-                        ((parseRules "FindStrings"))-                        <|>-                        ((parseRules "FindSubstitutions")))-     return (attr, result)--parseRules "VarSubst2" = -  do (attr, result) <- (((pDetectChar False '}' >>= withAttribute "Variable") >>~ (popContext >> popContext >> popContext))-                        <|>-                        ((parseRules "FindStrings"))-                        <|>-                        ((parseRules "FindSubstitutions")))-     return (attr, result)--parseRules "VarSub" = -  do (attr, result) <- (((pDetectChar False ':' >>= withAttribute "Variable") >>~ pushContext "VarSub2")-                        <|>-                        ((pDetectChar False '}' >>= withAttribute "Variable") >>~ (popContext >> popContext))-                        <|>-                        ((pRegExpr regex_'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a >>= withAttribute "Variable"))-                        <|>-                        ((pRegExpr regex_'5b0'2d9'5d'2b'28'3f'3d'5b'3a'7d'5d'29 >>= withAttribute "Variable"))-                        <|>-                        ((parseRules "FindSubstitutions")))-     return (attr, result)--parseRules "VarSub2" = -  do (attr, result) <- (((pDetectChar False '}' >>= withAttribute "Variable") >>~ (popContext >> popContext >> popContext))-                        <|>-                        ((pRegExpr regex_'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a >>= withAttribute "Variable"))-                        <|>-                        ((pRegExpr regex_'5b0'2d9'5d'28'3f'3d'5b'3a'7d'5d'29 >>= withAttribute "Variable"))-                        <|>-                        ((parseRules "FindSubstitutions")))-     return (attr, result)--parseRules "SubstFile" = -  do (attr, result) <- (((pDetectChar False ')' >>= withAttribute "Redirection") >>~ (popContext))-                        <|>-                        ((parseRules "FindCommentsParen"))-                        <|>-                        ((parseRules "FindStrings"))-                        <|>-                        ((parseRules "FindSubstitutions"))-                        <|>-                        ((parseRules "FindOthers")))-     return (attr, result)--parseRules "SubstCommand" = -  do (attr, result) <- (((pDetectChar False ')' >>= withAttribute "Variable") >>~ (popContext))-                        <|>-                        ((parseRules "FindCommentsParen"))-                        <|>-                        ((parseRules "FindCommands"))-                        <|>-                        ((parseRules "FindStrings"))-                        <|>-                        ((parseRules "FindSubstitutions"))-                        <|>-                        ((parseRules "FindOthers")))-     return (attr, result)--parseRules "SubstBackq" = -  do (attr, result) <- (((pDetectChar False '`' >>= withAttribute "Backquote") >>~ (popContext))-                        <|>-                        ((parseRules "FindCommentsBackq"))-                        <|>-                        ((parseRules "FindCommands"))-                        <|>-                        ((parseRules "FindStrings"))-                        <|>-                        ((parseRules "FindSubstitutions"))-                        <|>-                        ((parseRules "FindOthers")))-     return (attr, result)--parseRules "Case" = -  do (attr, result) <- (((pRegExpr regex_'5csin'5cb >>= withAttribute "Keyword") >>~ pushContext "CaseIn")-                        <|>-                        ((parseRules "FindMost")))-     return (attr, result)--parseRules "CaseIn" = -  do (attr, result) <- (((pRegExpr regex_'5cbesac'28'3f'3d'24'7c'5b'5cs'3b'29'5d'29 >>= withAttribute "Keyword") >>~ (popContext >> popContext))-                        <|>-                        ((pDetectChar False ')' >>= withAttribute "Keyword") >>~ pushContext "CaseExpr")-                        <|>-                        ((pAnyChar "(|" >>= withAttribute "Keyword"))-                        <|>-                        ((parseRules "FindMost")))-     return (attr, result)--parseRules "CaseExpr" = -  do (attr, result) <- (((pDetect2Chars False ';' ';' >>= withAttribute "Keyword") >>~ (popContext))-                        <|>-                        ((pFirstNonSpace >> lookAhead (pRegExpr regex_esac'28'3f'3d'24'7c'5b'5cs'3b'29'5d'29) >> return ([],"") ) >>~ (popContext))-                        <|>-                        ((parseRules "FindAll")))-     return (attr, result)--parseRules "HereDoc" = -  do (attr, result) <- (((lookAhead (pRegExpr regex_'28'3c'3c'2d'5cs'2a'22'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'22'29) >> return ([],"") ) >>~ pushContext "HereDocIQ")-                        <|>-                        ((lookAhead (pRegExpr regex_'28'3c'3c'2d'5cs'2a'27'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'27'29) >> return ([],"") ) >>~ pushContext "HereDocIQ")-                        <|>-                        ((lookAhead (pRegExpr regex_'28'3c'3c'2d'5cs'2a'5c'5c'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'29) >> return ([],"") ) >>~ pushContext "HereDocIQ")-                        <|>-                        ((lookAhead (pRegExpr regex_'28'3c'3c'2d'5cs'2a'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'29) >> return ([],"") ) >>~ pushContext "HereDocINQ")-                        <|>-                        ((lookAhead (pRegExpr regex_'28'3c'3c'5cs'2a'22'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'22'29) >> return ([],"") ) >>~ pushContext "HereDocQ")-                        <|>-                        ((lookAhead (pRegExpr regex_'28'3c'3c'5cs'2a'27'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'27'29) >> return ([],"") ) >>~ pushContext "HereDocQ")-                        <|>-                        ((lookAhead (pRegExpr regex_'28'3c'3c'5cs'2a'5c'5c'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'29) >> return ([],"") ) >>~ pushContext "HereDocQ")-                        <|>-                        ((lookAhead (pRegExpr regex_'28'3c'3c'5cs'2a'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'29) >> return ([],"") ) >>~ pushContext "HereDocNQ")-                        <|>-                        ((pString False "<<" >>= withAttribute "Redirection") >>~ (popContext)))-     return (attr, result)--parseRules "HereDocRemainder" = -  do (attr, result) <- ((parseRules "FindAll"))-     return (attr, result)--parseRules "HereDocQ" = -  do (attr, result) <- (((pRegExprDynamic "%1" >>= withAttribute "Redirection") >>~ pushContext "HereDocRemainder")-                        <|>-                        ((pColumn 0 >> pRegExprDynamic "%2\\b" >>= withAttribute "Redirection") >>~ (popContext >> popContext)))-     return (attr, result)--parseRules "HereDocNQ" = -  do (attr, result) <- (((pRegExprDynamic "%1" >>= withAttribute "Redirection") >>~ pushContext "HereDocRemainder")-                        <|>-                        ((pColumn 0 >> pRegExprDynamic "%2\\b" >>= withAttribute "Redirection") >>~ (popContext >> popContext))-                        <|>-                        ((parseRules "FindSubstitutions")))-     return (attr, result)--parseRules "HereDocIQ" = -  do (attr, result) <- (((pRegExprDynamic "%1" >>= withAttribute "Redirection") >>~ pushContext "HereDocRemainder")-                        <|>-                        ((pColumn 0 >> pRegExprDynamic "\\t*%2\\b" >>= withAttribute "Redirection") >>~ (popContext >> popContext)))-     return (attr, result)--parseRules "HereDocINQ" = -  do (attr, result) <- (((pRegExprDynamic "%1" >>= withAttribute "Redirection") >>~ pushContext "HereDocRemainder")-                        <|>-                        ((pColumn 0 >> pRegExprDynamic "\\t*%2\\b" >>= withAttribute "Redirection") >>~ (popContext >> popContext))-                        <|>-                        ((parseRules "FindSubstitutions")))-     return (attr, result)+{- This module was generated from data in the Kate syntax+   highlighting file bash.xml, version 2.12, by Wilbert Berendsen (wilbert@kde.nl) -}++module Text.Highlighting.Kate.Syntax.Bash+          (highlight, parseExpression, syntaxName, syntaxExtensions)+where+import Text.Highlighting.Kate.Types+import Text.Highlighting.Kate.Common+import qualified Text.Highlighting.Kate.Syntax.Alert+import Text.ParserCombinators.Parsec hiding (State)+import Data.Map (fromList)+import Control.Monad.State+import Data.Char (isSpace)+import Data.Maybe (fromMaybe)+import qualified Data.Set as Set++-- | Full name of language.+syntaxName :: String+syntaxName = "Bash"++-- | Filename extensions for this language.+syntaxExtensions :: String+syntaxExtensions = "*.sh;*.bash;*.ebuild;*.eclass;.bashrc;.bash_profile;.bash_login;.profile"++-- | Highlight source code using this syntax definition.+highlight :: String -> [SourceLine]+highlight input = evalState (mapM parseSourceLine $ lines input) startingState++parseSourceLine :: String -> State SyntaxState SourceLine+parseSourceLine = mkParseSourceLine parseExpressionInternal pEndLine++-- | Parse an expression using appropriate local context.+parseExpression :: KateParser Token+parseExpression = do+  st <- getState+  let oldLang = synStLanguage st+  setState $ st { synStLanguage = "Bash" }+  context <- currentContext <|> (pushContext "Start" >> currentContext)+  result <- parseRules context+  optional $ eof >> pEndLine+  updateState $ \st -> st { synStLanguage = oldLang }+  return result++startingState = SyntaxState {synStContexts = fromList [("Bash",["Start"])], synStLanguage = "Bash", synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}++pEndLine = do+  context <- currentContext+  case context of+    "Start" -> return ()+    "FindAll" -> return ()+    "FindMost" -> return ()+    "FindComments" -> (popContext) >> pEndLine+    "Comment" -> (popContext) >> pEndLine+    "FindCommentsParen" -> (popContext) >> pEndLine+    "CommentParen" -> (popContext) >> pEndLine+    "FindCommentsBackq" -> (popContext) >> pEndLine+    "CommentBackq" -> (popContext) >> pEndLine+    "FindCommands" -> return ()+    "FindOthers" -> return ()+    "FindStrings" -> return ()+    "FindSubstitutions" -> return ()+    "FindTests" -> return ()+    "ExprDblParen" -> return ()+    "ExprDblParenSubst" -> return ()+    "ExprSubParen" -> return ()+    "ExprBracket" -> return ()+    "ExprDblBracket" -> return ()+    "Group" -> return ()+    "SubShell" -> return ()+    "Assign" -> (popContext) >> pEndLine+    "AssignArray" -> (popContext) >> pEndLine+    "AssignSubscr" -> (popContext) >> pEndLine+    "Subscript" -> return ()+    "FunctionDef" -> (popContext) >> pEndLine+    "VarName" -> (popContext) >> pEndLine+    "ProcessSubst" -> return ()+    "StringSQ" -> return ()+    "StringDQ" -> return ()+    "StringEsc" -> return ()+    "VarBrace" -> return ()+    "VarAlt" -> return ()+    "VarSubst" -> return ()+    "VarSubst2" -> return ()+    "VarSub" -> return ()+    "VarSub2" -> return ()+    "SubstFile" -> return ()+    "SubstCommand" -> return ()+    "SubstBackq" -> return ()+    "Case" -> return ()+    "CaseIn" -> return ()+    "CaseExpr" -> return ()+    "HereDoc" -> return ()+    "HereDocRemainder" -> (popContext) >> pEndLine+    "HereDocQ" -> return ()+    "HereDocNQ" -> return ()+    "HereDocIQ" -> return ()+    "HereDocINQ" -> return ()+    _ -> return ()++withAttribute attr txt = do+  when (null txt) $ fail "Parser matched no text"+  updateState $ \st -> st { synStPrevChar = last txt+                          , synStPrevNonspace = synStPrevNonspace st || not (all isSpace txt) }+  return (attr, txt)++parseExpressionInternal = do+  context <- currentContext+  parseRules context <|> (pDefault >>= withAttribute (fromMaybe NormalTok $ lookup context defaultAttributes))++list_keywords = Set.fromList $ words $ "else for function in select until while elif then set"+list_builtins = Set.fromList $ words $ ": source alias bg bind break builtin cd caller 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 suspend test time times trap type ulimit umask unalias wait"+list_builtins'5fvar = Set.fromList $ words $ "export unset declare typeset local read readonly"+list_unixcommands = Set.fromList $ words $ "arch awk bash bunzip2 bzcat bzcmp bzdiff bzegrep bzfgrep bzgrep bzip2 bzip2recover bzless bzmore cat chattr chgrp chmod chown chvt cp date dd deallocvt df dir dircolors dmesg dnsdomainname domainname du dumpkeys echo ed egrep false fgconsole fgrep fuser gawk getkeycodes gocr grep groff groups gunzip gzexe gzip hostname igawk install kbd_mode kbdrate killall last lastb link ln loadkeys loadunimap login ls lsattr lsmod lsmod.old lzcat lzcmp lzdiff lzegrep lzfgrep lzgrep lzless lzcat lzma lzmainfo lzmore mapscrn mesg mkdir mkfifo mknod mktemp more mount mv nano netstat nisdomainname nroff openvt pgawk pidof ping ps pstree pwd rbash readlink red resizecons rm rmdir run-parts sash sed setfont setkeycodes setleds setmetamode setserial sh showkey shred sleep ssed stat stty su sync tar tempfile touch troff true umount uname unicode_start unicode_stop unlink unlzma unxz utmpdump uuidgen vdir wall wc xz xzcat ypdomainname zcat zcmp zdiff zegrep zfgrep zforce zgrep zless zmore znew zsh aclocal aconnect aplay apm apmsleep apropos ar arecord as as86 autoconf autoheader automake awk basename bc bison c++ cal cat cc cdda2wav cdparanoia cdrdao cd-read cdrecord chfn chgrp chmod chown chroot chsh clear cmp co col comm cp cpio cpp cut dc dd df diff diff3 dir dircolors directomatic dirname du env expr fbset file find flex flex++ fmt free ftp funzip fuser g++ gawk gc gcc gdb getent getopt gettext gettextize gimp gimp-remote gimptool gmake gs head hexdump id install join kill killall ld ld86 ldd less lex ln locate lockfile logname lp lpr ls lynx m4 make man mkdir mknod msgfmt mv namei nasm nawk nice nl nm nm86 nmap nohup nop od passwd patch pcregrep pcretest perl perror pidof pr printf procmail prune ps2ascii ps2epsi ps2frag ps2pdf ps2ps psbook psmerge psnup psresize psselect pstops rcs rev rm scp sed seq setterm shred size size86 skill slogin snice sort sox split ssh ssh-add ssh-agent ssh-keygen ssh-keyscan stat strings strip sudo suidperl sum tac tail tee test tr uniq unlink unzip updatedb updmap uptime users vmstat w wc wget whatis whereis which who whoami write xargs yacc yes zip zsoelim dcop kdialog kfile xhost xmodmap xset"++regex_'5b'5cs'3b'5d'28'3f'3d'23'29 = compileRegex "[\\s;](?=#)"+regex_'5b'5e'29'5d'28'3f'3d'5c'29'29 = compileRegex "[^)](?=\\))"+regex_'5b'5e'60'5d'28'3f'3d'60'29 = compileRegex "[^`](?=`)"+regex_'5c'5b'5c'5b'28'3f'3d'28'24'7c'5cs'29'29 = compileRegex "\\[\\[(?=($|\\s))"+regex_'5cs'5c'5b'5c'5b'28'3f'3d'28'24'7c'5cs'29'29 = compileRegex "\\s\\[\\[(?=($|\\s))"+regex_'5c'5b'28'3f'3d'28'24'7c'5cs'29'29 = compileRegex "\\[(?=($|\\s))"+regex_'5cs'5c'5b'28'3f'3d'28'24'7c'5cs'29'29 = compileRegex "\\s\\[(?=($|\\s))"+regex_'5c'7b'28'3f'3d'28'24'7c'5cs'29'29 = compileRegex "\\{(?=($|\\s))"+regex_'5cbdo'28'3f'21'5b'5cw'24'2b'2d'5d'29 = compileRegex "\\bdo(?![\\w$+-])"+regex_'5cbdone'28'3f'21'5b'5cw'24'2b'2d'5d'29 = compileRegex "\\bdone(?![\\w$+-])"+regex_'5cbif_'28'3f'21'5b'5cw'24'2b'2d'5d'29 = compileRegex "\\bif (?![\\w$+-])"+regex_'5cbfi'28'3f'21'5b'5cw'24'2b'2d'5d'29 = compileRegex "\\bfi(?![\\w$+-])"+regex_'5cbcase'28'3f'21'5b'5cw'24'2b'2d'5d'29 = compileRegex "\\bcase(?![\\w$+-])"+regex_'2d'5bA'2dZa'2dz0'2d9'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a = compileRegex "-[A-Za-z0-9][A-Za-z0-9_]*"+regex_'2d'2d'5ba'2dz'5d'5bA'2dZa'2dz0'2d9'5f'2d'5d'2a = compileRegex "--[a-z][A-Za-z0-9_-]*"+regex_'5cb'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'5c'2b'3f'3d = compileRegex "\\b[A-Za-z_][A-Za-z0-9_]*\\+?="+regex_'5cb'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'28'3f'3d'5c'5b'2e'2b'5c'5d'5c'2b'3f'3d'29 = compileRegex "\\b[A-Za-z_][A-Za-z0-9_]*(?=\\[.+\\]\\+?=)"+regex_'5cbfunction'5cb = compileRegex "\\bfunction\\b"+regex_'5c'2e'28'3f'3d'5cs'29 = compileRegex "\\.(?=\\s)"+regex_'5cd'2a'3c'3c'3c = compileRegex "\\d*<<<"+regex_'5b'3c'3e'5d'5c'28 = compileRegex "[<>]\\("+regex_'28'5b0'2d9'5d'2a'28'3e'7b1'2c2'7d'7c'3c'29'28'26'5b0'2d9'5d'2b'2d'3f'29'3f'7c'26'3e'7c'3e'26'7c'5b0'2d9'5d'2a'3c'3e'29 = compileRegex "([0-9]*(>{1,2}|<)(&[0-9]+-?)?|&>|>&|[0-9]*<>)"+regex_'28'5b'7c'26'5d'29'5c1'3f = compileRegex "([|&])\\1?"+regex_'5bA'2dZa'2dz'5f'3a'5d'5bA'2dZa'2dz0'2d9'5f'3a'23'25'40'2d'5d'2a'5cs'2a'5c'28'5c'29 = compileRegex "[A-Za-z_:][A-Za-z0-9_:#%@-]*\\s*\\(\\)"+regex_'5c'5c'5b'5d'5b'3b'5c'5c'24'60'7b'7d'28'29'7c'26'3c'3e'2a_'5d = compileRegex "\\\\[][;\\\\$`{}()|&<>* ]"+regex_'5c'5c'24 = compileRegex "\\\\$"+regex_'5c'7b'28'3f'21'28'5cs'7c'24'29'29'5cS'2a'5c'7d = compileRegex "\\{(?!(\\s|$))\\S*\\}"+regex_'28'5b'5cw'5f'40'2e'25'2a'3f'2b'2d'5d'7c'5c'5c_'29'2a'28'3f'3d'2f'29 = compileRegex "([\\w_@.%*?+-]|\\\\ )*(?=/)"+regex_'7e'5cw'2a = compileRegex "~\\w*"+regex_'2f'28'5b'5cw'5f'40'2e'25'2a'3f'2b'2d'5d'7c'5c'5c_'29'2a'28'3f'3d'28'5b'5cs'2f'29'3a'3b'24'60'27'22'5d'7c'24'29'29 = compileRegex "/([\\w_@.%*?+-]|\\\\ )*(?=([\\s/):;$`'\"]|$))"+regex_'5c'24'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'5c'5b = compileRegex "\\$[A-Za-z_][A-Za-z0-9_]*\\["+regex_'5c'24'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a = compileRegex "\\$[A-Za-z_][A-Za-z0-9_]*"+regex_'5c'24'5b'2a'40'23'3f'24'21'5f0'2d9'2d'5d = compileRegex "\\$[*@#?$!_0-9-]"+regex_'5c'24'5c'7b'5b'2a'40'23'3f'24'21'5f0'2d9'2d'5d'5c'7d = compileRegex "\\$\\{[*@#?$!_0-9-]\\}"+regex_'5c'24'5c'7b'23'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'28'5c'5b'5b'2a'40'5d'5c'5d'29'3f'5c'7d = compileRegex "\\$\\{#[A-Za-z_][A-Za-z0-9_]*(\\[[*@]\\])?\\}"+regex_'5c'24'5c'7b'21'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'28'5c'5b'5b'2a'40'5d'5c'5d'7c'5b'2a'40'5d'29'3f'5c'7d = compileRegex "\\$\\{![A-Za-z_][A-Za-z0-9_]*(\\[[*@]\\]|[*@])?\\}"+regex_'5c'24'5c'7b'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a = compileRegex "\\$\\{[A-Za-z_][A-Za-z0-9_]*"+regex_'5c'24'5c'7b'5b'2a'40'23'3f'24'21'5f0'2d9'2d'5d'28'3f'3d'5b'3a'23'25'2f'3d'3f'2b'2d'5d'29 = compileRegex "\\$\\{[*@#?$!_0-9-](?=[:#%/=?+-])"+regex_'5c'5c'5b'60'24'5c'5c'5d = compileRegex "\\\\[`$\\\\]"+regex_'2d'5babcdefghkprstuwxOGLSNozn'5d'28'3f'3d'5cs'29 = compileRegex "-[abcdefghkprstuwxOGLSNozn](?=\\s)"+regex_'2d'28'5bno'5dt'7cef'29'28'3f'3d'5cs'29 = compileRegex "-([no]t|ef)(?=\\s)"+regex_'28'5b'21'3d'5d'3d'3f'7c'5b'3e'3c'5d'29'28'3f'3d'5cs'29 = compileRegex "([!=]=?|[><])(?=\\s)"+regex_'2d'28eq'7cne'7c'5bgl'5d'5bte'5d'29'28'3f'3d'5cs'29 = compileRegex "-(eq|ne|[gl][te])(?=\\s)"+regex_'5cs'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 = compileRegex "\\s\\](?=($|[\\s;|&]))"+regex_'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 = compileRegex "\\](?=($|[\\s;|&]))"+regex_'5cs'5c'5d'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 = compileRegex "\\s\\]\\](?=($|[\\s;|&]))"+regex_'5c'5d'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 = compileRegex "\\]\\](?=($|[\\s;|&]))"+regex_'5b'5cw'3a'2c'2b'5f'2e'2f'2d'5d = compileRegex "[\\w:,+_./-]"+regex_'5cs'2b'5bA'2dZa'2dz'5f'3a'5d'5bA'2dZa'2dz0'2d9'5f'3a'23'25'40'2d'5d'2a'28'5cs'2a'5c'28'5c'29'29'3f = compileRegex "\\s+[A-Za-z_:][A-Za-z0-9_:#%@-]*(\\s*\\(\\))?"+regex_'2d'5bA'2dZa'2dz0'2d9'5d'2b = compileRegex "-[A-Za-z0-9]+"+regex_'5cb'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a = compileRegex "\\b[A-Za-z_][A-Za-z0-9_]*"+regex_'5b'5e'5d'7d'29'7c'3b'60'26'3e'3c'5d = compileRegex "[^]})|;`&><]"+regex_'5c'5c'5b'60'22'5c'5c'24'5cn'5d = compileRegex "\\\\[`\"\\\\$\\n]"+regex_'5c'5c'5babefnrtv'5c'5c'27'5d = compileRegex "\\\\[abefnrtv\\\\']"+regex_'5c'5c'28'5b0'2d7'5d'7b1'2c3'7d'7cx'5bA'2dFa'2df0'2d9'5d'7b1'2c2'7d'7cc'2e'29 = compileRegex "\\\\([0-7]{1,3}|x[A-Fa-f0-9]{1,2}|c.)"+regex_'28'3a'3f'5b'2d'3d'3f'2b'5d'7c'23'23'3f'7c'25'25'3f'29 = compileRegex "(:?[-=?+]|##?|%%?)"+regex_'2f'2f'3f = compileRegex "//?"+regex_'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a = compileRegex "[A-Za-z_][A-Za-z0-9_]*"+regex_'5b0'2d9'5d'2b'28'3f'3d'5b'3a'7d'5d'29 = compileRegex "[0-9]+(?=[:}])"+regex_'5b0'2d9'5d'28'3f'3d'5b'3a'7d'5d'29 = compileRegex "[0-9](?=[:}])"+regex_'5csin'5cb = compileRegex "\\sin\\b"+regex_'5cbesac'28'3f'3d'24'7c'5b'5cs'3b'29'5d'29 = compileRegex "\\besac(?=$|[\\s;)])"+regex_esac'28'3f'3d'24'7c'5b'5cs'3b'29'5d'29 = compileRegex "esac(?=$|[\\s;)])"+regex_'28'3c'3c'2d'5cs'2a'22'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'22'29 = compileRegex "(<<-\\s*\"([^|&;()<>\\s]+)\")"+regex_'28'3c'3c'2d'5cs'2a'27'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'27'29 = compileRegex "(<<-\\s*'([^|&;()<>\\s]+)')"+regex_'28'3c'3c'2d'5cs'2a'5c'5c'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'29 = compileRegex "(<<-\\s*\\\\([^|&;()<>\\s]+))"+regex_'28'3c'3c'2d'5cs'2a'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'29 = compileRegex "(<<-\\s*([^|&;()<>\\s]+))"+regex_'28'3c'3c'5cs'2a'22'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'22'29 = compileRegex "(<<\\s*\"([^|&;()<>\\s]+)\")"+regex_'28'3c'3c'5cs'2a'27'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'27'29 = compileRegex "(<<\\s*'([^|&;()<>\\s]+)')"+regex_'28'3c'3c'5cs'2a'5c'5c'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'29 = compileRegex "(<<\\s*\\\\([^|&;()<>\\s]+))"+regex_'28'3c'3c'5cs'2a'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'29 = compileRegex "(<<\\s*([^|&;()<>\\s]+))"++defaultAttributes = [("Start",NormalTok),("FindAll",NormalTok),("FindMost",NormalTok),("FindComments",NormalTok),("Comment",CommentTok),("FindCommentsParen",NormalTok),("CommentParen",CommentTok),("FindCommentsBackq",NormalTok),("CommentBackq",CommentTok),("FindCommands",NormalTok),("FindOthers",NormalTok),("FindStrings",NormalTok),("FindSubstitutions",NormalTok),("FindTests",NormalTok),("ExprDblParen",NormalTok),("ExprDblParenSubst",NormalTok),("ExprSubParen",NormalTok),("ExprBracket",NormalTok),("ExprDblBracket",NormalTok),("Group",NormalTok),("SubShell",NormalTok),("Assign",NormalTok),("AssignArray",NormalTok),("AssignSubscr",NormalTok),("Subscript",OtherTok),("FunctionDef",FunctionTok),("VarName",NormalTok),("ProcessSubst",NormalTok),("StringSQ",StringTok),("StringDQ",StringTok),("StringEsc",StringTok),("VarBrace",ErrorTok),("VarAlt",NormalTok),("VarSubst",NormalTok),("VarSubst2",NormalTok),("VarSub",ErrorTok),("VarSub2",ErrorTok),("SubstFile",NormalTok),("SubstCommand",NormalTok),("SubstBackq",NormalTok),("Case",NormalTok),("CaseIn",NormalTok),("CaseExpr",NormalTok),("HereDoc",NormalTok),("HereDocRemainder",NormalTok),("HereDocQ",NormalTok),("HereDocNQ",NormalTok),("HereDocIQ",NormalTok),("HereDocINQ",NormalTok)]++parseRules "Start" =+  ((parseRules "FindAll"))++parseRules "FindAll" =+  (((parseRules "FindComments"))+   <|>+   ((parseRules "FindCommands"))+   <|>+   ((parseRules "FindStrings"))+   <|>+   ((parseRules "FindSubstitutions"))+   <|>+   ((parseRules "FindOthers")))++parseRules "FindMost" =+  (((parseRules "FindComments"))+   <|>+   ((parseRules "FindStrings"))+   <|>+   ((parseRules "FindSubstitutions"))+   <|>+   ((parseRules "FindOthers")))++parseRules "FindComments" =+  (((pFirstNonSpace >> pDetectChar False '#' >>= withAttribute CommentTok) >>~ pushContext "Comment")+   <|>+   ((pRegExpr regex_'5b'5cs'3b'5d'28'3f'3d'23'29 >>= withAttribute NormalTok) >>~ pushContext "Comment"))++parseRules "Comment" =+  ((Text.Highlighting.Kate.Syntax.Alert.parseExpression >>= ((withAttribute CommentTok) . snd)))++parseRules "FindCommentsParen" =+  (((pFirstNonSpace >> pDetectChar False '#' >>= withAttribute CommentTok) >>~ pushContext "CommentParen")+   <|>+   ((pRegExpr regex_'5b'5cs'3b'5d'28'3f'3d'23'29 >>= withAttribute NormalTok) >>~ pushContext "CommentParen"))++parseRules "CommentParen" =+  (((pRegExpr regex_'5b'5e'29'5d'28'3f'3d'5c'29'29 >>= withAttribute CommentTok) >>~ (popContext))+   <|>+   ((Text.Highlighting.Kate.Syntax.Alert.parseExpression >>= ((withAttribute CommentTok) . snd))))++parseRules "FindCommentsBackq" =+  (((pFirstNonSpace >> pDetectChar False '#' >>= withAttribute CommentTok) >>~ pushContext "CommentBackq")+   <|>+   ((pRegExpr regex_'5b'5cs'3b'5d'28'3f'3d'23'29 >>= withAttribute NormalTok) >>~ pushContext "CommentBackq"))++parseRules "CommentBackq" =+  (((pRegExpr regex_'5b'5e'60'5d'28'3f'3d'60'29 >>= withAttribute CommentTok) >>~ (popContext))+   <|>+   ((Text.Highlighting.Kate.Syntax.Alert.parseExpression >>= ((withAttribute CommentTok) . snd))))++parseRules "FindCommands" =+  (((pDetect2Chars False '(' '(' >>= withAttribute KeywordTok) >>~ pushContext "ExprDblParen")+   <|>+   ((pColumn 0 >> pRegExpr regex_'5c'5b'5c'5b'28'3f'3d'28'24'7c'5cs'29'29 >>= withAttribute KeywordTok) >>~ pushContext "ExprDblBracket")+   <|>+   ((pRegExpr regex_'5cs'5c'5b'5c'5b'28'3f'3d'28'24'7c'5cs'29'29 >>= withAttribute KeywordTok) >>~ pushContext "ExprDblBracket")+   <|>+   ((pColumn 0 >> pRegExpr regex_'5c'5b'28'3f'3d'28'24'7c'5cs'29'29 >>= withAttribute KeywordTok) >>~ pushContext "ExprBracket")+   <|>+   ((pRegExpr regex_'5cs'5c'5b'28'3f'3d'28'24'7c'5cs'29'29 >>= withAttribute KeywordTok) >>~ pushContext "ExprBracket")+   <|>+   ((pRegExpr regex_'5c'7b'28'3f'3d'28'24'7c'5cs'29'29 >>= withAttribute KeywordTok) >>~ pushContext "Group")+   <|>+   ((pDetectChar False '(' >>= withAttribute KeywordTok) >>~ pushContext "SubShell")+   <|>+   ((pRegExpr regex_'5cbdo'28'3f'21'5b'5cw'24'2b'2d'5d'29 >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5cbdone'28'3f'21'5b'5cw'24'2b'2d'5d'29 >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5cbif_'28'3f'21'5b'5cw'24'2b'2d'5d'29 >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5cbfi'28'3f'21'5b'5cw'24'2b'2d'5d'29 >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5cbcase'28'3f'21'5b'5cw'24'2b'2d'5d'29 >>= withAttribute KeywordTok) >>~ pushContext "Case")+   <|>+   ((pRegExpr regex_'2d'5bA'2dZa'2dz0'2d9'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a >>= withAttribute NormalTok))+   <|>+   ((pRegExpr regex_'2d'2d'5ba'2dz'5d'5bA'2dZa'2dz0'2d9'5f'2d'5d'2a >>= withAttribute NormalTok))+   <|>+   ((pRegExpr regex_'5cb'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'5c'2b'3f'3d >>= withAttribute OtherTok) >>~ pushContext "Assign")+   <|>+   ((pRegExpr regex_'5cb'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'28'3f'3d'5c'5b'2e'2b'5c'5d'5c'2b'3f'3d'29 >>= withAttribute OtherTok) >>~ pushContext "AssignSubscr")+   <|>+   ((pString False ":()" >>= withAttribute FunctionTok))+   <|>+   ((pRegExpr regex_'5cbfunction'5cb >>= withAttribute KeywordTok) >>~ pushContext "FunctionDef")+   <|>+   ((pKeyword " \n\t()!+,<=>&*;?|~\\`" list_keywords >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5c'2e'28'3f'3d'5cs'29 >>= withAttribute KeywordTok))+   <|>+   ((pKeyword " \n\t()!+,<=>&*;?|~\\`" list_builtins >>= withAttribute KeywordTok))+   <|>+   ((pKeyword " \n\t()!+,<=>&*;?|~\\`" list_unixcommands >>= withAttribute KeywordTok))+   <|>+   ((pKeyword " \n\t()!+,<=>&*;?|~\\`" list_builtins'5fvar >>= withAttribute KeywordTok) >>~ pushContext "VarName")+   <|>+   ((pRegExpr regex_'5cd'2a'3c'3c'3c >>= withAttribute KeywordTok))+   <|>+   ((lookAhead (pString False "<<") >> return (NormalTok,"") ) >>~ pushContext "HereDoc")+   <|>+   ((pRegExpr regex_'5b'3c'3e'5d'5c'28 >>= withAttribute KeywordTok) >>~ pushContext "ProcessSubst")+   <|>+   ((pRegExpr regex_'28'5b0'2d9'5d'2a'28'3e'7b1'2c2'7d'7c'3c'29'28'26'5b0'2d9'5d'2b'2d'3f'29'3f'7c'26'3e'7c'3e'26'7c'5b0'2d9'5d'2a'3c'3e'29 >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'28'5b'7c'26'5d'29'5c1'3f >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5bA'2dZa'2dz'5f'3a'5d'5bA'2dZa'2dz0'2d9'5f'3a'23'25'40'2d'5d'2a'5cs'2a'5c'28'5c'29 >>= withAttribute FunctionTok)))++parseRules "FindOthers" =+  (((pRegExpr regex_'5c'5c'5b'5d'5b'3b'5c'5c'24'60'7b'7d'28'29'7c'26'3c'3e'2a_'5d >>= withAttribute DataTypeTok))+   <|>+   ((pRegExpr regex_'5c'5c'24 >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5c'7b'28'3f'21'28'5cs'7c'24'29'29'5cS'2a'5c'7d >>= withAttribute DataTypeTok))+   <|>+   ((pRegExpr regex_'28'5b'5cw'5f'40'2e'25'2a'3f'2b'2d'5d'7c'5c'5c_'29'2a'28'3f'3d'2f'29 >>= withAttribute NormalTok))+   <|>+   ((pRegExpr regex_'7e'5cw'2a >>= withAttribute NormalTok))+   <|>+   ((pRegExpr regex_'2f'28'5b'5cw'5f'40'2e'25'2a'3f'2b'2d'5d'7c'5c'5c_'29'2a'28'3f'3d'28'5b'5cs'2f'29'3a'3b'24'60'27'22'5d'7c'24'29'29 >>= withAttribute NormalTok)))++parseRules "FindStrings" =+  (((pDetect2Chars False '\\' '\'' >>= withAttribute DataTypeTok))+   <|>+   ((pDetect2Chars False '\\' '"' >>= withAttribute DataTypeTok))+   <|>+   ((pDetectChar False '\'' >>= withAttribute StringTok) >>~ pushContext "StringSQ")+   <|>+   ((pDetectChar False '"' >>= withAttribute StringTok) >>~ pushContext "StringDQ")+   <|>+   ((pDetect2Chars False '$' '\'' >>= withAttribute StringTok) >>~ pushContext "StringEsc")+   <|>+   ((pDetect2Chars False '$' '"' >>= withAttribute StringTok) >>~ pushContext "StringDQ"))++parseRules "FindSubstitutions" =+  (((pRegExpr regex_'5c'24'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'5c'5b >>= withAttribute OtherTok) >>~ pushContext "Subscript")+   <|>+   ((pRegExpr regex_'5c'24'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a >>= withAttribute OtherTok))+   <|>+   ((pRegExpr regex_'5c'24'5b'2a'40'23'3f'24'21'5f0'2d9'2d'5d >>= withAttribute OtherTok))+   <|>+   ((pRegExpr regex_'5c'24'5c'7b'5b'2a'40'23'3f'24'21'5f0'2d9'2d'5d'5c'7d >>= withAttribute OtherTok))+   <|>+   ((pRegExpr regex_'5c'24'5c'7b'23'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'28'5c'5b'5b'2a'40'5d'5c'5d'29'3f'5c'7d >>= withAttribute OtherTok))+   <|>+   ((pRegExpr regex_'5c'24'5c'7b'21'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'28'5c'5b'5b'2a'40'5d'5c'5d'7c'5b'2a'40'5d'29'3f'5c'7d >>= withAttribute OtherTok))+   <|>+   ((pRegExpr regex_'5c'24'5c'7b'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a >>= withAttribute OtherTok) >>~ pushContext "VarBrace")+   <|>+   ((pRegExpr regex_'5c'24'5c'7b'5b'2a'40'23'3f'24'21'5f0'2d9'2d'5d'28'3f'3d'5b'3a'23'25'2f'3d'3f'2b'2d'5d'29 >>= withAttribute OtherTok) >>~ pushContext "VarBrace")+   <|>+   ((pString False "$((" >>= withAttribute OtherTok) >>~ pushContext "ExprDblParenSubst")+   <|>+   ((pString False "$(<" >>= withAttribute KeywordTok) >>~ pushContext "SubstFile")+   <|>+   ((pString False "$(" >>= withAttribute OtherTok) >>~ pushContext "SubstCommand")+   <|>+   ((pDetectChar False '`' >>= withAttribute KeywordTok) >>~ pushContext "SubstBackq")+   <|>+   ((pRegExpr regex_'5c'5c'5b'60'24'5c'5c'5d >>= withAttribute DataTypeTok)))++parseRules "FindTests" =+  (((pRegExpr regex_'2d'5babcdefghkprstuwxOGLSNozn'5d'28'3f'3d'5cs'29 >>= withAttribute OtherTok))+   <|>+   ((pRegExpr regex_'2d'28'5bno'5dt'7cef'29'28'3f'3d'5cs'29 >>= withAttribute OtherTok))+   <|>+   ((pRegExpr regex_'28'5b'21'3d'5d'3d'3f'7c'5b'3e'3c'5d'29'28'3f'3d'5cs'29 >>= withAttribute OtherTok))+   <|>+   ((pRegExpr regex_'2d'28eq'7cne'7c'5bgl'5d'5bte'5d'29'28'3f'3d'5cs'29 >>= withAttribute OtherTok)))++parseRules "ExprDblParen" =+  (((pDetect2Chars False ')' ')' >>= withAttribute KeywordTok) >>~ (popContext))+   <|>+   ((pDetectChar False '(' >>= withAttribute NormalTok) >>~ pushContext "ExprSubParen")+   <|>+   ((parseRules "FindMost")))++parseRules "ExprDblParenSubst" =+  (((pDetect2Chars False ')' ')' >>= withAttribute OtherTok) >>~ (popContext))+   <|>+   ((pDetectChar False '(' >>= withAttribute NormalTok) >>~ pushContext "ExprSubParen")+   <|>+   ((parseRules "FindMost")))++parseRules "ExprSubParen" =+  (((pDetectChar False ')' >>= withAttribute NormalTok) >>~ (popContext))+   <|>+   ((pDetectChar False '(' >>= withAttribute NormalTok) >>~ pushContext "ExprSubParen")+   <|>+   ((parseRules "FindMost")))++parseRules "ExprBracket" =+  (((pRegExpr regex_'5cs'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 >>= withAttribute KeywordTok) >>~ (popContext))+   <|>+   ((pColumn 0 >> pRegExpr regex_'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 >>= withAttribute KeywordTok) >>~ (popContext))+   <|>+   ((pDetectChar False '(' >>= withAttribute NormalTok) >>~ pushContext "ExprSubParen")+   <|>+   ((parseRules "FindTests"))+   <|>+   ((parseRules "FindMost")))++parseRules "ExprDblBracket" =+  (((pRegExpr regex_'5cs'5c'5d'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 >>= withAttribute KeywordTok) >>~ (popContext))+   <|>+   ((pColumn 0 >> pRegExpr regex_'5c'5d'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 >>= withAttribute KeywordTok) >>~ (popContext))+   <|>+   ((pDetectChar False '(' >>= withAttribute NormalTok) >>~ pushContext "ExprSubParen")+   <|>+   ((parseRules "FindTests"))+   <|>+   ((parseRules "FindMost")))++parseRules "Group" =+  (((pDetectChar False '}' >>= withAttribute KeywordTok) >>~ (popContext))+   <|>+   ((parseRules "FindAll")))++parseRules "SubShell" =+  (((pDetectChar False ')' >>= withAttribute KeywordTok) >>~ (popContext))+   <|>+   ((parseRules "FindAll")))++parseRules "Assign" =+  (((pDetectChar False '(' >>= withAttribute OtherTok) >>~ pushContext "AssignArray")+   <|>+   ((parseRules "FindStrings"))+   <|>+   ((parseRules "FindSubstitutions"))+   <|>+   ((parseRules "FindOthers"))+   <|>+   ((pRegExpr regex_'5b'5cw'3a'2c'2b'5f'2e'2f'2d'5d >>= withAttribute NormalTok))+   <|>+   ((popContext) >> currentContext >>= parseRules))++parseRules "AssignArray" =+  (((pDetectChar False ')' >>= withAttribute OtherTok) >>~ (popContext))+   <|>+   ((pDetectChar False '[' >>= withAttribute OtherTok) >>~ pushContext "Subscript")+   <|>+   ((pDetectChar False '=' >>= withAttribute OtherTok) >>~ pushContext "Assign")+   <|>+   ((parseRules "FindMost")))++parseRules "AssignSubscr" =+  (((pDetectChar False '[' >>= withAttribute OtherTok) >>~ pushContext "Subscript")+   <|>+   ((pDetect2Chars False '+' '=' >>= withAttribute OtherTok) >>~ pushContext "Assign")+   <|>+   ((pDetectChar False '=' >>= withAttribute OtherTok) >>~ pushContext "Assign")+   <|>+   ((parseRules "FindStrings"))+   <|>+   ((parseRules "FindSubstitutions"))+   <|>+   ((parseRules "FindOthers"))+   <|>+   ((popContext) >> currentContext >>= parseRules))++parseRules "Subscript" =+  (((pDetectChar False ']' >>= withAttribute OtherTok) >>~ (popContext))+   <|>+   ((parseRules "FindStrings"))+   <|>+   ((parseRules "FindSubstitutions"))+   <|>+   ((parseRules "FindOthers")))++parseRules "FunctionDef" =+  (((pRegExpr regex_'5cs'2b'5bA'2dZa'2dz'5f'3a'5d'5bA'2dZa'2dz0'2d9'5f'3a'23'25'40'2d'5d'2a'28'5cs'2a'5c'28'5c'29'29'3f >>= withAttribute FunctionTok) >>~ (popContext))+   <|>+   ((popContext) >> currentContext >>= parseRules))++parseRules "VarName" =+  (((pRegExpr regex_'2d'5bA'2dZa'2dz0'2d9'5d'2b >>= withAttribute NormalTok))+   <|>+   ((pRegExpr regex_'2d'2d'5ba'2dz'5d'5bA'2dZa'2dz0'2d9'5f'2d'5d'2a >>= withAttribute NormalTok))+   <|>+   ((pRegExpr regex_'5cb'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a >>= withAttribute OtherTok))+   <|>+   ((pDetectChar False '[' >>= withAttribute OtherTok) >>~ pushContext "Subscript")+   <|>+   ((pDetectChar False '=' >>= withAttribute OtherTok) >>~ pushContext "Assign")+   <|>+   ((parseRules "FindMost"))+   <|>+   ((pRegExpr regex_'5b'5e'5d'7d'29'7c'3b'60'26'3e'3c'5d >>= withAttribute NormalTok))+   <|>+   ((popContext) >> currentContext >>= parseRules))++parseRules "ProcessSubst" =+  (((pDetectChar False ')' >>= withAttribute KeywordTok) >>~ (popContext))+   <|>+   ((parseRules "FindCommentsParen"))+   <|>+   ((parseRules "FindCommands"))+   <|>+   ((parseRules "FindStrings"))+   <|>+   ((parseRules "FindSubstitutions"))+   <|>+   ((parseRules "FindOthers")))++parseRules "StringSQ" =+  ((pDetectChar False '\'' >>= withAttribute StringTok) >>~ (popContext))++parseRules "StringDQ" =+  (((pDetectChar False '"' >>= withAttribute StringTok) >>~ (popContext))+   <|>+   ((pRegExpr regex_'5c'5c'5b'60'22'5c'5c'24'5cn'5d >>= withAttribute DataTypeTok))+   <|>+   ((parseRules "FindSubstitutions")))++parseRules "StringEsc" =+  (((pDetectChar False '\'' >>= withAttribute StringTok) >>~ (popContext))+   <|>+   ((pRegExpr regex_'5c'5c'5babefnrtv'5c'5c'27'5d >>= withAttribute DataTypeTok))+   <|>+   ((pRegExpr regex_'5c'5c'28'5b0'2d7'5d'7b1'2c3'7d'7cx'5bA'2dFa'2df0'2d9'5d'7b1'2c2'7d'7cc'2e'29 >>= withAttribute DataTypeTok)))++parseRules "VarBrace" =+  (((pDetectChar False '}' >>= withAttribute OtherTok) >>~ (popContext))+   <|>+   ((pDetectChar False '[' >>= withAttribute OtherTok) >>~ pushContext "Subscript")+   <|>+   ((pRegExpr regex_'28'3a'3f'5b'2d'3d'3f'2b'5d'7c'23'23'3f'7c'25'25'3f'29 >>= withAttribute OtherTok) >>~ pushContext "VarAlt")+   <|>+   ((pRegExpr regex_'2f'2f'3f >>= withAttribute OtherTok) >>~ pushContext "VarSubst")+   <|>+   ((pDetectChar False ':' >>= withAttribute OtherTok) >>~ pushContext "VarSub"))++parseRules "VarAlt" =+  (((pDetectChar False '}' >>= withAttribute OtherTok) >>~ (popContext >> popContext))+   <|>+   ((parseRules "FindStrings"))+   <|>+   ((parseRules "FindSubstitutions")))++parseRules "VarSubst" =+  (((pDetectChar False '}' >>= withAttribute OtherTok) >>~ (popContext >> popContext))+   <|>+   ((pDetectChar False '/' >>= withAttribute OtherTok) >>~ pushContext "VarSubst2")+   <|>+   ((parseRules "FindStrings"))+   <|>+   ((parseRules "FindSubstitutions")))++parseRules "VarSubst2" =+  (((pDetectChar False '}' >>= withAttribute OtherTok) >>~ (popContext >> popContext >> popContext))+   <|>+   ((parseRules "FindStrings"))+   <|>+   ((parseRules "FindSubstitutions")))++parseRules "VarSub" =+  (((pDetectChar False ':' >>= withAttribute OtherTok) >>~ pushContext "VarSub2")+   <|>+   ((pDetectChar False '}' >>= withAttribute OtherTok) >>~ (popContext >> popContext))+   <|>+   ((pRegExpr regex_'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a >>= withAttribute OtherTok))+   <|>+   ((pRegExpr regex_'5b0'2d9'5d'2b'28'3f'3d'5b'3a'7d'5d'29 >>= withAttribute OtherTok))+   <|>+   ((parseRules "FindSubstitutions")))++parseRules "VarSub2" =+  (((pDetectChar False '}' >>= withAttribute OtherTok) >>~ (popContext >> popContext >> popContext))+   <|>+   ((pRegExpr regex_'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a >>= withAttribute OtherTok))+   <|>+   ((pRegExpr regex_'5b0'2d9'5d'28'3f'3d'5b'3a'7d'5d'29 >>= withAttribute OtherTok))+   <|>+   ((parseRules "FindSubstitutions")))++parseRules "SubstFile" =+  (((pDetectChar False ')' >>= withAttribute KeywordTok) >>~ (popContext))+   <|>+   ((parseRules "FindCommentsParen"))+   <|>+   ((parseRules "FindStrings"))+   <|>+   ((parseRules "FindSubstitutions"))+   <|>+   ((parseRules "FindOthers")))++parseRules "SubstCommand" =+  (((pDetectChar False ')' >>= withAttribute OtherTok) >>~ (popContext))+   <|>+   ((parseRules "FindCommentsParen"))+   <|>+   ((parseRules "FindCommands"))+   <|>+   ((parseRules "FindStrings"))+   <|>+   ((parseRules "FindSubstitutions"))+   <|>+   ((parseRules "FindOthers")))++parseRules "SubstBackq" =+  (((pDetectChar False '`' >>= withAttribute KeywordTok) >>~ (popContext))+   <|>+   ((parseRules "FindCommentsBackq"))+   <|>+   ((parseRules "FindCommands"))+   <|>+   ((parseRules "FindStrings"))+   <|>+   ((parseRules "FindSubstitutions"))+   <|>+   ((parseRules "FindOthers")))++parseRules "Case" =+  (((pRegExpr regex_'5csin'5cb >>= withAttribute KeywordTok) >>~ pushContext "CaseIn")+   <|>+   ((parseRules "FindMost")))++parseRules "CaseIn" =+  (((pRegExpr regex_'5cbesac'28'3f'3d'24'7c'5b'5cs'3b'29'5d'29 >>= withAttribute KeywordTok) >>~ (popContext >> popContext))+   <|>+   ((pDetectChar False ')' >>= withAttribute KeywordTok) >>~ pushContext "CaseExpr")+   <|>+   ((pAnyChar "(|" >>= withAttribute KeywordTok))+   <|>+   ((parseRules "FindMost")))++parseRules "CaseExpr" =+  (((pDetect2Chars False ';' ';' >>= withAttribute KeywordTok) >>~ (popContext))+   <|>+   ((pFirstNonSpace >> lookAhead (pRegExpr regex_esac'28'3f'3d'24'7c'5b'5cs'3b'29'5d'29) >> return (NormalTok,"") ) >>~ (popContext))+   <|>+   ((parseRules "FindAll")))++parseRules "HereDoc" =+  (((lookAhead (pRegExpr regex_'28'3c'3c'2d'5cs'2a'22'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'22'29) >> return (NormalTok,"") ) >>~ pushContext "HereDocIQ")+   <|>+   ((lookAhead (pRegExpr regex_'28'3c'3c'2d'5cs'2a'27'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'27'29) >> return (NormalTok,"") ) >>~ pushContext "HereDocIQ")+   <|>+   ((lookAhead (pRegExpr regex_'28'3c'3c'2d'5cs'2a'5c'5c'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'29) >> return (NormalTok,"") ) >>~ pushContext "HereDocIQ")+   <|>+   ((lookAhead (pRegExpr regex_'28'3c'3c'2d'5cs'2a'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'29) >> return (NormalTok,"") ) >>~ pushContext "HereDocINQ")+   <|>+   ((lookAhead (pRegExpr regex_'28'3c'3c'5cs'2a'22'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'22'29) >> return (NormalTok,"") ) >>~ pushContext "HereDocQ")+   <|>+   ((lookAhead (pRegExpr regex_'28'3c'3c'5cs'2a'27'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'27'29) >> return (NormalTok,"") ) >>~ pushContext "HereDocQ")+   <|>+   ((lookAhead (pRegExpr regex_'28'3c'3c'5cs'2a'5c'5c'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'29) >> return (NormalTok,"") ) >>~ pushContext "HereDocQ")+   <|>+   ((lookAhead (pRegExpr regex_'28'3c'3c'5cs'2a'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'29) >> return (NormalTok,"") ) >>~ pushContext "HereDocNQ")+   <|>+   ((pString False "<<" >>= withAttribute KeywordTok) >>~ (popContext)))++parseRules "HereDocRemainder" =+  ((parseRules "FindAll"))++parseRules "HereDocQ" =+  (((pRegExprDynamic "%1" >>= withAttribute KeywordTok) >>~ pushContext "HereDocRemainder")+   <|>+   ((pColumn 0 >> pRegExprDynamic "%2\\b" >>= withAttribute KeywordTok) >>~ (popContext >> popContext)))++parseRules "HereDocNQ" =+  (((pRegExprDynamic "%1" >>= withAttribute KeywordTok) >>~ pushContext "HereDocRemainder")+   <|>+   ((pColumn 0 >> pRegExprDynamic "%2\\b" >>= withAttribute KeywordTok) >>~ (popContext >> popContext))+   <|>+   ((parseRules "FindSubstitutions")))++parseRules "HereDocIQ" =+  (((pRegExprDynamic "%1" >>= withAttribute KeywordTok) >>~ pushContext "HereDocRemainder")+   <|>+   ((pColumn 0 >> pRegExprDynamic "\\t*%2\\b" >>= withAttribute KeywordTok) >>~ (popContext >> popContext)))++parseRules "HereDocINQ" =+  (((pRegExprDynamic "%1" >>= withAttribute KeywordTok) >>~ pushContext "HereDocRemainder")+   <|>+   ((pColumn 0 >> pRegExprDynamic "\\t*%2\\b" >>= withAttribute KeywordTok) >>~ (popContext >> popContext))+   <|>+   ((parseRules "FindSubstitutions")))  parseRules "" = parseRules "Start" 

@@ -1,15 +1,18 @@-{- This module was generated from data in the Kate syntax highlighting file bibtex.xml, version 1.17,-   by  Jeroen Wijnhout (Jeroen.Wijnhout@kdemail.net)+Thomas Braun (thomas.braun@virtuell-zuhause.de) -}+{- This module was generated from data in the Kate syntax+   highlighting file bibtex.xml, version 1.17, by Jeroen Wijnhout (Jeroen.Wijnhout@kdemail.net)+Thomas Braun (thomas.braun@virtuell-zuhause.de) -} -module Text.Highlighting.Kate.Syntax.Bibtex ( highlight, parseExpression, syntaxName, syntaxExtensions ) where-import Text.Highlighting.Kate.Definitions+module Text.Highlighting.Kate.Syntax.Bibtex+          (highlight, parseExpression, syntaxName, syntaxExtensions)+where+import Text.Highlighting.Kate.Types import Text.Highlighting.Kate.Common-import Text.ParserCombinators.Parsec-import Control.Monad (when)+import Text.ParserCombinators.Parsec hiding (State) import Data.Map (fromList)-import Data.Maybe (fromMaybe, maybeToList)-+import Control.Monad.State+import Data.Char (isSpace)+import Data.Maybe (fromMaybe) import qualified Data.Set as Set+ -- | Full name of language. syntaxName :: String syntaxName = "BibTeX"@@ -19,60 +22,47 @@ syntaxExtensions = "*.bib"  -- | Highlight source code using this syntax definition.-highlight :: String -> Either String [SourceLine]-highlight input =-  case runParser parseSource startingState "source" input of-    Left err     -> Left $ show err-    Right result -> Right result+highlight :: String -> [SourceLine]+highlight input = evalState (mapM parseSourceLine $ lines input) startingState +parseSourceLine :: String -> State SyntaxState SourceLine+parseSourceLine = mkParseSourceLine parseExpressionInternal pEndLine+ -- | Parse an expression using appropriate local context.-parseExpression :: GenParser Char SyntaxState LabeledSource+parseExpression :: KateParser Token parseExpression = do   st <- getState   let oldLang = synStLanguage st   setState $ st { synStLanguage = "BibTeX" }   context <- currentContext <|> (pushContext "Normal" >> currentContext)   result <- parseRules context+  optional $ eof >> pEndLine   updateState $ \st -> st { synStLanguage = oldLang }   return result -parseSource = do -  lineContents <- lookAhead wholeLine-  updateState $ \st -> st { synStCurrentLine = lineContents }-  result <- manyTill parseSourceLine eof-  return $ map normalizeHighlighting result--startingState = SyntaxState {synStContexts = fromList [("BibTeX",["Normal"])], synStLanguage = "BibTeX", synStCurrentLine = "", synStCharsParsedInLine = 0, synStPrevChar = '\n', synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}--parseSourceLine = manyTill parseExpressionInternal pEndLine+startingState = SyntaxState {synStContexts = fromList [("BibTeX",["Normal"])], synStLanguage = "BibTeX", synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}  pEndLine = do-  lookAhead $ newline <|> (eof >> return '\n')   context <- currentContext   case context of-    "Normal" -> return () >> pHandleEndLine-    "PreambleCommand" -> return () >> pHandleEndLine-    "StringCommand" -> return () >> pHandleEndLine-    "Entry" -> return () >> pHandleEndLine-    "Field" -> return () >> pHandleEndLine-    "CurlyBracket" -> return () >> pHandleEndLine-    "QuotedText" -> return () >> pHandleEndLine-    _ -> pHandleEndLine+    "Normal" -> return ()+    "PreambleCommand" -> return ()+    "StringCommand" -> return ()+    "Entry" -> return ()+    "Field" -> return ()+    "CurlyBracket" -> return ()+    "QuotedText" -> return ()+    _ -> return ()  withAttribute attr txt = do   when (null txt) $ fail "Parser matched no text"-  let labs = attr : maybeToList (lookup attr styles)-  st <- getState-  let oldCharsParsed = synStCharsParsedInLine st-  let prevchar = if null txt then '\n' else last txt-  updateState $ \st -> st { synStCharsParsedInLine = oldCharsParsed + length txt, synStPrevChar = prevchar } -  return (labs, txt)--styles = [("Entry","kw"),("Command","fu"),("Field","dt"),("Ref Key","ot"),("LatexCommand","ch"),("Comment","co"),("Error","al"),("String","st")]+  updateState $ \st -> st { synStPrevChar = last txt+                          , synStPrevNonspace = synStPrevNonspace st || not (all isSpace txt) }+  return (attr, txt)  parseExpressionInternal = do   context <- currentContext-  parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes))+  parseRules context <|> (pDefault >>= withAttribute (fromMaybe NormalTok $ lookup context defaultAttributes))  list_kw'5fentry = Set.fromList $ words $ "@article @book @booklet @conference @collection @electronic @inbook @incollection @inproceedings @manual @mastersthesis @misc @online @patent @periodical @proceedings @report @phdthesis @set @thesis @techreport @unpublished @www @person @company @place" @@ -84,85 +74,78 @@ regex_'5c'5c'28'5ba'2dzA'2dZ'40'5d'2b'7c'5b'5e_'5d'29 = compileRegex "\\\\([a-zA-Z@]+|[^ ])" regex_'7d'24 = compileRegex "}$" -defaultAttributes = [("Normal","Comment"),("PreambleCommand","Normal Text"),("StringCommand","Normal Text"),("Entry","Normal Text"),("Field","Normal Text"),("CurlyBracket","Normal Text"),("QuotedText","String")]+defaultAttributes = [("Normal",CommentTok),("PreambleCommand",NormalTok),("StringCommand",NormalTok),("Entry",NormalTok),("Field",NormalTok),("CurlyBracket",NormalTok),("QuotedText",StringTok)] -parseRules "Normal" = -  do (attr, result) <- (((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~" list_kw'5fentry >>= withAttribute "Entry") >>~ pushContext "Entry")-                        <|>-                        ((pString False "@string" >>= withAttribute "Command") >>~ pushContext "StringCommand")-                        <|>-                        ((pString False "@preamble" >>= withAttribute "Command") >>~ pushContext "PreambleCommand")-                        <|>-                        ((pString False "@comment" >>= withAttribute "Comment")))-     return (attr, result)+parseRules "Normal" =+  (((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~" list_kw'5fentry >>= withAttribute KeywordTok) >>~ pushContext "Entry")+   <|>+   ((pString False "@string" >>= withAttribute FunctionTok) >>~ pushContext "StringCommand")+   <|>+   ((pString False "@preamble" >>= withAttribute FunctionTok) >>~ pushContext "PreambleCommand")+   <|>+   ((pString False "@comment" >>= withAttribute CommentTok))) -parseRules "PreambleCommand" = -  do (attr, result) <- (((pDetectChar False '{' >>= withAttribute "Normal Text") >>~ pushContext "CurlyBracket")-                        <|>-                        ((popContext) >> return ([], "")))-     return (attr, result)+parseRules "PreambleCommand" =+  (((pDetectChar False '{' >>= withAttribute NormalTok) >>~ pushContext "CurlyBracket")+   <|>+   ((popContext) >> currentContext >>= parseRules)) -parseRules "StringCommand" = -  do (attr, result) <- (((pDetectChar False '{' >>= withAttribute "Normal Text") >>~ pushContext "CurlyBracket")-                        <|>-                        ((pRegExpr regex_'5ba'2dzA'2dZ0'2d9'5c'2d'5d'2b >>= withAttribute "String") >>~ pushContext "CurlyBracket")-                        <|>-                        ((popContext) >> return ([], "")))-     return (attr, result)+parseRules "StringCommand" =+  (((pDetectChar False '{' >>= withAttribute NormalTok) >>~ pushContext "CurlyBracket")+   <|>+   ((pRegExpr regex_'5ba'2dzA'2dZ0'2d9'5c'2d'5d'2b >>= withAttribute StringTok) >>~ pushContext "CurlyBracket")+   <|>+   ((popContext) >> currentContext >>= parseRules)) -parseRules "Entry" = -  do (attr, result) <- (((pDetectChar False '{' >>= withAttribute "Normal Text"))-                        <|>-                        ((pRegExpr regex_'5ba'2dzA'2dZ0'2d9'5f'40'5c'5c'2d'5c'5c'3a'5d'2b >>= withAttribute "Ref Key"))-                        <|>-                        ((pDetectChar False ',' >>= withAttribute "Normal Text") >>~ pushContext "Field")-                        <|>-                        ((pDetectChar False '}' >>= withAttribute "Normal Text") >>~ (popContext)))-     return (attr, result)+parseRules "Entry" =+  (((pDetectChar False '{' >>= withAttribute NormalTok))+   <|>+   ((pRegExpr regex_'5ba'2dzA'2dZ0'2d9'5f'40'5c'5c'2d'5c'5c'3a'5d'2b >>= withAttribute OtherTok))+   <|>+   ((pDetectChar False ',' >>= withAttribute NormalTok) >>~ pushContext "Field")+   <|>+   ((pDetectChar False '}' >>= withAttribute NormalTok) >>~ (popContext))) -parseRules "Field" = -  do (attr, result) <- (((pFirstNonSpace >> pRegExpr regex_'5ba'2dzA'2dZ0'2d9'5c'2d'5f'5c'2e'5d'2b >>= withAttribute "Field"))-                        <|>-                        ((pDetectSpaces >>= withAttribute "Normal Text"))-                        <|>-                        ((pDetectChar False '=' >>= withAttribute "Normal Text"))-                        <|>-                        ((pDetectSpaces >>= withAttribute "Normal Text"))-                        <|>-                        ((pDetectChar False '{' >>= withAttribute "Normal Text") >>~ pushContext "CurlyBracket")-                        <|>-                        ((lookAhead (pDetectChar False '}') >> return ([],"") ) >>~ (popContext))-                        <|>-                        ((pDetectChar False '"' >>= withAttribute "Normal Text") >>~ pushContext "QuotedText")-                        <|>-                        ((pDetectChar False ',' >>= withAttribute "Normal Text"))-                        <|>-                        ((pDetectChar False '#' >>= withAttribute "Normal Text"))-                        <|>-                        ((pRegExpr regex_'5b0'2d9'5d'2b >>= withAttribute "Normal Text"))-                        <|>-                        ((pRegExpr regex_'5ba'2dzA'2dZ0'2d9'5c'2d'5d'2b >>= withAttribute "String"))-                        <|>-                        ((pDetectSpaces >>= withAttribute "Normal Text"))-                        <|>-                        ((pRegExpr regex_'2e >>= withAttribute "Error")))-     return (attr, result)+parseRules "Field" =+  (((pFirstNonSpace >> pRegExpr regex_'5ba'2dzA'2dZ0'2d9'5c'2d'5f'5c'2e'5d'2b >>= withAttribute DataTypeTok))+   <|>+   ((pDetectSpaces >>= withAttribute NormalTok))+   <|>+   ((pDetectChar False '=' >>= withAttribute NormalTok))+   <|>+   ((pDetectSpaces >>= withAttribute NormalTok))+   <|>+   ((pDetectChar False '{' >>= withAttribute NormalTok) >>~ pushContext "CurlyBracket")+   <|>+   ((lookAhead (pDetectChar False '}') >> return (NormalTok,"") ) >>~ (popContext))+   <|>+   ((pDetectChar False '"' >>= withAttribute NormalTok) >>~ pushContext "QuotedText")+   <|>+   ((pDetectChar False ',' >>= withAttribute NormalTok))+   <|>+   ((pDetectChar False '#' >>= withAttribute NormalTok))+   <|>+   ((pRegExpr regex_'5b0'2d9'5d'2b >>= withAttribute NormalTok))+   <|>+   ((pRegExpr regex_'5ba'2dzA'2dZ0'2d9'5c'2d'5d'2b >>= withAttribute StringTok))+   <|>+   ((pDetectSpaces >>= withAttribute NormalTok))+   <|>+   ((pRegExpr regex_'2e >>= withAttribute AlertTok))) -parseRules "CurlyBracket" = -  do (attr, result) <- (((pDetectChar False '{' >>= withAttribute "Normal Text") >>~ pushContext "CurlyBracket")-                        <|>-                        ((pRegExpr regex_'5c'5c'28'5ba'2dzA'2dZ'40'5d'2b'7c'5b'5e_'5d'29 >>= withAttribute "LatexCommand"))-                        <|>-                        ((pRegExpr regex_'7d'24 >>= withAttribute "Normal Text") >>~ (popContext >> popContext))-                        <|>-                        ((pDetectChar False '}' >>= withAttribute "Normal Text") >>~ (popContext)))-     return (attr, result)+parseRules "CurlyBracket" =+  (((pDetectChar False '{' >>= withAttribute NormalTok) >>~ pushContext "CurlyBracket")+   <|>+   ((pRegExpr regex_'5c'5c'28'5ba'2dzA'2dZ'40'5d'2b'7c'5b'5e_'5d'29 >>= withAttribute CharTok))+   <|>+   ((pRegExpr regex_'7d'24 >>= withAttribute NormalTok) >>~ (popContext >> popContext))+   <|>+   ((pDetectChar False '}' >>= withAttribute NormalTok) >>~ (popContext))) -parseRules "QuotedText" = -  do (attr, result) <- (((pDetectChar False '"' >>= withAttribute "Normal Text") >>~ (popContext))-                        <|>-                        ((pRegExpr regex_'5c'5c'28'5ba'2dzA'2dZ'40'5d'2b'7c'5b'5e_'5d'29 >>= withAttribute "LatexCommand")))-     return (attr, result)+parseRules "QuotedText" =+  (((pDetectChar False '"' >>= withAttribute NormalTok) >>~ (popContext))+   <|>+   ((pRegExpr regex_'5c'5c'28'5ba'2dzA'2dZ'40'5d'2b'7c'5b'5e_'5d'29 >>= withAttribute CharTok)))  parseRules "" = parseRules "Normal" 

@@ -1,15 +1,18 @@-{- This module was generated from data in the Kate syntax highlighting file boo.xml, version 0.91,-   by  Marc Dassonneville -}+{- This module was generated from data in the Kate syntax+   highlighting file boo.xml, version 0.91, by Marc Dassonneville -} -module Text.Highlighting.Kate.Syntax.Boo ( highlight, parseExpression, syntaxName, syntaxExtensions ) where-import Text.Highlighting.Kate.Definitions+module Text.Highlighting.Kate.Syntax.Boo+          (highlight, parseExpression, syntaxName, syntaxExtensions)+where+import Text.Highlighting.Kate.Types import Text.Highlighting.Kate.Common-import Text.ParserCombinators.Parsec-import Control.Monad (when)+import Text.ParserCombinators.Parsec hiding (State) import Data.Map (fromList)-import Data.Maybe (fromMaybe, maybeToList)-+import Control.Monad.State+import Data.Char (isSpace)+import Data.Maybe (fromMaybe) import qualified Data.Set as Set+ -- | Full name of language. syntaxName :: String syntaxName = "Boo"@@ -19,69 +22,56 @@ syntaxExtensions = "*.boo"  -- | Highlight source code using this syntax definition.-highlight :: String -> Either String [SourceLine]-highlight input =-  case runParser parseSource startingState "source" input of-    Left err     -> Left $ show err-    Right result -> Right result+highlight :: String -> [SourceLine]+highlight input = evalState (mapM parseSourceLine $ lines input) startingState +parseSourceLine :: String -> State SyntaxState SourceLine+parseSourceLine = mkParseSourceLine parseExpressionInternal pEndLine+ -- | Parse an expression using appropriate local context.-parseExpression :: GenParser Char SyntaxState LabeledSource+parseExpression :: KateParser Token parseExpression = do   st <- getState   let oldLang = synStLanguage st   setState $ st { synStLanguage = "Boo" }   context <- currentContext <|> (pushContext "Normal" >> currentContext)   result <- parseRules context+  optional $ eof >> pEndLine   updateState $ \st -> st { synStLanguage = oldLang }   return result -parseSource = do -  lineContents <- lookAhead wholeLine-  updateState $ \st -> st { synStCurrentLine = lineContents }-  result <- manyTill parseSourceLine eof-  return $ map normalizeHighlighting result--startingState = SyntaxState {synStContexts = fromList [("Boo",["Normal"])], synStLanguage = "Boo", synStCurrentLine = "", synStCharsParsedInLine = 0, synStPrevChar = '\n', synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}--parseSourceLine = manyTill parseExpressionInternal pEndLine+startingState = SyntaxState {synStContexts = fromList [("Boo",["Normal"])], synStLanguage = "Boo", synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do-  lookAhead $ newline <|> (eof >> return '\n')   context <- currentContext   case context of-    "Normal" -> return () >> pHandleEndLine-    "parenthesised" -> return () >> pHandleEndLine-    "Quasi-Quotation" -> return () >> pHandleEndLine-    "Tripple A-comment" -> return () >> pHandleEndLine-    "Tripple Q-comment" -> return () >> pHandleEndLine-    "Tripple A-string" -> return () >> pHandleEndLine-    "Raw Tripple A-string" -> return () >> pHandleEndLine-    "Tripple Q-string" -> return () >> pHandleEndLine-    "Raw Tripple Q-string" -> return () >> pHandleEndLine+    "Normal" -> return ()+    "parenthesised" -> return ()+    "Quasi-Quotation" -> return ()+    "Tripple A-comment" -> return ()+    "Tripple Q-comment" -> return ()+    "Tripple A-string" -> return ()+    "Raw Tripple A-string" -> return ()+    "Tripple Q-string" -> return ()+    "Raw Tripple Q-string" -> return ()     "Comment SlashSlash" -> (popContext) >> pEndLine-    "Single A-comment" -> return () >> pHandleEndLine-    "Single Q-comment" -> return () >> pHandleEndLine-    "Single A-string" -> return () >> pHandleEndLine-    "Single Q-string" -> return () >> pHandleEndLine-    "Raw A-string" -> return () >> pHandleEndLine-    "Raw Q-string" -> return () >> pHandleEndLine-    _ -> pHandleEndLine+    "Single A-comment" -> return ()+    "Single Q-comment" -> return ()+    "Single A-string" -> return ()+    "Single Q-string" -> return ()+    "Raw A-string" -> return ()+    "Raw Q-string" -> return ()+    _ -> return ()  withAttribute attr txt = do   when (null txt) $ fail "Parser matched no text"-  let labs = attr : maybeToList (lookup attr styles)-  st <- getState-  let oldCharsParsed = synStCharsParsedInLine st-  let prevchar = if null txt then '\n' else last txt-  updateState $ \st -> st { synStCharsParsedInLine = oldCharsParsed + length txt, synStPrevChar = prevchar } -  return (labs, txt)--styles = [("Definition Keyword","kw"),("Data Type","dt"),("Flow Control Keyword","kw"),("Builtin Function","dt"),("Special Variable","ot"),("Preprocessor","ch"),("String Char","ch"),("Long","ot"),("Float","fl"),("Int","dv"),("Hex","ot"),("Octal","ot"),("Complex","ot"),("Comment","co"),("String","st"),("Raw String","st")]+  updateState $ \st -> st { synStPrevChar = last txt+                          , synStPrevNonspace = synStPrevNonspace st || not (all isSpace txt) }+  return (attr, txt)  parseExpressionInternal = do   context <- currentContext-  parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes))+  parseRules context <|> (pDefault >>= withAttribute (fromMaybe NormalTok $ lookup context defaultAttributes))  list_namespace = Set.fromList $ words $ "import from as namespace" list_operators = Set.fromList $ words $ "and assert in is not or"@@ -112,189 +102,173 @@ regex_'25'5c'28'5ba'2dzA'2dZ0'2d9'5f'5d'2b'5c'29'5ba'2dzA'2dZ'5d = compileRegex "%\\([a-zA-Z0-9_]+\\)[a-zA-Z]" regex_'27'27'27 = compileRegex "'''" -defaultAttributes = [("Normal","Normal Text"),("parenthesised","Normal Text"),("Quasi-Quotation","Operator"),("Tripple A-comment","Comment"),("Tripple Q-comment","Comment"),("Tripple A-string","String"),("Raw Tripple A-string","Raw String"),("Tripple Q-string","String"),("Raw Tripple Q-string","Raw String"),("Comment SlashSlash","Comment"),("Single A-comment","Comment"),("Single Q-comment","Comment"),("Single A-string","String"),("Single Q-string","String"),("Raw A-string","Raw String"),("Raw Q-string","Raw String")]+defaultAttributes = [("Normal",NormalTok),("parenthesised",NormalTok),("Quasi-Quotation",NormalTok),("Tripple A-comment",CommentTok),("Tripple Q-comment",CommentTok),("Tripple A-string",StringTok),("Raw Tripple A-string",StringTok),("Tripple Q-string",StringTok),("Raw Tripple Q-string",StringTok),("Comment SlashSlash",CommentTok),("Single A-comment",CommentTok),("Single Q-comment",CommentTok),("Single A-string",StringTok),("Single Q-string",StringTok),("Raw A-string",StringTok),("Raw Q-string",StringTok)] -parseRules "Normal" = -  do (attr, result) <- (((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_namespace >>= withAttribute "Preprocessor"))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_definition >>= withAttribute "Definition Keyword"))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_operators >>= withAttribute "Operator"))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_keywords >>= withAttribute "Flow Control Keyword"))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_builtins >>= withAttribute "Builtin Function"))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_literals >>= withAttribute "Special Variable"))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_boolean >>= withAttribute "Special Variable"))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_primitive >>= withAttribute "Data Type"))-                        <|>-                        ((pRegExpr regex_'5ba'2dzA'2dZ'5f'5d'5ba'2dzA'2dZ'5f0'2d9'5d'2b >>= withAttribute "Normal"))-                        <|>-                        ((pRegExpr regex__'28'28'28'5b0'2d9'5d'2a'5c'2e'5b0'2d9'5d'2b'7c'5b0'2d9'5d'2b'5c'2e'29'7c'28'5b0'2d9'5d'2b'7c'28'5b0'2d9'5d'2a'5c'2e'5b0'2d9'5d'2b'7c'5b0'2d9'5d'2b'5c'2e'29'29'5beE'5d'28'5c'2b'7c'2d'29'3f'5b0'2d9'5d'2b'29'7c'5b0'2d9'5d'2b'29'5bjJ'5d >>= withAttribute "Complex"))-                        <|>-                        ((pRegExpr regex_'28'5b0'2d9'5d'2b'5c'2e'5b0'2d9'5d'2a'7c'5c'2e'5b0'2d9'5d'2b'29'28'5beE'5d'5b0'2d9'5d'2b'29'3f >>= withAttribute "Float"))-                        <|>-                        ((pRegExpr regex_'28'5b1'2d9'5d'5b0'2d9'5d'2a'28'5beE'5d'5b0'2d9'5d'2b'29'3f'7c0'29 >>= withAttribute "Int"))-                        <|>-                        ((pRegExpr regex_'5b1'2d9'5d'5b0'2d9'5d'2a'28'5beE'5d'5b0'2d9'2e'5d'2b'29'3f'5bLl'5d >>= withAttribute "Long"))-                        <|>-                        ((pRegExpr regex_0'5bXx'5d'5b0'2d9a'2dfA'2dF'5d'2b >>= withAttribute "Hex"))-                        <|>-                        ((pRegExpr regex_0'5b1'2d9'5d'5b0'2d9'5d'2a >>= withAttribute "Octal"))-                        <|>-                        ((pRegExpr regex_'5brR'5d'27'27'27 >>= withAttribute "Raw String") >>~ pushContext "Raw Tripple A-string")-                        <|>-                        ((pRegExpr regex_'5brR'5d'22'22'22 >>= withAttribute "Raw String") >>~ pushContext "Raw Tripple Q-string")-                        <|>-                        ((pRegExpr regex_'5brR'5d'27 >>= withAttribute "Raw String") >>~ pushContext "Raw A-string")-                        <|>-                        ((pRegExpr regex_'5brR'5d'22 >>= withAttribute "Raw String") >>~ pushContext "Raw Q-string")-                        <|>-                        ((pRegExpr regex_'23'2e'2a'24 >>= withAttribute "Comment"))-                        <|>-                        ((pColumn 0 >> pRegExpr regex_'5cs'2au'3f'27'27'27 >>= withAttribute "Comment") >>~ pushContext "Tripple A-comment")-                        <|>-                        ((pColumn 0 >> pRegExpr regex_'5cs'2au'3f'22'22'22 >>= withAttribute "Comment") >>~ pushContext "Tripple Q-comment")-                        <|>-                        ((pDetect2Chars False '/' '/' >>= withAttribute "Comment") >>~ pushContext "Comment SlashSlash")-                        <|>-                        ((pString False "'''" >>= withAttribute "String") >>~ pushContext "Tripple A-string")-                        <|>-                        ((pString False "\"\"\"" >>= withAttribute "String") >>~ pushContext "Tripple Q-string")-                        <|>-                        ((pDetectChar False '\'' >>= withAttribute "String") >>~ pushContext "Single A-string")-                        <|>-                        ((pDetectChar False '"' >>= withAttribute "String") >>~ pushContext "Single Q-string")-                        <|>-                        ((pDetectChar False '(' >>= withAttribute "Operator") >>~ pushContext "parenthesised")-                        <|>-                        ((pDetectChar False ')' >>= withAttribute "Operator") >>~ (popContext))-                        <|>-                        ((pString False "[|" >>= withAttribute "Operator") >>~ pushContext "Quasi-Quotation")-                        <|>-                        ((pString False "|]" >>= withAttribute "Operator") >>~ (popContext))-                        <|>-                        ((pRegExpr regex_'5b'2b'2a'2f'25'5c'7c'3d'3b'5c'21'3c'3e'21'5e'26'7e'2d'5d >>= withAttribute "Operator"))-                        <|>-                        ((pRegExpr regex_'25'5ba'2dzA'2dZ'5d >>= withAttribute "String Substitution")))-     return (attr, result)+parseRules "Normal" =+  (((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_namespace >>= withAttribute CharTok))+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_definition >>= withAttribute KeywordTok))+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_operators >>= withAttribute NormalTok))+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_keywords >>= withAttribute KeywordTok))+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_builtins >>= withAttribute DataTypeTok))+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_literals >>= withAttribute OtherTok))+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_boolean >>= withAttribute OtherTok))+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_primitive >>= withAttribute DataTypeTok))+   <|>+   ((pRegExpr regex_'5ba'2dzA'2dZ'5f'5d'5ba'2dzA'2dZ'5f0'2d9'5d'2b >>= withAttribute NormalTok))+   <|>+   ((pRegExpr regex__'28'28'28'5b0'2d9'5d'2a'5c'2e'5b0'2d9'5d'2b'7c'5b0'2d9'5d'2b'5c'2e'29'7c'28'5b0'2d9'5d'2b'7c'28'5b0'2d9'5d'2a'5c'2e'5b0'2d9'5d'2b'7c'5b0'2d9'5d'2b'5c'2e'29'29'5beE'5d'28'5c'2b'7c'2d'29'3f'5b0'2d9'5d'2b'29'7c'5b0'2d9'5d'2b'29'5bjJ'5d >>= withAttribute OtherTok))+   <|>+   ((pRegExpr regex_'28'5b0'2d9'5d'2b'5c'2e'5b0'2d9'5d'2a'7c'5c'2e'5b0'2d9'5d'2b'29'28'5beE'5d'5b0'2d9'5d'2b'29'3f >>= withAttribute FloatTok))+   <|>+   ((pRegExpr regex_'28'5b1'2d9'5d'5b0'2d9'5d'2a'28'5beE'5d'5b0'2d9'5d'2b'29'3f'7c0'29 >>= withAttribute DecValTok))+   <|>+   ((pRegExpr regex_'5b1'2d9'5d'5b0'2d9'5d'2a'28'5beE'5d'5b0'2d9'2e'5d'2b'29'3f'5bLl'5d >>= withAttribute OtherTok))+   <|>+   ((pRegExpr regex_0'5bXx'5d'5b0'2d9a'2dfA'2dF'5d'2b >>= withAttribute OtherTok))+   <|>+   ((pRegExpr regex_0'5b1'2d9'5d'5b0'2d9'5d'2a >>= withAttribute OtherTok))+   <|>+   ((pRegExpr regex_'5brR'5d'27'27'27 >>= withAttribute StringTok) >>~ pushContext "Raw Tripple A-string")+   <|>+   ((pRegExpr regex_'5brR'5d'22'22'22 >>= withAttribute StringTok) >>~ pushContext "Raw Tripple Q-string")+   <|>+   ((pRegExpr regex_'5brR'5d'27 >>= withAttribute StringTok) >>~ pushContext "Raw A-string")+   <|>+   ((pRegExpr regex_'5brR'5d'22 >>= withAttribute StringTok) >>~ pushContext "Raw Q-string")+   <|>+   ((pRegExpr regex_'23'2e'2a'24 >>= withAttribute CommentTok))+   <|>+   ((pColumn 0 >> pRegExpr regex_'5cs'2au'3f'27'27'27 >>= withAttribute CommentTok) >>~ pushContext "Tripple A-comment")+   <|>+   ((pColumn 0 >> pRegExpr regex_'5cs'2au'3f'22'22'22 >>= withAttribute CommentTok) >>~ pushContext "Tripple Q-comment")+   <|>+   ((pDetect2Chars False '/' '/' >>= withAttribute CommentTok) >>~ pushContext "Comment SlashSlash")+   <|>+   ((pString False "'''" >>= withAttribute StringTok) >>~ pushContext "Tripple A-string")+   <|>+   ((pString False "\"\"\"" >>= withAttribute StringTok) >>~ pushContext "Tripple Q-string")+   <|>+   ((pDetectChar False '\'' >>= withAttribute StringTok) >>~ pushContext "Single A-string")+   <|>+   ((pDetectChar False '"' >>= withAttribute StringTok) >>~ pushContext "Single Q-string")+   <|>+   ((pDetectChar False '(' >>= withAttribute NormalTok) >>~ pushContext "parenthesised")+   <|>+   ((pDetectChar False ')' >>= withAttribute NormalTok) >>~ (popContext))+   <|>+   ((pString False "[|" >>= withAttribute NormalTok) >>~ pushContext "Quasi-Quotation")+   <|>+   ((pString False "|]" >>= withAttribute NormalTok) >>~ (popContext))+   <|>+   ((pRegExpr regex_'5b'2b'2a'2f'25'5c'7c'3d'3b'5c'21'3c'3e'21'5e'26'7e'2d'5d >>= withAttribute NormalTok))+   <|>+   ((pRegExpr regex_'25'5ba'2dzA'2dZ'5d >>= withAttribute NormalTok))) -parseRules "parenthesised" = -  do (attr, result) <- ((parseRules "Normal"))-     return (attr, result)+parseRules "parenthesised" =+  ((parseRules "Normal")) -parseRules "Quasi-Quotation" = -  do (attr, result) <- ((parseRules "Normal"))-     return (attr, result)+parseRules "Quasi-Quotation" =+  ((parseRules "Normal")) -parseRules "Tripple A-comment" = -  do (attr, result) <- ((pString False "'''" >>= withAttribute "Comment") >>~ (popContext))-     return (attr, result)+parseRules "Tripple A-comment" =+  ((pString False "'''" >>= withAttribute CommentTok) >>~ (popContext)) -parseRules "Tripple Q-comment" = -  do (attr, result) <- (((pHlCChar >>= withAttribute "Comment"))-                        <|>-                        ((pRegExpr regex_'22'22'22 >>= withAttribute "Comment") >>~ (popContext)))-     return (attr, result)+parseRules "Tripple Q-comment" =+  (((pHlCChar >>= withAttribute CommentTok))+   <|>+   ((pRegExpr regex_'22'22'22 >>= withAttribute CommentTok) >>~ (popContext))) -parseRules "Tripple A-string" = -  do (attr, result) <- (((pHlCStringChar >>= withAttribute "String Char"))-                        <|>-                        ((pRegExpr regex_'25'5c'28'5ba'2dzA'2dZ0'2d9'5f'5d'2b'5c'29'5ba'2dzA'2dZ'5d >>= withAttribute "String Substitution"))-                        <|>-                        ((pRegExpr regex_'25'5ba'2dzA'2dZ'5d >>= withAttribute "String Substitution"))-                        <|>-                        ((pRegExpr regex_'27'27'27 >>= withAttribute "String") >>~ (popContext)))-     return (attr, result)+parseRules "Tripple A-string" =+  (((pHlCStringChar >>= withAttribute CharTok))+   <|>+   ((pRegExpr regex_'25'5c'28'5ba'2dzA'2dZ0'2d9'5f'5d'2b'5c'29'5ba'2dzA'2dZ'5d >>= withAttribute NormalTok))+   <|>+   ((pRegExpr regex_'25'5ba'2dzA'2dZ'5d >>= withAttribute NormalTok))+   <|>+   ((pRegExpr regex_'27'27'27 >>= withAttribute StringTok) >>~ (popContext))) -parseRules "Raw Tripple A-string" = -  do (attr, result) <- (((pHlCStringChar >>= withAttribute "Raw String"))-                        <|>-                        ((pRegExpr regex_'25'5c'28'5ba'2dzA'2dZ0'2d9'5f'5d'2b'5c'29'5ba'2dzA'2dZ'5d >>= withAttribute "String Substitution"))-                        <|>-                        ((pRegExpr regex_'25'5ba'2dzA'2dZ'5d >>= withAttribute "String Substitution"))-                        <|>-                        ((pRegExpr regex_'27'27'27 >>= withAttribute "String") >>~ (popContext)))-     return (attr, result)+parseRules "Raw Tripple A-string" =+  (((pHlCStringChar >>= withAttribute StringTok))+   <|>+   ((pRegExpr regex_'25'5c'28'5ba'2dzA'2dZ0'2d9'5f'5d'2b'5c'29'5ba'2dzA'2dZ'5d >>= withAttribute NormalTok))+   <|>+   ((pRegExpr regex_'25'5ba'2dzA'2dZ'5d >>= withAttribute NormalTok))+   <|>+   ((pRegExpr regex_'27'27'27 >>= withAttribute StringTok) >>~ (popContext))) -parseRules "Tripple Q-string" = -  do (attr, result) <- (((pHlCStringChar >>= withAttribute "String Char"))-                        <|>-                        ((pRegExpr regex_'25'5c'28'5ba'2dzA'2dZ0'2d9'5f'5d'2b'5c'29'5ba'2dzA'2dZ'5d >>= withAttribute "String Substitution"))-                        <|>-                        ((pRegExpr regex_'25'5ba'2dzA'2dZ'5d >>= withAttribute "String Substitution"))-                        <|>-                        ((pRegExpr regex_'22'22'22 >>= withAttribute "String") >>~ (popContext)))-     return (attr, result)+parseRules "Tripple Q-string" =+  (((pHlCStringChar >>= withAttribute CharTok))+   <|>+   ((pRegExpr regex_'25'5c'28'5ba'2dzA'2dZ0'2d9'5f'5d'2b'5c'29'5ba'2dzA'2dZ'5d >>= withAttribute NormalTok))+   <|>+   ((pRegExpr regex_'25'5ba'2dzA'2dZ'5d >>= withAttribute NormalTok))+   <|>+   ((pRegExpr regex_'22'22'22 >>= withAttribute StringTok) >>~ (popContext))) -parseRules "Raw Tripple Q-string" = -  do (attr, result) <- (((pHlCStringChar >>= withAttribute "Raw String"))-                        <|>-                        ((pRegExpr regex_'25'5c'28'5ba'2dzA'2dZ0'2d9'5f'5d'2b'5c'29'5ba'2dzA'2dZ'5d >>= withAttribute "String Substitution"))-                        <|>-                        ((pRegExpr regex_'25'5ba'2dzA'2dZ'5d >>= withAttribute "String Substitution"))-                        <|>-                        ((pRegExpr regex_'22'22'22 >>= withAttribute "String") >>~ (popContext)))-     return (attr, result)+parseRules "Raw Tripple Q-string" =+  (((pHlCStringChar >>= withAttribute StringTok))+   <|>+   ((pRegExpr regex_'25'5c'28'5ba'2dzA'2dZ0'2d9'5f'5d'2b'5c'29'5ba'2dzA'2dZ'5d >>= withAttribute NormalTok))+   <|>+   ((pRegExpr regex_'25'5ba'2dzA'2dZ'5d >>= withAttribute NormalTok))+   <|>+   ((pRegExpr regex_'22'22'22 >>= withAttribute StringTok) >>~ (popContext))) -parseRules "Comment SlashSlash" = -  do (attr, result) <- ((pLineContinue >>= withAttribute "Comment"))-     return (attr, result)+parseRules "Comment SlashSlash" =+  ((pLineContinue >>= withAttribute CommentTok)) -parseRules "Single A-comment" = -  do (attr, result) <- (((pHlCStringChar >>= withAttribute "Comment"))-                        <|>-                        ((pDetectChar False '\'' >>= withAttribute "Comment") >>~ (popContext)))-     return (attr, result)+parseRules "Single A-comment" =+  (((pHlCStringChar >>= withAttribute CommentTok))+   <|>+   ((pDetectChar False '\'' >>= withAttribute CommentTok) >>~ (popContext))) -parseRules "Single Q-comment" = -  do (attr, result) <- (((pHlCStringChar >>= withAttribute "Comment"))-                        <|>-                        ((pDetectChar False '"' >>= withAttribute "Comment") >>~ (popContext)))-     return (attr, result)+parseRules "Single Q-comment" =+  (((pHlCStringChar >>= withAttribute CommentTok))+   <|>+   ((pDetectChar False '"' >>= withAttribute CommentTok) >>~ (popContext))) -parseRules "Single A-string" = -  do (attr, result) <- (((pHlCStringChar >>= withAttribute "String Char"))-                        <|>-                        ((pRegExpr regex_'25'5c'28'5ba'2dzA'2dZ0'2d9'5f'5d'2b'5c'29'5ba'2dzA'2dZ'5d >>= withAttribute "String Substitution"))-                        <|>-                        ((pRegExpr regex_'25'5ba'2dzA'2dZ'5d >>= withAttribute "String Substitution"))-                        <|>-                        ((pDetectChar False '\'' >>= withAttribute "String") >>~ (popContext)))-     return (attr, result)+parseRules "Single A-string" =+  (((pHlCStringChar >>= withAttribute CharTok))+   <|>+   ((pRegExpr regex_'25'5c'28'5ba'2dzA'2dZ0'2d9'5f'5d'2b'5c'29'5ba'2dzA'2dZ'5d >>= withAttribute NormalTok))+   <|>+   ((pRegExpr regex_'25'5ba'2dzA'2dZ'5d >>= withAttribute NormalTok))+   <|>+   ((pDetectChar False '\'' >>= withAttribute StringTok) >>~ (popContext))) -parseRules "Single Q-string" = -  do (attr, result) <- (((pHlCStringChar >>= withAttribute "String Char"))-                        <|>-                        ((pRegExpr regex_'25'5c'28'5ba'2dzA'2dZ0'2d9'5f'5d'2b'5c'29'5ba'2dzA'2dZ'5d >>= withAttribute "String Substitution"))-                        <|>-                        ((pRegExpr regex_'25'5ba'2dzA'2dZ'5d >>= withAttribute "String Substitution"))-                        <|>-                        ((pDetectChar False '"' >>= withAttribute "String") >>~ (popContext)))-     return (attr, result)+parseRules "Single Q-string" =+  (((pHlCStringChar >>= withAttribute CharTok))+   <|>+   ((pRegExpr regex_'25'5c'28'5ba'2dzA'2dZ0'2d9'5f'5d'2b'5c'29'5ba'2dzA'2dZ'5d >>= withAttribute NormalTok))+   <|>+   ((pRegExpr regex_'25'5ba'2dzA'2dZ'5d >>= withAttribute NormalTok))+   <|>+   ((pDetectChar False '"' >>= withAttribute StringTok) >>~ (popContext))) -parseRules "Raw A-string" = -  do (attr, result) <- (((pHlCStringChar >>= withAttribute "Raw String"))-                        <|>-                        ((pRegExpr regex_'25'5c'28'5ba'2dzA'2dZ0'2d9'5f'5d'2b'5c'29'5ba'2dzA'2dZ'5d >>= withAttribute "String Substitution"))-                        <|>-                        ((pRegExpr regex_'25'5ba'2dzA'2dZ'5d >>= withAttribute "String Substitution"))-                        <|>-                        ((pDetectChar False '\'' >>= withAttribute "Raw String") >>~ (popContext)))-     return (attr, result)+parseRules "Raw A-string" =+  (((pHlCStringChar >>= withAttribute StringTok))+   <|>+   ((pRegExpr regex_'25'5c'28'5ba'2dzA'2dZ0'2d9'5f'5d'2b'5c'29'5ba'2dzA'2dZ'5d >>= withAttribute NormalTok))+   <|>+   ((pRegExpr regex_'25'5ba'2dzA'2dZ'5d >>= withAttribute NormalTok))+   <|>+   ((pDetectChar False '\'' >>= withAttribute StringTok) >>~ (popContext))) -parseRules "Raw Q-string" = -  do (attr, result) <- (((pHlCStringChar >>= withAttribute "Raw String"))-                        <|>-                        ((pRegExpr regex_'25'5c'28'5ba'2dzA'2dZ0'2d9'5f'5d'2b'5c'29'5ba'2dzA'2dZ'5d >>= withAttribute "String Substitution"))-                        <|>-                        ((pRegExpr regex_'25'5ba'2dzA'2dZ'5d >>= withAttribute "String Substitution"))-                        <|>-                        ((pDetectChar False '"' >>= withAttribute "Raw String") >>~ (popContext)))-     return (attr, result)+parseRules "Raw Q-string" =+  (((pHlCStringChar >>= withAttribute StringTok))+   <|>+   ((pRegExpr regex_'25'5c'28'5ba'2dzA'2dZ0'2d9'5f'5d'2b'5c'29'5ba'2dzA'2dZ'5d >>= withAttribute NormalTok))+   <|>+   ((pRegExpr regex_'25'5ba'2dzA'2dZ'5d >>= withAttribute NormalTok))+   <|>+   ((pDetectChar False '"' >>= withAttribute StringTok) >>~ (popContext)))  parseRules "" = parseRules "Normal" 

@@ -1,17 +1,20 @@-{- This module was generated from data in the Kate syntax highlighting file c.xml, version 1.44,-   by   -}+{- This module was generated from data in the Kate syntax+   highlighting file c.xml, version 1.44, by  -} -module Text.Highlighting.Kate.Syntax.C ( highlight, parseExpression, syntaxName, syntaxExtensions ) where-import Text.Highlighting.Kate.Definitions+module Text.Highlighting.Kate.Syntax.C+          (highlight, parseExpression, syntaxName, syntaxExtensions)+where+import Text.Highlighting.Kate.Types import Text.Highlighting.Kate.Common import qualified Text.Highlighting.Kate.Syntax.Doxygen import qualified Text.Highlighting.Kate.Syntax.Alert-import Text.ParserCombinators.Parsec-import Control.Monad (when)+import Text.ParserCombinators.Parsec hiding (State) import Data.Map (fromList)-import Data.Maybe (fromMaybe, maybeToList)-+import Control.Monad.State+import Data.Char (isSpace)+import Data.Maybe (fromMaybe) import qualified Data.Set as Set+ -- | Full name of language. syntaxName :: String syntaxName = "C"@@ -21,64 +24,51 @@ syntaxExtensions = "*.c;*.C;*.h"  -- | Highlight source code using this syntax definition.-highlight :: String -> Either String [SourceLine]-highlight input =-  case runParser parseSource startingState "source" input of-    Left err     -> Left $ show err-    Right result -> Right result+highlight :: String -> [SourceLine]+highlight input = evalState (mapM parseSourceLine $ lines input) startingState +parseSourceLine :: String -> State SyntaxState SourceLine+parseSourceLine = mkParseSourceLine parseExpressionInternal pEndLine+ -- | Parse an expression using appropriate local context.-parseExpression :: GenParser Char SyntaxState LabeledSource+parseExpression :: KateParser Token parseExpression = do   st <- getState   let oldLang = synStLanguage st   setState $ st { synStLanguage = "C" }   context <- currentContext <|> (pushContext "Normal" >> currentContext)   result <- parseRules context+  optional $ eof >> pEndLine   updateState $ \st -> st { synStLanguage = oldLang }   return result -parseSource = do -  lineContents <- lookAhead wholeLine-  updateState $ \st -> st { synStCurrentLine = lineContents }-  result <- manyTill parseSourceLine eof-  return $ map normalizeHighlighting result--startingState = SyntaxState {synStContexts = fromList [("C",["Normal"])], synStLanguage = "C", synStCurrentLine = "", synStCharsParsedInLine = 0, synStPrevChar = '\n', synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}--parseSourceLine = manyTill parseExpressionInternal pEndLine+startingState = SyntaxState {synStContexts = fromList [("C",["Normal"])], synStLanguage = "C", synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do-  lookAhead $ newline <|> (eof >> return '\n')   context <- currentContext   case context of-    "Normal" -> return () >> pHandleEndLine+    "Normal" -> return ()     "String" -> (popContext) >> pEndLine     "Region Marker" -> (popContext) >> pEndLine     "Commentar 1" -> (popContext) >> pEndLine-    "Commentar 2" -> return () >> pHandleEndLine+    "Commentar 2" -> return ()     "AfterHash" -> (popContext) >> pEndLine     "Preprocessor" -> (popContext) >> pEndLine     "Define" -> (popContext) >> pEndLine-    "Commentar/Preprocessor" -> return () >> pHandleEndLine-    "Outscoped" -> return () >> pHandleEndLine-    "Outscoped intern" -> return () >> pHandleEndLine-    _ -> pHandleEndLine+    "Commentar/Preprocessor" -> return ()+    "Outscoped" -> return ()+    "Outscoped intern" -> return ()+    _ -> return ()  withAttribute attr txt = do   when (null txt) $ fail "Parser matched no text"-  let labs = attr : maybeToList (lookup attr styles)-  st <- getState-  let oldCharsParsed = synStCharsParsedInLine st-  let prevchar = if null txt then '\n' else last txt-  updateState $ \st -> st { synStCharsParsedInLine = oldCharsParsed + length txt, synStPrevChar = prevchar } -  return (labs, txt)--styles = [("Keyword","kw"),("Data Type","dt"),("Decimal","dv"),("Octal","bn"),("Hex","bn"),("Float","fl"),("Char","ch"),("String","st"),("String Char","ch"),("Comment","co"),("Preprocessor","ot"),("Prep. Lib","ot"),("Alert","al"),("Region Marker","re"),("Error","er")]+  updateState $ \st -> st { synStPrevChar = last txt+                          , synStPrevNonspace = synStPrevNonspace st || not (all isSpace txt) }+  return (attr, txt)  parseExpressionInternal = do   context <- currentContext-  parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes))+  parseRules context <|> (pDefault >>= withAttribute (fromMaybe NormalTok $ lookup context defaultAttributes))  list_keywords = Set.fromList $ words $ "break case continue default do else enum extern for goto if inline return sizeof struct switch typedef union while" list_types = Set.fromList $ words $ "auto char const double float int long register restrict short signed static unsigned void volatile int8_t int16_t int32_t int64_t uint8_t uint16_t uint32_t uint64_t wchar_t _Imaginary _Complex _Bool"@@ -92,160 +82,150 @@ regex_'23'5cs'2aif = compileRegex "#\\s*if" regex_'23'5cs'2ael'28'3f'3ase'7cif'29 = compileRegex "#\\s*el(?:se|if)" -defaultAttributes = [("Normal","Normal Text"),("String","String"),("Region Marker","Region Marker"),("Commentar 1","Comment"),("Commentar 2","Comment"),("AfterHash","Error"),("Preprocessor","Preprocessor"),("Define","Preprocessor"),("Commentar/Preprocessor","Comment"),("Outscoped","Comment"),("Outscoped intern","Comment")]+defaultAttributes = [("Normal",NormalTok),("String",StringTok),("Region Marker",RegionMarkerTok),("Commentar 1",CommentTok),("Commentar 2",CommentTok),("AfterHash",ErrorTok),("Preprocessor",OtherTok),("Define",OtherTok),("Commentar/Preprocessor",CommentTok),("Outscoped",CommentTok),("Outscoped intern",CommentTok)] -parseRules "Normal" = -  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Normal Text"))-                        <|>-                        ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2aif'5cs'2b0'5cs'2a'24 >>= withAttribute "Preprocessor") >>~ pushContext "Outscoped")-                        <|>-                        ((pFirstNonSpace >> lookAhead (pDetectChar False '#') >> return ([],"") ) >>~ pushContext "AfterHash")-                        <|>-                        ((pFirstNonSpace >> pString False "//BEGIN" >>= withAttribute "Region Marker") >>~ pushContext "Region Marker")-                        <|>-                        ((pFirstNonSpace >> pString False "//END" >>= withAttribute "Region Marker") >>~ pushContext "Region Marker")-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\'\"" list_keywords >>= withAttribute "Keyword"))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\'\"" list_types >>= withAttribute "Data Type"))-                        <|>-                        ((pDetectIdentifier >>= withAttribute "Normal Text"))-                        <|>-                        ((pDetectChar False '{' >>= withAttribute "Symbol"))-                        <|>-                        ((pDetectChar False '}' >>= withAttribute "Symbol"))-                        <|>-                        (withChildren (pFloat >>= withAttribute "Float") ((pAnyChar "fF" >>= withAttribute "Float")))-                        <|>-                        ((pHlCOct >>= withAttribute "Octal"))-                        <|>-                        ((pHlCHex >>= withAttribute "Hex"))-                        <|>-                        (withChildren (pInt >>= withAttribute "Decimal") (((pString False "ULL" >>= withAttribute "Decimal"))-                                                                          <|>-                                                                          ((pString False "LUL" >>= withAttribute "Decimal"))-                                                                          <|>-                                                                          ((pString False "LLU" >>= withAttribute "Decimal"))-                                                                          <|>-                                                                          ((pString False "UL" >>= withAttribute "Decimal"))-                                                                          <|>-                                                                          ((pString False "LU" >>= withAttribute "Decimal"))-                                                                          <|>-                                                                          ((pString False "LL" >>= withAttribute "Decimal"))-                                                                          <|>-                                                                          ((pString False "U" >>= withAttribute "Decimal"))-                                                                          <|>-                                                                          ((pString False "L" >>= withAttribute "Decimal"))))-                        <|>-                        ((pHlCChar >>= withAttribute "Char"))-                        <|>-                        ((pDetectChar False '"' >>= withAttribute "String") >>~ pushContext "String")-                        <|>-                        ((Text.Highlighting.Kate.Syntax.Doxygen.parseExpression))-                        <|>-                        ((pDetect2Chars False '/' '/' >>= withAttribute "Comment") >>~ pushContext "Commentar 1")-                        <|>-                        ((pDetect2Chars False '/' '*' >>= withAttribute "Comment") >>~ pushContext "Commentar 2")-                        <|>-                        ((pAnyChar ":!%&()+,-/.*<=>?[]|~^;" >>= withAttribute "Symbol")))-     return (attr, result)+parseRules "Normal" =+  (((pDetectSpaces >>= withAttribute NormalTok))+   <|>+   ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2aif'5cs'2b0'5cs'2a'24 >>= withAttribute OtherTok) >>~ pushContext "Outscoped")+   <|>+   ((pFirstNonSpace >> lookAhead (pDetectChar False '#') >> return (NormalTok,"") ) >>~ pushContext "AfterHash")+   <|>+   ((pFirstNonSpace >> pString False "//BEGIN" >>= withAttribute RegionMarkerTok) >>~ pushContext "Region Marker")+   <|>+   ((pFirstNonSpace >> pString False "//END" >>= withAttribute RegionMarkerTok) >>~ pushContext "Region Marker")+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\'\"" list_keywords >>= withAttribute KeywordTok))+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\'\"" list_types >>= withAttribute DataTypeTok))+   <|>+   ((pDetectIdentifier >>= withAttribute NormalTok))+   <|>+   ((pDetectChar False '{' >>= withAttribute NormalTok))+   <|>+   ((pDetectChar False '}' >>= withAttribute NormalTok))+   <|>+   (withChildren (pFloat >>= withAttribute FloatTok) ((pAnyChar "fF" >>= withAttribute FloatTok)))+   <|>+   ((pHlCOct >>= withAttribute BaseNTok))+   <|>+   ((pHlCHex >>= withAttribute BaseNTok))+   <|>+   (withChildren (pInt >>= withAttribute DecValTok) (((pString False "ULL" >>= withAttribute DecValTok))+                                                     <|>+                                                     ((pString False "LUL" >>= withAttribute DecValTok))+                                                     <|>+                                                     ((pString False "LLU" >>= withAttribute DecValTok))+                                                     <|>+                                                     ((pString False "UL" >>= withAttribute DecValTok))+                                                     <|>+                                                     ((pString False "LU" >>= withAttribute DecValTok))+                                                     <|>+                                                     ((pString False "LL" >>= withAttribute DecValTok))+                                                     <|>+                                                     ((pString False "U" >>= withAttribute DecValTok))+                                                     <|>+                                                     ((pString False "L" >>= withAttribute DecValTok))))+   <|>+   ((pHlCChar >>= withAttribute CharTok))+   <|>+   ((pDetectChar False '"' >>= withAttribute StringTok) >>~ pushContext "String")+   <|>+   ((Text.Highlighting.Kate.Syntax.Doxygen.parseExpression))+   <|>+   ((pDetect2Chars False '/' '/' >>= withAttribute CommentTok) >>~ pushContext "Commentar 1")+   <|>+   ((pDetect2Chars False '/' '*' >>= withAttribute CommentTok) >>~ pushContext "Commentar 2")+   <|>+   ((pAnyChar ":!%&()+,-/.*<=>?[]|~^;" >>= withAttribute NormalTok))) -parseRules "String" = -  do (attr, result) <- (((pLineContinue >>= withAttribute "String"))-                        <|>-                        ((pHlCStringChar >>= withAttribute "String Char"))-                        <|>-                        ((pDetectChar False '"' >>= withAttribute "String") >>~ (popContext)))-     return (attr, result)+parseRules "String" =+  (((pLineContinue >>= withAttribute StringTok))+   <|>+   ((pHlCStringChar >>= withAttribute CharTok))+   <|>+   ((pDetectChar False '"' >>= withAttribute StringTok) >>~ (popContext))) -parseRules "Region Marker" = +parseRules "Region Marker" =   pzero -parseRules "Commentar 1" = -  do (attr, result) <- (((pLineContinue >>= withAttribute "Comment"))-                        <|>-                        ((Text.Highlighting.Kate.Syntax.Alert.parseExpression)))-     return (attr, result)+parseRules "Commentar 1" =+  (((pLineContinue >>= withAttribute CommentTok))+   <|>+   ((Text.Highlighting.Kate.Syntax.Alert.parseExpression >>= ((withAttribute CommentTok) . snd)))) -parseRules "Commentar 2" = -  do (attr, result) <- (((pDetect2Chars False '*' '/' >>= withAttribute "Comment") >>~ (popContext))-                        <|>-                        ((Text.Highlighting.Kate.Syntax.Alert.parseExpression)))-     return (attr, result)+parseRules "Commentar 2" =+  (((pDetect2Chars False '*' '/' >>= withAttribute CommentTok) >>~ (popContext))+   <|>+   ((Text.Highlighting.Kate.Syntax.Alert.parseExpression >>= ((withAttribute CommentTok) . snd)))) -parseRules "AfterHash" = -  do (attr, result) <- (((pFirstNonSpace >> pRegExpr regex_'23'5cs'2aif'28'3f'3adef'7cndef'29'3f'28'3f'3d'5cs'2b'5cS'29 >>= withAttribute "Preprocessor") >>~ pushContext "Preprocessor")-                        <|>-                        ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2aendif >>= withAttribute "Preprocessor") >>~ pushContext "Preprocessor")-                        <|>-                        ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2adefine'2e'2a'28'28'3f'3d'5c'5c'29'29 >>= withAttribute "Preprocessor") >>~ pushContext "Define")-                        <|>-                        ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2a'28'3f'3ael'28'3f'3ase'7cif'29'7cinclude'28'3f'3a'5fnext'29'3f'7cdefine'7cundef'7cline'7cerror'7cwarning'7cpragma'29 >>= withAttribute "Preprocessor") >>~ pushContext "Preprocessor")-                        <|>-                        ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2b'5b0'2d9'5d'2b >>= withAttribute "Preprocessor") >>~ pushContext "Preprocessor"))-     return (attr, result)+parseRules "AfterHash" =+  (((pFirstNonSpace >> pRegExpr regex_'23'5cs'2aif'28'3f'3adef'7cndef'29'3f'28'3f'3d'5cs'2b'5cS'29 >>= withAttribute OtherTok) >>~ pushContext "Preprocessor")+   <|>+   ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2aendif >>= withAttribute OtherTok) >>~ pushContext "Preprocessor")+   <|>+   ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2adefine'2e'2a'28'28'3f'3d'5c'5c'29'29 >>= withAttribute OtherTok) >>~ pushContext "Define")+   <|>+   ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2a'28'3f'3ael'28'3f'3ase'7cif'29'7cinclude'28'3f'3a'5fnext'29'3f'7cdefine'7cundef'7cline'7cerror'7cwarning'7cpragma'29 >>= withAttribute OtherTok) >>~ pushContext "Preprocessor")+   <|>+   ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2b'5b0'2d9'5d'2b >>= withAttribute OtherTok) >>~ pushContext "Preprocessor")) -parseRules "Preprocessor" = -  do (attr, result) <- (((pLineContinue >>= withAttribute "Preprocessor"))-                        <|>-                        ((pRangeDetect '"' '"' >>= withAttribute "Prep. Lib"))-                        <|>-                        ((pRangeDetect '<' '>' >>= withAttribute "Prep. Lib"))-                        <|>-                        ((Text.Highlighting.Kate.Syntax.Doxygen.parseExpression))-                        <|>-                        ((pDetect2Chars False '/' '*' >>= withAttribute "Comment") >>~ pushContext "Commentar/Preprocessor"))-     return (attr, result)+parseRules "Preprocessor" =+  (((pLineContinue >>= withAttribute OtherTok))+   <|>+   ((pRangeDetect '"' '"' >>= withAttribute OtherTok))+   <|>+   ((pRangeDetect '<' '>' >>= withAttribute OtherTok))+   <|>+   ((Text.Highlighting.Kate.Syntax.Doxygen.parseExpression >>= ((withAttribute OtherTok) . snd)))+   <|>+   ((pDetect2Chars False '/' '*' >>= withAttribute CommentTok) >>~ pushContext "Commentar/Preprocessor")) -parseRules "Define" = -  do (attr, result) <- ((pLineContinue >>= withAttribute "Preprocessor"))-     return (attr, result)+parseRules "Define" =+  ((pLineContinue >>= withAttribute OtherTok)) -parseRules "Commentar/Preprocessor" = -  do (attr, result) <- ((pDetect2Chars False '*' '/' >>= withAttribute "Comment") >>~ (popContext))-     return (attr, result)+parseRules "Commentar/Preprocessor" =+  ((pDetect2Chars False '*' '/' >>= withAttribute CommentTok) >>~ (popContext)) -parseRules "Outscoped" = -  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Comment"))-                        <|>-                        ((Text.Highlighting.Kate.Syntax.Alert.parseExpression))-                        <|>-                        ((pDetectIdentifier >>= withAttribute "Comment"))-                        <|>-                        ((pDetectChar False '"' >>= withAttribute "String") >>~ pushContext "String")-                        <|>-                        ((Text.Highlighting.Kate.Syntax.Doxygen.parseExpression))-                        <|>-                        ((pDetect2Chars False '/' '/' >>= withAttribute "Comment") >>~ pushContext "Commentar 1")-                        <|>-                        ((pDetect2Chars False '/' '*' >>= withAttribute "Comment") >>~ pushContext "Commentar 2")-                        <|>-                        ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2aif >>= withAttribute "Comment") >>~ pushContext "Outscoped intern")-                        <|>-                        ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2ael'28'3f'3ase'7cif'29 >>= withAttribute "Preprocessor") >>~ (popContext))-                        <|>-                        ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2aendif >>= withAttribute "Preprocessor") >>~ (popContext)))-     return (attr, result)+parseRules "Outscoped" =+  (((pDetectSpaces >>= withAttribute CommentTok))+   <|>+   ((Text.Highlighting.Kate.Syntax.Alert.parseExpression >>= ((withAttribute CommentTok) . snd)))+   <|>+   ((pDetectIdentifier >>= withAttribute CommentTok))+   <|>+   ((pDetectChar False '"' >>= withAttribute StringTok) >>~ pushContext "String")+   <|>+   ((Text.Highlighting.Kate.Syntax.Doxygen.parseExpression >>= ((withAttribute CommentTok) . snd)))+   <|>+   ((pDetect2Chars False '/' '/' >>= withAttribute CommentTok) >>~ pushContext "Commentar 1")+   <|>+   ((pDetect2Chars False '/' '*' >>= withAttribute CommentTok) >>~ pushContext "Commentar 2")+   <|>+   ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2aif >>= withAttribute CommentTok) >>~ pushContext "Outscoped intern")+   <|>+   ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2ael'28'3f'3ase'7cif'29 >>= withAttribute OtherTok) >>~ (popContext))+   <|>+   ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2aendif >>= withAttribute OtherTok) >>~ (popContext))) -parseRules "Outscoped intern" = -  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Comment"))-                        <|>-                        ((Text.Highlighting.Kate.Syntax.Alert.parseExpression))-                        <|>-                        ((pDetectIdentifier >>= withAttribute "Comment"))-                        <|>-                        ((pDetectChar False '"' >>= withAttribute "String") >>~ pushContext "String")-                        <|>-                        ((Text.Highlighting.Kate.Syntax.Doxygen.parseExpression))-                        <|>-                        ((pDetect2Chars False '/' '/' >>= withAttribute "Comment") >>~ pushContext "Commentar 1")-                        <|>-                        ((pDetect2Chars False '/' '*' >>= withAttribute "Comment") >>~ pushContext "Commentar 2")-                        <|>-                        ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2aif >>= withAttribute "Comment") >>~ pushContext "Outscoped intern")-                        <|>-                        ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2aendif >>= withAttribute "Comment") >>~ (popContext)))-     return (attr, result)+parseRules "Outscoped intern" =+  (((pDetectSpaces >>= withAttribute CommentTok))+   <|>+   ((Text.Highlighting.Kate.Syntax.Alert.parseExpression >>= ((withAttribute CommentTok) . snd)))+   <|>+   ((pDetectIdentifier >>= withAttribute CommentTok))+   <|>+   ((pDetectChar False '"' >>= withAttribute StringTok) >>~ pushContext "String")+   <|>+   ((Text.Highlighting.Kate.Syntax.Doxygen.parseExpression >>= ((withAttribute CommentTok) . snd)))+   <|>+   ((pDetect2Chars False '/' '/' >>= withAttribute CommentTok) >>~ pushContext "Commentar 1")+   <|>+   ((pDetect2Chars False '/' '*' >>= withAttribute CommentTok) >>~ pushContext "Commentar 2")+   <|>+   ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2aif >>= withAttribute CommentTok) >>~ pushContext "Outscoped intern")+   <|>+   ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2aendif >>= withAttribute CommentTok) >>~ (popContext)))  parseRules "" = parseRules "Normal" 

@@ -1,13 +1,16 @@-{- This module was generated from data in the Kate syntax highlighting file changelog.xml, version 1.04,-   by  Dominik Haumann (dhdev@gmx.de) -}+{- This module was generated from data in the Kate syntax+   highlighting file changelog.xml, version 1.04, by Dominik Haumann (dhdev@gmx.de) -} -module Text.Highlighting.Kate.Syntax.Changelog ( highlight, parseExpression, syntaxName, syntaxExtensions ) where-import Text.Highlighting.Kate.Definitions+module Text.Highlighting.Kate.Syntax.Changelog+          (highlight, parseExpression, syntaxName, syntaxExtensions)+where+import Text.Highlighting.Kate.Types import Text.Highlighting.Kate.Common-import Text.ParserCombinators.Parsec-import Control.Monad (when)+import Text.ParserCombinators.Parsec hiding (State) import Data.Map (fromList)-import Data.Maybe (fromMaybe, maybeToList)+import Control.Monad.State+import Data.Char (isSpace)+import Data.Maybe (fromMaybe)  -- | Full name of language. syntaxName :: String@@ -18,56 +21,43 @@ syntaxExtensions = "ChangeLog"  -- | Highlight source code using this syntax definition.-highlight :: String -> Either String [SourceLine]-highlight input =-  case runParser parseSource startingState "source" input of-    Left err     -> Left $ show err-    Right result -> Right result+highlight :: String -> [SourceLine]+highlight input = evalState (mapM parseSourceLine $ lines input) startingState +parseSourceLine :: String -> State SyntaxState SourceLine+parseSourceLine = mkParseSourceLine parseExpressionInternal pEndLine+ -- | Parse an expression using appropriate local context.-parseExpression :: GenParser Char SyntaxState LabeledSource+parseExpression :: KateParser Token parseExpression = do   st <- getState   let oldLang = synStLanguage st   setState $ st { synStLanguage = "ChangeLog" }   context <- currentContext <|> (pushContext "Normal" >> currentContext)   result <- parseRules context+  optional $ eof >> pEndLine   updateState $ \st -> st { synStLanguage = oldLang }   return result -parseSource = do -  lineContents <- lookAhead wholeLine-  updateState $ \st -> st { synStCurrentLine = lineContents }-  result <- manyTill parseSourceLine eof-  return $ map normalizeHighlighting result--startingState = SyntaxState {synStContexts = fromList [("ChangeLog",["Normal"])], synStLanguage = "ChangeLog", synStCurrentLine = "", synStCharsParsedInLine = 0, synStPrevChar = '\n', synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}--parseSourceLine = manyTill parseExpressionInternal pEndLine+startingState = SyntaxState {synStContexts = fromList [("ChangeLog",["Normal"])], synStLanguage = "ChangeLog", synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do-  lookAhead $ newline <|> (eof >> return '\n')   context <- currentContext   case context of-    "Normal" -> return () >> pHandleEndLine+    "Normal" -> return ()     "line" -> (popContext) >> pEndLine     "entry" -> (popContext) >> pEndLine-    _ -> pHandleEndLine+    _ -> return ()  withAttribute attr txt = do   when (null txt) $ fail "Parser matched no text"-  let labs = attr : maybeToList (lookup attr styles)-  st <- getState-  let oldCharsParsed = synStCharsParsedInLine st-  let prevchar = if null txt then '\n' else last txt-  updateState $ \st -> st { synStCharsParsedInLine = oldCharsParsed + length txt, synStPrevChar = prevchar } -  return (labs, txt)--styles = [("Name","kw"),("E-Mail","ot"),("Date","dt"),("Entry","dv")]+  updateState $ \st -> st { synStPrevChar = last txt+                          , synStPrevNonspace = synStPrevNonspace st || not (all isSpace txt) }+  return (attr, txt)  parseExpressionInternal = do   context <- currentContext-  parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes))+  parseRules context <|> (pDefault >>= withAttribute (fromMaybe NormalTok $ lookup context defaultAttributes))   regex_'5cd'5cd'5cd'5cd'5cs'2a'2d'5cs'2a'5cd'5cd'5cs'2a'2d'5cs'2a'5cd'5cd'5cs'2a = compileRegex "\\d\\d\\d\\d\\s*-\\s*\\d\\d\\s*-\\s*\\d\\d\\s*"@@ -75,23 +65,20 @@ regex_'3c'2e'2a'3e'5cs'2a'24 = compileRegex "<.*>\\s*$" regex_'2e'2a'3a = compileRegex ".*:" -defaultAttributes = [("Normal","Normal Text"),("line","Normal Text"),("entry","Normal Text")]+defaultAttributes = [("Normal",NormalTok),("line",NormalTok),("entry",NormalTok)] -parseRules "Normal" = -  do (attr, result) <- (((pFirstNonSpace >> pDetectChar False '*' >>= withAttribute "Entry") >>~ pushContext "entry")-                        <|>-                        ((pColumn 0 >> pRegExpr regex_'5cd'5cd'5cd'5cd'5cs'2a'2d'5cs'2a'5cd'5cd'5cs'2a'2d'5cs'2a'5cd'5cd'5cs'2a >>= withAttribute "Date") >>~ pushContext "line"))-     return (attr, result)+parseRules "Normal" =+  (((pFirstNonSpace >> pDetectChar False '*' >>= withAttribute DecValTok) >>~ pushContext "entry")+   <|>+   ((pColumn 0 >> pRegExpr regex_'5cd'5cd'5cd'5cd'5cs'2a'2d'5cs'2a'5cd'5cd'5cs'2a'2d'5cs'2a'5cd'5cd'5cs'2a >>= withAttribute DataTypeTok) >>~ pushContext "line")) -parseRules "line" = -  do (attr, result) <- (((pRegExpr regex_'28'5cw'5cs'2a'29'2b >>= withAttribute "Name"))-                        <|>-                        ((pRegExpr regex_'3c'2e'2a'3e'5cs'2a'24 >>= withAttribute "E-Mail") >>~ (popContext)))-     return (attr, result)+parseRules "line" =+  (((pRegExpr regex_'28'5cw'5cs'2a'29'2b >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'3c'2e'2a'3e'5cs'2a'24 >>= withAttribute OtherTok) >>~ (popContext))) -parseRules "entry" = -  do (attr, result) <- ((pRegExpr regex_'2e'2a'3a >>= withAttribute "Entry") >>~ (popContext))-     return (attr, result)+parseRules "entry" =+  ((pRegExpr regex_'2e'2a'3a >>= withAttribute DecValTok) >>~ (popContext))  parseRules "" = parseRules "Normal" 

@@ -1,15 +1,18 @@-{- This module was generated from data in the Kate syntax highlighting file clojure.xml, version 1.05,-   by  Dominik Haumann (dhdev@gmx.de) -}+{- This module was generated from data in the Kate syntax+   highlighting file clojure.xml, version 1.05, by Dominik Haumann (dhdev@gmx.de) -} -module Text.Highlighting.Kate.Syntax.Clojure ( highlight, parseExpression, syntaxName, syntaxExtensions ) where-import Text.Highlighting.Kate.Definitions+module Text.Highlighting.Kate.Syntax.Clojure+          (highlight, parseExpression, syntaxName, syntaxExtensions)+where+import Text.Highlighting.Kate.Types import Text.Highlighting.Kate.Common-import Text.ParserCombinators.Parsec-import Control.Monad (when)+import Text.ParserCombinators.Parsec hiding (State) import Data.Map (fromList)-import Data.Maybe (fromMaybe, maybeToList)-+import Control.Monad.State+import Data.Char (isSpace)+import Data.Maybe (fromMaybe) import qualified Data.Set as Set+ -- | Full name of language. syntaxName :: String syntaxName = "Clojure"@@ -19,57 +22,44 @@ syntaxExtensions = "*.clj"  -- | Highlight source code using this syntax definition.-highlight :: String -> Either String [SourceLine]-highlight input =-  case runParser parseSource startingState "source" input of-    Left err     -> Left $ show err-    Right result -> Right result+highlight :: String -> [SourceLine]+highlight input = evalState (mapM parseSourceLine $ lines input) startingState +parseSourceLine :: String -> State SyntaxState SourceLine+parseSourceLine = mkParseSourceLine parseExpressionInternal pEndLine+ -- | Parse an expression using appropriate local context.-parseExpression :: GenParser Char SyntaxState LabeledSource+parseExpression :: KateParser Token parseExpression = do   st <- getState   let oldLang = synStLanguage st   setState $ st { synStLanguage = "Clojure" }   context <- currentContext <|> (pushContext "Normal" >> currentContext)   result <- parseRules context+  optional $ eof >> pEndLine   updateState $ \st -> st { synStLanguage = oldLang }   return result -parseSource = do -  lineContents <- lookAhead wholeLine-  updateState $ \st -> st { synStCurrentLine = lineContents }-  result <- manyTill parseSourceLine eof-  return $ map normalizeHighlighting result--startingState = SyntaxState {synStContexts = fromList [("Clojure",["Normal"])], synStLanguage = "Clojure", synStCurrentLine = "", synStCharsParsedInLine = 0, synStPrevChar = '\n', synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}--parseSourceLine = manyTill parseExpressionInternal pEndLine+startingState = SyntaxState {synStContexts = fromList [("Clojure",["Normal"])], synStLanguage = "Clojure", synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do-  lookAhead $ newline <|> (eof >> return '\n')   context <- currentContext   case context of-    "Normal" -> return () >> pHandleEndLine-    "function_decl" -> return () >> pHandleEndLine+    "Normal" -> return ()+    "function_decl" -> return ()     "SpecialNumber" -> (popContext) >> pEndLine-    "String" -> return () >> pHandleEndLine-    _ -> pHandleEndLine+    "String" -> return ()+    _ -> return ()  withAttribute attr txt = do   when (null txt) $ fail "Parser matched no text"-  let labs = attr : maybeToList (lookup attr styles)-  st <- getState-  let oldCharsParsed = synStCharsParsedInLine st-  let prevchar = if null txt then '\n' else last txt-  updateState $ \st -> st { synStCharsParsedInLine = oldCharsParsed + length txt, synStPrevChar = prevchar } -  return (labs, txt)--styles = [("Keyword","kw"),("Operator","kw"),("Modifier","kw"),("Variable","kw"),("Definition","kw"),("Data","dt"),("Decimal","dv"),("BaseN","bn"),("Float","fl"),("Function","fu"),("Char","ch"),("String","st"),("Comment","co"),("Region Marker","re")]+  updateState $ \st -> st { synStPrevChar = last txt+                          , synStPrevNonspace = synStPrevNonspace st || not (all isSpace txt) }+  return (attr, txt)  parseExpressionInternal = do   context <- currentContext-  parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes))+  parseRules context <|> (pDefault >>= withAttribute (fromMaybe NormalTok $ lookup context defaultAttributes))  list_definitions = Set.fromList $ words $ "def def- defalias defhinted definline defmacro defmacro- defmethod defmulti defn defn- defnk defn-memo defonce defonce- defprotocol defrecord defstruct defstruct- deftest deftest- deftype defunbound defunbound- defvar defvar-" list_keywords = Set.fromList $ words $ "< <= = == > >= - -> ->> / . .. * + 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! associative? assoc-in atom atom? attrs await await1 await-for 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? char-array char-escape-string char-name-string chars children chunk chunk-append chunk-buffer chunk-cons chunked-seq? chunk-first chunk-next chunk-rest 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 doall doc dorun doseq dosync do-template 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 extenders extend-protocol extends? extend-type false? ffirst file-position file-seq filter finally find find-doc find-ns find-var first float float? float-array floats flush fn fn? fnext for force format function? future future? future-call future-cancel future-cancelled? future-done? 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 ifn? if-not import inc inc-report-counter index init-proxy in-ns 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 isa? is-leaf 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? list-model list-provider load loaded-libs load-file load-reader load-script load-string locking long long-array longs loop macroexpand macroexpand-1 macroexpand-all main make-array make-hierarchy make-node map map? mapcat map-invert max max-key memfn memoize merge merge-with meta methods method-sig min min-key mod name namespace neg? newline next nfirst nil? nnext node not not= not-any? not-empty not-every? 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 prefer-method prefers prev prewalk prewalk-demo prewalk-replace primitives-classnames print print-cause-trace print-ctor print-doc print-dup printf println println-str print-method print-namespace-doc print-simple print-special-doc print-stack-trace print-str print-throwable print-trace-element prn prn-str project promise proxy proxy-call-with-super proxy-mappings proxy-name proxy-super pr-str push-thread-bindings pvalues quot rand rand-int range ratio? rational? rationalize read read-line read-string recur reduce ref refer refer-clojure ref-history-count re-find ref-max-history ref-min-history ref-set re-groups reify release-pending-sends rem re-matcher re-matches remove remove-method remove-ns remove-watcher rename rename-keys re-pattern repeat repeatedly repl replace repl-caught repl-exception replicate repl-prompt repl-read report require re-seq 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? seque sequence sequential? seq-zip set set? set-test set-validator! short short-array shorts shutdown-agents skip-if-eol skip-whitespace slurp some sort sort-by sorted? sorted-map sorted-map-by sorted-set sorted-set-by 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 testing testing-contexts-str testing-vars-str test-ns test-var 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? var-get var-set 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"@@ -82,75 +72,71 @@ regex_'5cs'2a'5bA'2dZa'2dz0'2d9'2d'2b'5c'3c'5c'3e'2f'2f'5c'2a'5d'2a'5cs'2a = compileRegex "\\s*[A-Za-z0-9-+\\<\\>//\\*]*\\s*" regex_'23'5c'5c'2e = compileRegex "#\\\\." -defaultAttributes = [("Normal","Normal"),("function_decl","Function"),("SpecialNumber","Normal"),("String","String")]+defaultAttributes = [("Normal",NormalTok),("function_decl",FunctionTok),("SpecialNumber",NormalTok),("String",StringTok)] -parseRules "Normal" = -  do (attr, result) <- (((pRegExpr regex_'3b'2e'2a'24 >>= withAttribute "Comment"))-                        <|>-                        ((pDetect2Chars False '#' '_' >>= withAttribute "Comment"))-                        <|>-                        ((pRegExpr regex_'3a'5cS'2b >>= withAttribute "Modifier"))-                        <|>-                        ((pRegExpr regex_'5b'40'7e'5d'5cS'2b >>= withAttribute "Modifier"))-                        <|>-                        ((pDetect2Chars False '#' '(' >>= withAttribute "Brackets"))-                        <|>-                        ((pDetectChar False '(' >>= withAttribute "Brackets"))-                        <|>-                        ((pDetectChar False ')' >>= withAttribute "Brackets"))-                        <|>-                        ((pDetect2Chars False '#' '{' >>= withAttribute "Brackets"))-                        <|>-                        ((pDetect2Chars False '^' '{' >>= withAttribute "Brackets"))-                        <|>-                        ((pDetectChar False '{' >>= withAttribute "Brackets"))-                        <|>-                        ((pDetectChar False '}' >>= withAttribute "Brackets"))-                        <|>-                        ((pDetectChar False '[' >>= withAttribute "Brackets"))-                        <|>-                        ((pDetectChar False ']' >>= withAttribute "Brackets"))-                        <|>-                        ((pDetect2Chars False '#' '\'' >>= withAttribute "Variable"))-                        <|>-                        ((pKeyword " \n\t.(),%&;[]^{|}~" list_keywords >>= withAttribute "Keyword"))-                        <|>-                        ((pKeyword " \n\t.(),%&;[]^{|}~" list_variables >>= withAttribute "Variable"))-                        <|>-                        ((pKeyword " \n\t.(),%&;[]^{|}~" list_definitions >>= withAttribute "Definition") >>~ pushContext "function_decl")-                        <|>-                        ((pRegExpr regex_'5c'5c'2e >>= withAttribute "Char"))-                        <|>-                        ((pDetect2Chars False '#' '"' >>= withAttribute "String") >>~ pushContext "String")-                        <|>-                        ((pDetectChar False '"' >>= withAttribute "String") >>~ pushContext "String")-                        <|>-                        ((pFloat >>= withAttribute "Float"))-                        <|>-                        ((pInt >>= withAttribute "Decimal")))-     return (attr, result)+parseRules "Normal" =+  (((pRegExpr regex_'3b'2e'2a'24 >>= withAttribute CommentTok))+   <|>+   ((pDetect2Chars False '#' '_' >>= withAttribute CommentTok))+   <|>+   ((pRegExpr regex_'3a'5cS'2b >>= withAttribute KeywordTok))+   <|>+   ((pRegExpr regex_'5b'40'7e'5d'5cS'2b >>= withAttribute KeywordTok))+   <|>+   ((pDetect2Chars False '#' '(' >>= withAttribute NormalTok))+   <|>+   ((pDetectChar False '(' >>= withAttribute NormalTok))+   <|>+   ((pDetectChar False ')' >>= withAttribute NormalTok))+   <|>+   ((pDetect2Chars False '#' '{' >>= withAttribute NormalTok))+   <|>+   ((pDetect2Chars False '^' '{' >>= withAttribute NormalTok))+   <|>+   ((pDetectChar False '{' >>= withAttribute NormalTok))+   <|>+   ((pDetectChar False '}' >>= withAttribute NormalTok))+   <|>+   ((pDetectChar False '[' >>= withAttribute NormalTok))+   <|>+   ((pDetectChar False ']' >>= withAttribute NormalTok))+   <|>+   ((pDetect2Chars False '#' '\'' >>= withAttribute KeywordTok))+   <|>+   ((pKeyword " \n\t.(),%&;[]^{|}~" list_keywords >>= withAttribute KeywordTok))+   <|>+   ((pKeyword " \n\t.(),%&;[]^{|}~" list_variables >>= withAttribute KeywordTok))+   <|>+   ((pKeyword " \n\t.(),%&;[]^{|}~" list_definitions >>= withAttribute KeywordTok) >>~ pushContext "function_decl")+   <|>+   ((pRegExpr regex_'5c'5c'2e >>= withAttribute CharTok))+   <|>+   ((pDetect2Chars False '#' '"' >>= withAttribute StringTok) >>~ pushContext "String")+   <|>+   ((pDetectChar False '"' >>= withAttribute StringTok) >>~ pushContext "String")+   <|>+   ((pFloat >>= withAttribute FloatTok))+   <|>+   ((pInt >>= withAttribute DecValTok))) -parseRules "function_decl" = -  do (attr, result) <- ((pRegExpr regex_'5cs'2a'5bA'2dZa'2dz0'2d9'2d'2b'5c'3c'5c'3e'2f'2f'5c'2a'5d'2a'5cs'2a >>= withAttribute "Function") >>~ (popContext))-     return (attr, result)+parseRules "function_decl" =+  ((pRegExpr regex_'5cs'2a'5bA'2dZa'2dz0'2d9'2d'2b'5c'3c'5c'3e'2f'2f'5c'2a'5d'2a'5cs'2a >>= withAttribute FunctionTok) >>~ (popContext)) -parseRules "SpecialNumber" = -  do (attr, result) <- (((pFloat >>= withAttribute "Float") >>~ (popContext))-                        <|>-                        ((pInt >>= withAttribute "Decimal") >>~ (popContext))-                        <|>-                        ((pHlCOct >>= withAttribute "BaseN") >>~ (popContext))-                        <|>-                        ((pHlCHex >>= withAttribute "Float") >>~ (popContext)))-     return (attr, result)+parseRules "SpecialNumber" =+  (((pFloat >>= withAttribute FloatTok) >>~ (popContext))+   <|>+   ((pInt >>= withAttribute DecValTok) >>~ (popContext))+   <|>+   ((pHlCOct >>= withAttribute BaseNTok) >>~ (popContext))+   <|>+   ((pHlCHex >>= withAttribute FloatTok) >>~ (popContext))) -parseRules "String" = -  do (attr, result) <- (((pRegExpr regex_'23'5c'5c'2e >>= withAttribute "Char"))-                        <|>-                        ((pHlCStringChar >>= withAttribute "String Char"))-                        <|>-                        ((pDetectChar False '"' >>= withAttribute "String") >>~ (popContext)))-     return (attr, result)+parseRules "String" =+  (((pRegExpr regex_'23'5c'5c'2e >>= withAttribute CharTok))+   <|>+   ((pHlCStringChar >>= withAttribute NormalTok))+   <|>+   ((pDetectChar False '"' >>= withAttribute StringTok) >>~ (popContext)))  parseRules "" = parseRules "Normal" 

@@ -1,16 +1,19 @@-{- This module was generated from data in the Kate syntax highlighting file cmake.xml, version 1.13,-   by  Alexander Neundorf (neundorf@kde.org) -}+{- This module was generated from data in the Kate syntax+   highlighting file cmake.xml, version 1.13, by Alexander Neundorf (neundorf@kde.org) -} -module Text.Highlighting.Kate.Syntax.Cmake ( highlight, parseExpression, syntaxName, syntaxExtensions ) where-import Text.Highlighting.Kate.Definitions+module Text.Highlighting.Kate.Syntax.Cmake+          (highlight, parseExpression, syntaxName, syntaxExtensions)+where+import Text.Highlighting.Kate.Types import Text.Highlighting.Kate.Common import qualified Text.Highlighting.Kate.Syntax.Alert-import Text.ParserCombinators.Parsec-import Control.Monad (when)+import Text.ParserCombinators.Parsec hiding (State) import Data.Map (fromList)-import Data.Maybe (fromMaybe, maybeToList)-+import Control.Monad.State+import Data.Char (isSpace)+import Data.Maybe (fromMaybe) import qualified Data.Set as Set+ -- | Full name of language. syntaxName :: String syntaxName = "CMake"@@ -20,59 +23,46 @@ syntaxExtensions = "CMakeLists.txt;*.cmake;"  -- | Highlight source code using this syntax definition.-highlight :: String -> Either String [SourceLine]-highlight input =-  case runParser parseSource startingState "source" input of-    Left err     -> Left $ show err-    Right result -> Right result+highlight :: String -> [SourceLine]+highlight input = evalState (mapM parseSourceLine $ lines input) startingState +parseSourceLine :: String -> State SyntaxState SourceLine+parseSourceLine = mkParseSourceLine parseExpressionInternal pEndLine+ -- | Parse an expression using appropriate local context.-parseExpression :: GenParser Char SyntaxState LabeledSource+parseExpression :: KateParser Token parseExpression = do   st <- getState   let oldLang = synStLanguage st   setState $ st { synStLanguage = "CMake" }   context <- currentContext <|> (pushContext "Normal Text" >> currentContext)   result <- parseRules context+  optional $ eof >> pEndLine   updateState $ \st -> st { synStLanguage = oldLang }   return result -parseSource = do -  lineContents <- lookAhead wholeLine-  updateState $ \st -> st { synStCurrentLine = lineContents }-  result <- manyTill parseSourceLine eof-  return $ map normalizeHighlighting result--startingState = SyntaxState {synStContexts = fromList [("CMake",["Normal Text"])], synStLanguage = "CMake", synStCurrentLine = "", synStCharsParsedInLine = 0, synStPrevChar = '\n', synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}--parseSourceLine = manyTill parseExpressionInternal pEndLine+startingState = SyntaxState {synStContexts = fromList [("CMake",["Normal Text"])], synStLanguage = "CMake", synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do-  lookAhead $ newline <|> (eof >> return '\n')   context <- currentContext   case context of-    "Normal Text" -> return () >> pHandleEndLine-    "Detect Variables" -> return () >> pHandleEndLine-    "Command Args" -> return () >> pHandleEndLine-    "Macro Args" -> return () >> pHandleEndLine+    "Normal Text" -> return ()+    "Detect Variables" -> return ()+    "Command Args" -> return ()+    "Macro Args" -> return ()     "Comment" -> (popContext) >> pEndLine-    "String" -> return () >> pHandleEndLine-    _ -> pHandleEndLine+    "String" -> return ()+    _ -> return ()  withAttribute attr txt = do   when (null txt) $ fail "Parser matched no text"-  let labs = attr : maybeToList (lookup attr styles)-  st <- getState-  let oldCharsParsed = synStCharsParsedInLine st-  let prevchar = if null txt then '\n' else last txt-  updateState $ \st -> st { synStCharsParsedInLine = oldCharsParsed + length txt, synStPrevChar = prevchar } -  return (labs, txt)--styles = [("Special Args","ot"),("Properties","ot"),("Commands","kw"),("Third-Party Commands","fu"),("Macros","fu"),("Strings","st"),("Escapes","ch"),("CMake Variable","dv"),("Environment Variable","fl"),("Comment","co"),("Region Marker","re")]+  updateState $ \st -> st { synStPrevChar = last txt+                          , synStPrevNonspace = synStPrevNonspace st || not (all isSpace txt) }+  return (attr, txt)  parseExpressionInternal = do   context <- currentContext-  parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes))+  parseRules context <|> (pDefault >>= withAttribute (fromMaybe NormalTok $ lookup context defaultAttributes))  list_commands = Set.fromList $ words $ "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_minimum_required cmake_policy configure_file create_test_sourcelist 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_link_libraries try_compile try_run unset use_mangled_mesa utility_source variable_requires variable_watch while write_file" list_itkvtk'5fcommands = Set.fromList $ words $ "itk_wrap_tcl vtk_make_instantiator vtk_wrap_java vtk_wrap_python vtk_wrap_tcl"@@ -90,67 +80,61 @@ regex_'22'28'3f'3d'5b_'29'3b'5d'7c'24'29 = compileRegex "\"(?=[ );]|$)" regex_'5c'5c'5b'22'24n'5c'5c'5d = compileRegex "\\\\[\"$n\\\\]" -defaultAttributes = [("Normal Text","Normal Text"),("Detect Variables","Normal Text"),("Command Args","Normal Text"),("Macro Args","Normal Text"),("Comment","Comment"),("String","Strings")]+defaultAttributes = [("Normal Text",NormalTok),("Detect Variables",NormalTok),("Command Args",NormalTok),("Macro Args",NormalTok),("Comment",CommentTok),("String",StringTok)] -parseRules "Normal Text" = -  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Normal Text"))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_commands >>= withAttribute "Commands") >>~ pushContext "Command Args")-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_itkvtk'5fcommands >>= withAttribute "Third-Party Commands"))-                        <|>-                        ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2aBEGIN'2e'2a'24 >>= withAttribute "Region Marker"))-                        <|>-                        ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2aEND'2e'2a'24 >>= withAttribute "Region Marker"))-                        <|>-                        ((pDetectChar False '#' >>= withAttribute "Comment") >>~ pushContext "Comment")-                        <|>-                        ((parseRules "Detect Variables"))-                        <|>-                        ((pRegExpr regex_'5cw'2b'5cs'2a'28'3f'3d'5c'28'29 >>= withAttribute "Macros") >>~ pushContext "Macro Args"))-     return (attr, result)+parseRules "Normal Text" =+  (((pDetectSpaces >>= withAttribute NormalTok))+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_commands >>= withAttribute KeywordTok) >>~ pushContext "Command Args")+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_itkvtk'5fcommands >>= withAttribute FunctionTok))+   <|>+   ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2aBEGIN'2e'2a'24 >>= withAttribute RegionMarkerTok))+   <|>+   ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2aEND'2e'2a'24 >>= withAttribute RegionMarkerTok))+   <|>+   ((pDetectChar False '#' >>= withAttribute CommentTok) >>~ pushContext "Comment")+   <|>+   ((parseRules "Detect Variables"))+   <|>+   ((pRegExpr regex_'5cw'2b'5cs'2a'28'3f'3d'5c'28'29 >>= withAttribute FunctionTok) >>~ pushContext "Macro Args")) -parseRules "Detect Variables" = -  do (attr, result) <- (((pRegExpr regex_'5c'24ENV'5c'7b'5cs'2a'5cw'2b'5cs'2a'5c'7d >>= withAttribute "Environment Variable"))-                        <|>-                        ((pRegExpr regex_'5c'24'5c'7b'5cs'2a'5cw'2b'5cs'2a'5c'7d >>= withAttribute "CMake Variable")))-     return (attr, result)+parseRules "Detect Variables" =+  (((pRegExpr regex_'5c'24ENV'5c'7b'5cs'2a'5cw'2b'5cs'2a'5c'7d >>= withAttribute FloatTok))+   <|>+   ((pRegExpr regex_'5c'24'5c'7b'5cs'2a'5cw'2b'5cs'2a'5c'7d >>= withAttribute DecValTok))) -parseRules "Command Args" = -  do (attr, result) <- (((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_special'5fargs >>= withAttribute "Special Args"))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_extra'5fspecial'5fargs >>= withAttribute "Special Args"))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_properties >>= withAttribute "Properties"))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_extra'5fproperties >>= withAttribute "Properties"))-                        <|>-                        ((parseRules "Macro Args")))-     return (attr, result)+parseRules "Command Args" =+  (((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_special'5fargs >>= withAttribute OtherTok))+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_extra'5fspecial'5fargs >>= withAttribute OtherTok))+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_properties >>= withAttribute OtherTok))+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_extra'5fproperties >>= withAttribute OtherTok))+   <|>+   ((parseRules "Macro Args"))) -parseRules "Macro Args" = -  do (attr, result) <- (((pDetectChar False ')' >>= withAttribute "Normal Text") >>~ (popContext))-                        <|>-                        ((pString False "\\\"" >>= withAttribute "Escapes"))-                        <|>-                        ((pDetectChar False '"' >>= withAttribute "Strings") >>~ pushContext "String")-                        <|>-                        ((pRegExpr regex_'23'2e'2a'24 >>= withAttribute "Comment"))-                        <|>-                        ((parseRules "Detect Variables")))-     return (attr, result)+parseRules "Macro Args" =+  (((pDetectChar False ')' >>= withAttribute NormalTok) >>~ (popContext))+   <|>+   ((pString False "\\\"" >>= withAttribute CharTok))+   <|>+   ((pDetectChar False '"' >>= withAttribute StringTok) >>~ pushContext "String")+   <|>+   ((pRegExpr regex_'23'2e'2a'24 >>= withAttribute CommentTok))+   <|>+   ((parseRules "Detect Variables"))) -parseRules "Comment" = -  do (attr, result) <- ((Text.Highlighting.Kate.Syntax.Alert.parseExpression))-     return (attr, result)+parseRules "Comment" =+  ((Text.Highlighting.Kate.Syntax.Alert.parseExpression >>= ((withAttribute CommentTok) . snd))) -parseRules "String" = -  do (attr, result) <- (((pRegExpr regex_'22'28'3f'3d'5b_'29'3b'5d'7c'24'29 >>= withAttribute "Strings") >>~ (popContext))-                        <|>-                        ((pRegExpr regex_'5c'5c'5b'22'24n'5c'5c'5d >>= withAttribute "Escapes"))-                        <|>-                        ((parseRules "Detect Variables")))-     return (attr, result)+parseRules "String" =+  (((pRegExpr regex_'22'28'3f'3d'5b_'29'3b'5d'7c'24'29 >>= withAttribute StringTok) >>~ (popContext))+   <|>+   ((pRegExpr regex_'5c'5c'5b'22'24n'5c'5c'5d >>= withAttribute CharTok))+   <|>+   ((parseRules "Detect Variables")))  parseRules "" = parseRules "Normal Text" 

@@ -1,17 +1,20 @@-{- This module was generated from data in the Kate syntax highlighting file coffeescript.xml, version 1.1,-   by  Max Shawabkeh (max99x@gmail.com) -}+{- This module was generated from data in the Kate syntax+   highlighting file coffeescript.xml, version 1.1, by Max Shawabkeh (max99x@gmail.com) -} -module Text.Highlighting.Kate.Syntax.Coffeescript ( highlight, parseExpression, syntaxName, syntaxExtensions ) where-import Text.Highlighting.Kate.Definitions+module Text.Highlighting.Kate.Syntax.Coffeescript+          (highlight, parseExpression, syntaxName, syntaxExtensions)+where+import Text.Highlighting.Kate.Types import Text.Highlighting.Kate.Common import qualified Text.Highlighting.Kate.Syntax.Alert_indent import qualified Text.Highlighting.Kate.Syntax.Javascript-import Text.ParserCombinators.Parsec-import Control.Monad (when)+import Text.ParserCombinators.Parsec hiding (State) import Data.Map (fromList)-import Data.Maybe (fromMaybe, maybeToList)-+import Control.Monad.State+import Data.Char (isSpace)+import Data.Maybe (fromMaybe) import qualified Data.Set as Set+ -- | Full name of language. syntaxName :: String syntaxName = "CofeeScript"@@ -21,64 +24,51 @@ syntaxExtensions = "Cakefile;*.coffee;*.coco"  -- | Highlight source code using this syntax definition.-highlight :: String -> Either String [SourceLine]-highlight input =-  case runParser parseSource startingState "source" input of-    Left err     -> Left $ show err-    Right result -> Right result+highlight :: String -> [SourceLine]+highlight input = evalState (mapM parseSourceLine $ lines input) startingState +parseSourceLine :: String -> State SyntaxState SourceLine+parseSourceLine = mkParseSourceLine parseExpressionInternal pEndLine+ -- | Parse an expression using appropriate local context.-parseExpression :: GenParser Char SyntaxState LabeledSource+parseExpression :: KateParser Token parseExpression = do   st <- getState   let oldLang = synStLanguage st   setState $ st { synStLanguage = "CofeeScript" }   context <- currentContext <|> (pushContext "Normal" >> currentContext)   result <- parseRules context+  optional $ eof >> pEndLine   updateState $ \st -> st { synStLanguage = oldLang }   return result -parseSource = do -  lineContents <- lookAhead wholeLine-  updateState $ \st -> st { synStCurrentLine = lineContents }-  result <- manyTill parseSourceLine eof-  return $ map normalizeHighlighting result--startingState = SyntaxState {synStContexts = fromList [("CofeeScript",["Normal"])], synStLanguage = "CofeeScript", synStCurrentLine = "", synStCharsParsedInLine = 0, synStPrevChar = '\n', synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}--parseSourceLine = manyTill parseExpressionInternal pEndLine+startingState = SyntaxState {synStContexts = fromList [("CofeeScript",["Normal"])], synStLanguage = "CofeeScript", synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do-  lookAhead $ newline <|> (eof >> return '\n')   context <- currentContext   case context of-    "Normal" -> return () >> pHandleEndLine-    "Multiline Regex" -> return () >> pHandleEndLine-    "Class" -> return () >> pHandleEndLine+    "Normal" -> return ()+    "Multiline Regex" -> return ()+    "Class" -> return ()     "Comment" -> (popContext) >> pEndLine-    "Multiline Comment" -> return () >> pHandleEndLine-    "String" -> return () >> pHandleEndLine-    "Rich String" -> return () >> pHandleEndLine-    "Heredoc" -> return () >> pHandleEndLine-    "Rich Heredoc" -> return () >> pHandleEndLine-    "Embedding" -> return () >> pHandleEndLine-    "Javascript" -> return () >> pHandleEndLine-    _ -> pHandleEndLine+    "Multiline Comment" -> return ()+    "String" -> return ()+    "Rich String" -> return ()+    "Heredoc" -> return ()+    "Rich Heredoc" -> return ()+    "Embedding" -> return ()+    "Javascript" -> return ()+    _ -> return ()  withAttribute attr txt = do   when (null txt) $ fail "Parser matched no text"-  let labs = attr : maybeToList (lookup attr styles)-  st <- getState-  let oldCharsParsed = synStCharsParsedInLine st-  let prevchar = if null txt then '\n' else last txt-  updateState $ \st -> st { synStCharsParsedInLine = oldCharsParsed + length txt, synStPrevChar = prevchar } -  return (labs, txt)--styles = [("Keyword","kw"),("Function","fu"),("Decimal","dv"),("Float","fl"),("Oct","bn"),("Hex","bn"),("String","st"),("Comment","co"),("Symbol","kw"),("Embedding","ch"),("Accessor","dt"),("Class","dt"),("Javascript","al"),("Regex","st"),("Reserved","al"),("Value Keywords","ot"),("Globals","ot")]+  updateState $ \st -> st { synStPrevChar = last txt+                          , synStPrevNonspace = synStPrevNonspace st || not (all isSpace txt) }+  return (attr, txt)  parseExpressionInternal = do   context <- currentContext-  parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes))+  parseRules context <|> (pDefault >>= withAttribute (fromMaybe NormalTok $ lookup context defaultAttributes))  list_value'5fkeywords = Set.fromList $ words $ "false true yes no on off undefined null NaN Infinity" list_keywords = Set.fromList $ words $ "return break continue throw for while until loop if else unless switch when then and or in of by is isnt not typeof delete where super try catch finally try catch finally constructor"@@ -96,121 +86,110 @@ regex_'2f'2f'2f'5bmig'5d'7b0'2c3'7d = compileRegex "///[mig]{0,3}" regex_'5b'40'24'3a'2e'5cw'5c'5b'5c'5d'5d'2b = compileRegex "[@$:.\\w\\[\\]]+" -defaultAttributes = [("Normal","Normal"),("Multiline Regex","Regex"),("Class","Normal"),("Comment","Comment"),("Multiline Comment","Comment"),("String","String"),("Rich String","String"),("Heredoc","String"),("Rich Heredoc","String"),("Embedding","Normal"),("Javascript","Javascript")]+defaultAttributes = [("Normal",NormalTok),("Multiline Regex",StringTok),("Class",NormalTok),("Comment",CommentTok),("Multiline Comment",CommentTok),("String",StringTok),("Rich String",StringTok),("Heredoc",StringTok),("Rich Heredoc",StringTok),("Embedding",NormalTok),("Javascript",AlertTok)] -parseRules "Normal" = -  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Normal"))-                        <|>-                        ((pFloat >>= withAttribute "Float"))-                        <|>-                        ((pInt >>= withAttribute "Decimal"))-                        <|>-                        ((pHlCOct >>= withAttribute "Oct"))-                        <|>-                        ((pHlCHex >>= withAttribute "Hex"))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\#'" list_keywords >>= withAttribute "Keyword"))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\#'" list_class'5fkeywords >>= withAttribute "Keyword") >>~ pushContext "Class")-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\#'" list_value'5fkeywords >>= withAttribute "Value Keywords"))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\#'" list_reserved >>= withAttribute "Reserved"))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\#'" list_globals >>= withAttribute "Globals"))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\#'" list_browser'5fglobals >>= withAttribute "Browser Globals"))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\#'" list_nodejs'5fglobals >>= withAttribute "Node.js Globals"))-                        <|>-                        ((pRegExpr regex_'28'40'5b'5f'24a'2dzA'2dZ'5d'5b'24'5cw'5d'2b'7c'5cbthis'29'5cb >>= withAttribute "Accessor"))-                        <|>-                        ((pRegExpr regex_'28'5c'28'28'5c'27'5b'5e'27'5d'2a'27'7c'22'5b'5e'22'5d'2a'22'7c'5b'5e'28'29'5d'29'2a'5c'29'29'3f'5cs'2a'28'2d'7c'3d'29'3e >>= withAttribute "Function"))-                        <|>-                        ((pRegExpr regex_'5b'5f'24a'2dz'5d'5b'24'5cw'5d'2b'5cb >>= withAttribute "Identifier"))-                        <|>-                        ((pString False "'''" >>= withAttribute "String") >>~ pushContext "Heredoc")-                        <|>-                        ((pString False "\"\"\"" >>= withAttribute "String") >>~ pushContext "Rich Heredoc")-                        <|>-                        ((pDetectChar False '\'' >>= withAttribute "String") >>~ pushContext "String")-                        <|>-                        ((pDetectChar False '"' >>= withAttribute "String") >>~ pushContext "Rich String")-                        <|>-                        ((pDetectChar False '`' >>= withAttribute "Javascript") >>~ pushContext "Javascript")-                        <|>-                        ((pString False "###" >>= withAttribute "Comment") >>~ pushContext "Multiline Comment")-                        <|>-                        ((pDetectChar False '#' >>= withAttribute "Comment") >>~ pushContext "Comment")-                        <|>-                        ((pRegExpr regex_'2f'2f'2f >>= withAttribute "Regex") >>~ pushContext "Multiline Regex")-                        <|>-                        ((pRegExpr regex_'2f'28'5b'5e'2f'5c'5c'5cr'5cn'5d'7c'5c'5c'2e'29'2a'2f'5bmig'5d'7b0'2c3'7d >>= withAttribute "Regex"))-                        <|>-                        ((pAnyChar "():!%&+,-/.*<=>?[]|~^;{}" >>= withAttribute "Symbol")))-     return (attr, result)+parseRules "Normal" =+  (((pDetectSpaces >>= withAttribute NormalTok))+   <|>+   ((pFloat >>= withAttribute FloatTok))+   <|>+   ((pInt >>= withAttribute DecValTok))+   <|>+   ((pHlCOct >>= withAttribute BaseNTok))+   <|>+   ((pHlCHex >>= withAttribute BaseNTok))+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\#'" list_keywords >>= withAttribute KeywordTok))+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\#'" list_class'5fkeywords >>= withAttribute KeywordTok) >>~ pushContext "Class")+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\#'" list_value'5fkeywords >>= withAttribute OtherTok))+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\#'" list_reserved >>= withAttribute AlertTok))+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\#'" list_globals >>= withAttribute OtherTok))+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\#'" list_browser'5fglobals >>= withAttribute NormalTok))+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\#'" list_nodejs'5fglobals >>= withAttribute NormalTok))+   <|>+   ((pRegExpr regex_'28'40'5b'5f'24a'2dzA'2dZ'5d'5b'24'5cw'5d'2b'7c'5cbthis'29'5cb >>= withAttribute DataTypeTok))+   <|>+   ((pRegExpr regex_'28'5c'28'28'5c'27'5b'5e'27'5d'2a'27'7c'22'5b'5e'22'5d'2a'22'7c'5b'5e'28'29'5d'29'2a'5c'29'29'3f'5cs'2a'28'2d'7c'3d'29'3e >>= withAttribute FunctionTok))+   <|>+   ((pRegExpr regex_'5b'5f'24a'2dz'5d'5b'24'5cw'5d'2b'5cb >>= withAttribute NormalTok))+   <|>+   ((pString False "'''" >>= withAttribute StringTok) >>~ pushContext "Heredoc")+   <|>+   ((pString False "\"\"\"" >>= withAttribute StringTok) >>~ pushContext "Rich Heredoc")+   <|>+   ((pDetectChar False '\'' >>= withAttribute StringTok) >>~ pushContext "String")+   <|>+   ((pDetectChar False '"' >>= withAttribute StringTok) >>~ pushContext "Rich String")+   <|>+   ((pDetectChar False '`' >>= withAttribute AlertTok) >>~ pushContext "Javascript")+   <|>+   ((pString False "###" >>= withAttribute CommentTok) >>~ pushContext "Multiline Comment")+   <|>+   ((pDetectChar False '#' >>= withAttribute CommentTok) >>~ pushContext "Comment")+   <|>+   ((pRegExpr regex_'2f'2f'2f >>= withAttribute StringTok) >>~ pushContext "Multiline Regex")+   <|>+   ((pRegExpr regex_'2f'28'5b'5e'2f'5c'5c'5cr'5cn'5d'7c'5c'5c'2e'29'2a'2f'5bmig'5d'7b0'2c3'7d >>= withAttribute StringTok))+   <|>+   ((pAnyChar "():!%&+,-/.*<=>?[]|~^;{}" >>= withAttribute KeywordTok))) -parseRules "Multiline Regex" = -  do (attr, result) <- (((pHlCStringChar >>= withAttribute "Regex"))-                        <|>-                        ((pDetectChar False '#' >>= withAttribute "Comment") >>~ pushContext "Comment")-                        <|>-                        ((pRegExpr regex_'2f'2f'2f'5bmig'5d'7b0'2c3'7d >>= withAttribute "Regex") >>~ (popContext)))-     return (attr, result)+parseRules "Multiline Regex" =+  (((pHlCStringChar >>= withAttribute StringTok))+   <|>+   ((pDetectChar False '#' >>= withAttribute CommentTok) >>~ pushContext "Comment")+   <|>+   ((pRegExpr regex_'2f'2f'2f'5bmig'5d'7b0'2c3'7d >>= withAttribute StringTok) >>~ (popContext))) -parseRules "Class" = -  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Normal"))-                        <|>-                        ((pRegExpr regex_'5b'40'24'3a'2e'5cw'5c'5b'5c'5d'5d'2b >>= withAttribute "Class") >>~ (popContext)))-     return (attr, result)+parseRules "Class" =+  (((pDetectSpaces >>= withAttribute NormalTok))+   <|>+   ((pRegExpr regex_'5b'40'24'3a'2e'5cw'5c'5b'5c'5d'5d'2b >>= withAttribute DataTypeTok) >>~ (popContext))) -parseRules "Comment" = -  do (attr, result) <- ((Text.Highlighting.Kate.Syntax.Alert_indent.parseExpression))-     return (attr, result)+parseRules "Comment" =+  ((Text.Highlighting.Kate.Syntax.Alert_indent.parseExpression >>= ((withAttribute CommentTok) . snd))) -parseRules "Multiline Comment" = -  do (attr, result) <- (((pString False "###" >>= withAttribute "Comment") >>~ (popContext))-                        <|>-                        ((Text.Highlighting.Kate.Syntax.Alert_indent.parseExpression)))-     return (attr, result)+parseRules "Multiline Comment" =+  (((pString False "###" >>= withAttribute CommentTok) >>~ (popContext))+   <|>+   ((Text.Highlighting.Kate.Syntax.Alert_indent.parseExpression >>= ((withAttribute CommentTok) . snd)))) -parseRules "String" = -  do (attr, result) <- (((pHlCStringChar >>= withAttribute "String"))-                        <|>-                        ((pDetectChar False '\'' >>= withAttribute "String") >>~ (popContext)))-     return (attr, result)+parseRules "String" =+  (((pHlCStringChar >>= withAttribute StringTok))+   <|>+   ((pDetectChar False '\'' >>= withAttribute StringTok) >>~ (popContext))) -parseRules "Rich String" = -  do (attr, result) <- (((pHlCStringChar >>= withAttribute "String"))-                        <|>-                        ((pDetect2Chars False '#' '{' >>= withAttribute "Embedding") >>~ pushContext "Embedding")-                        <|>-                        ((pDetectChar False '"' >>= withAttribute "String") >>~ (popContext)))-     return (attr, result)+parseRules "Rich String" =+  (((pHlCStringChar >>= withAttribute StringTok))+   <|>+   ((pDetect2Chars False '#' '{' >>= withAttribute CharTok) >>~ pushContext "Embedding")+   <|>+   ((pDetectChar False '"' >>= withAttribute StringTok) >>~ (popContext))) -parseRules "Heredoc" = -  do (attr, result) <- (((pHlCStringChar >>= withAttribute "String"))-                        <|>-                        ((pString False "'''" >>= withAttribute "String") >>~ (popContext)))-     return (attr, result)+parseRules "Heredoc" =+  (((pHlCStringChar >>= withAttribute StringTok))+   <|>+   ((pString False "'''" >>= withAttribute StringTok) >>~ (popContext))) -parseRules "Rich Heredoc" = -  do (attr, result) <- (((pHlCStringChar >>= withAttribute "String"))-                        <|>-                        ((pDetect2Chars False '#' '{' >>= withAttribute "Embedding") >>~ pushContext "Embedding")-                        <|>-                        ((pString False "\"\"\"" >>= withAttribute "String") >>~ (popContext)))-     return (attr, result)+parseRules "Rich Heredoc" =+  (((pHlCStringChar >>= withAttribute StringTok))+   <|>+   ((pDetect2Chars False '#' '{' >>= withAttribute CharTok) >>~ pushContext "Embedding")+   <|>+   ((pString False "\"\"\"" >>= withAttribute StringTok) >>~ (popContext))) -parseRules "Embedding" = -  do (attr, result) <- ((pDetectChar False '}' >>= withAttribute "Embedding") >>~ (popContext))-     return (attr, result)+parseRules "Embedding" =+  ((pDetectChar False '}' >>= withAttribute CharTok) >>~ (popContext)) -parseRules "Javascript" = -  do (attr, result) <- (((pDetectChar False '`' >>= withAttribute "Javascript") >>~ (popContext))-                        <|>-                        ((Text.Highlighting.Kate.Syntax.Javascript.parseExpression)))-     return (attr, result)+parseRules "Javascript" =+  (((pDetectChar False '`' >>= withAttribute AlertTok) >>~ (popContext))+   <|>+   ((Text.Highlighting.Kate.Syntax.Javascript.parseExpression)))  parseRules "" = parseRules "Normal"