packages feed

highlighting-kate 0.2.6.2 → 0.2.7

raw patch · 73 files changed

+3571/−1541 lines, 73 filesdep ~parsecPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: parsec

API changes (from Hackage documentation)

+ Text.Highlighting.Kate: OptDetailed :: FormatOption
+ Text.Highlighting.Kate: languagesByFilename :: FilePath -> [String]
+ Text.Highlighting.Kate.Format: OptDetailed :: FormatOption
+ Text.Highlighting.Kate.Syntax: languagesByFilename :: FilePath -> [String]
+ Text.Highlighting.Kate.Syntax.Octave: highlight :: String -> Either String [SourceLine]
+ Text.Highlighting.Kate.Syntax.Octave: parseExpression :: GenParser Char SyntaxState LabeledSource
+ Text.Highlighting.Kate.Syntax.Octave: syntaxExtensions :: String
+ Text.Highlighting.Kate.Syntax.Octave: syntaxName :: String

Files

Highlight.hs view
@@ -6,7 +6,7 @@ import Text.XHtml.Transitional import System.Console.GetOpt import System.Exit-import System.FilePath (takeFileName, takeExtension)+import System.FilePath (takeFileName) import Data.Maybe (listToMaybe) import Data.Char (toLower) @@ -16,6 +16,7 @@           | List           | NumberLines           | Syntax String+          | Detailed           | TitleAttributes           | Version           deriving (Eq, Show)@@ -28,6 +29,7 @@   , 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"   ]@@ -81,10 +83,9 @@              else mapM readFile fnames >>= return . filterNewlines . concat   let lang' = case syntaxOf opts of                     Just e   -> Just e-                    Nothing  -> if null fnames-                                   then Nothing-                                   else let firstExt = drop 1 $ takeExtension $ head fnames-                                        in  listToMaybe $ languagesByExtension firstExt+                    Nothing  -> case fnames of+                                     []     -> Nothing+                                     (x:_)  -> listToMaybe $ languagesByFilename $ takeFileName x   lang <- if lang' == Nothing              then hPutStrLn stderr "No syntax specified." >>                   hPutStrLn stderr (usageInfo usageHeader options) >>@@ -94,8 +95,10 @@   if not (lang `elem` (map (map toLower) languages))      then hPutStrLn stderr ("Unknown syntax: " ++ lang) >> exitWith (ExitFailure 4)      else return ()-  let highlightOpts = (if TitleAttributes `elem` opts then [OptTitleAttributes] else []) ++-                      (if NumberLines `elem` opts then [OptNumberLines, OptLineAnchors] else [])+  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
ParseSyntaxFiles.hs view
@@ -24,12 +24,11 @@ import Text.XML.HXT.Arrow.Edit import Control.Arrow import Control.Arrow.ArrowList+import Control.Monad (liftM) import Data.List import Data.Maybe import Data.Char (toUpper, toLower, isAlphaNum) import qualified Data.Map as Map-import Prelude hiding (writeFile, putStrLn)-import System.IO.UTF8 (writeFile, putStrLn) import System.Directory import System.Environment import System.Exit@@ -38,6 +37,8 @@ import Text.Printf (printf) import Data.Char (ord) import Text.Highlighting.Kate.Definitions+import qualified Data.ByteString as B+import Data.ByteString.UTF8 (fromString, toString)  data SyntaxDefinition =   SyntaxDefinition { synLanguage      :: String@@ -110,46 +111,15 @@   -- 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 = concat $ intersperse ", " $ map (\name -> "(" ++ show name ++ ", " ++ name ++ ".syntaxExtensions)") names-  writeFile syntaxFile $-           "module Text.Highlighting.Kate.Syntax ( highlightAs, languages, languagesByExtension ) where\n\-           \import Data.Char (toLower)\n\-           \import Data.Maybe (fromMaybe)\n\-           \import Text.Highlighting.Kate.Definitions\n" ++-           imports ++ "\n" ++-           "-- | List of supported languages.\n\-           \languages :: [String]\n\-           \languages = " ++ show names ++ "\n\n\-           \-- | List of language extensions.\n\-           \languageExtensions :: [(String, String)]\n\-           \languageExtensions = [" ++ languageExtensions ++ "]\n\n" ++-           "-- | Returns a list of languages appropriate for the given file extension.\n\-           \languagesByExtension :: String -> [String]\n\-           \languagesByExtension ext = filter (hasExtension ext) languages\n\n\-           \-- | True if extension belongs to language.\n\-           \hasExtension ext lang =\n\-           \  let exts = fromMaybe \"\" (lookup lang languageExtensions)\n\-           \      matchExtension _ [] = False\n\-           \      matchExtension ext ('.':xs) =\n\-           \        let (next, rest) = span (/=';') xs\n\-           \        in  if next == ext then True else matchExtension ext rest\n\-           \      matchExtension ext (_:xs) = matchExtension ext xs\n\-           \  in  matchExtension (dropWhile (=='.') ext) exts\n\n\-           \-- | Highlight source code using a specified syntax definition.\n\-           \highlightAs :: String                        -- ^ Language syntax\n\-           \            -> String                        -- ^ Source code to highlight\n\-           \            -> Either String [SourceLine]    -- ^ Either error message or result\n\-           \highlightAs lang =\n\-           \  let lang'  = map toLower lang\n\-           \      lang'' = if lang' `elem` map (map toLower) languages\n\-           \                  then lang'\n\-           \                  else case languagesByExtension lang' of\n\-           \                            [l]  -> map toLower l  -- go by extension if unambiguous\n\-           \                            _    -> lang'\n\-           \  in  case lang'' of\n" ++-           cases ++-           "        _ -> (\\_ -> Left (\"Unknown language: \" ++ lang))\n"+  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+  B.writeFile syntaxFile $ fromString filledTemplate  processOneFile :: FilePath -> IO () processOneFile src = do@@ -161,7 +131,7 @@         concatMap contParsers $ synContexts syntax   let includeImports = map (("import qualified " ++) . langNameToModule) includeLangs   putStrLn $ "Writing " ++ outFile-  writeFile 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" ++ @@ -170,10 +140,12 @@            \import Text.Highlighting.Kate.Common\n" ++            unlines includeImports ++             "import Text.ParserCombinators.Parsec\n\-           \import Data.List (nub)\n\-           \import qualified Data.Set as Set\n\+           \import Control.Monad (when)\n\            \import Data.Map (fromList)\n\-           \import Data.Maybe (fromMaybe)\n\n" +++           \import Data.Maybe (fromMaybe, maybeToList)\n\n" +++           (if null (synLists syntax)+               then ""+               else "import qualified Data.Set as Set\n") ++            render (mkParser syntax) ++ "\n"  mkParser :: SyntaxDefinition -> Doc@@ -184,17 +156,29 @@       exts = text "-- | Filename extensions for this language." $$              text "syntaxExtensions :: String" $$              text ("syntaxExtensions = " ++ show (synExtensions syntax))-      styles = text ("styles = " ++ (show $ map (\(typ, sty) -> (typ, drop 2 sty)) $ synItemDatas 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 "if null txt" $$-                   text "   then fail \"Parser matched no text\"" $$-                   text "   else return ()" $$-                   text "let style = fromMaybe \"\" $ lookup attr styles" $$+                   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 (nub [style, attr], txt)")+                   text "return (labs, txt)")       parseExpressionInternal = text "parseExpressionInternal = do" $$ (nest 2 $                                    text "context <- currentContext" $$                                   text "parseRules context <|> (pDefault >>= withAttribute (fromMaybe \"\" $ lookup context defaultAttributes))")@@ -521,4 +505,20 @@                            z | z `elem` ["true","yes","1"] -> True                            z | z `elem` ["false","no","0"] -> False                            _ -> defaultVal++-- | Fill template.  The template variables in the source text are+-- surrounded by @'s: e.g., @myvar@.+fillTemplate :: Int -> [(String,String)] -> String -> String+fillTemplate _ _ [] = []+fillTemplate _ [] lst = lst+fillTemplate n 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+         then case lookup pref subs of+                    Just v  -> intercalate ('\n':replicate n ' ') (lines v) +++                                 fillTemplate (n + length v) subs (tail suff)+                    Nothing -> '@' : fillTemplate (n+1) subs xs+         else '@' : fillTemplate (n+1) subs xs+fillTemplate n subs (x:xs) = x : fillTemplate (n+1) subs xs
README view
@@ -49,7 +49,10 @@      runghc ParseSyntaxFiles.hs xml -Note that ParseSyntaxFiles.hs requires the HXT package.+Note that ParseSyntaxFiles.hs requires the HXT package. 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'.  You can browse the available Kate syntax highlighting files at
Text/Highlighting/Kate.hs view
@@ -24,6 +24,7 @@ module Text.Highlighting.Kate ( highlightAs                               , languages                               , languagesByExtension+                              , languagesByFilename                               , formatAsXHtml                               , FormatOption (..)                               , defaultHighlightingCss@@ -32,7 +33,7 @@                               , highlightingKateVersion                               ) where import Text.Highlighting.Kate.Format ( formatAsXHtml, FormatOption (..), defaultHighlightingCss )-import Text.Highlighting.Kate.Syntax ( highlightAs, languages, languagesByExtension )+import Text.Highlighting.Kate.Syntax ( highlightAs, languages, languagesByExtension, languagesByFilename ) import Text.Highlighting.Kate.Definitions ( SourceLine, LabeledSource ) import Data.Version (showVersion) import Paths_highlighting_kate (version)
Text/Highlighting/Kate/Common.hs view
@@ -21,9 +21,32 @@ import Text.Highlighting.Kate.Definitions import Text.ParserCombinators.Parsec import Data.Char (isDigit, chr, toLower)+import Data.List (tails) import qualified Data.Map as Map import qualified Data.Set as Set +-- | Match filename against a list of globs contained in a semicolon-separated+-- string.+matchGlobs :: String -> String -> Bool+matchGlobs fn globs = any (flip matchGlob fn) (splitBySemi $ filter (/=' ') globs)++-- | Match filename against a glob pattern with asterisks.+matchGlob :: String -> String -> Bool+matchGlob ('*':xs) fn = any (matchGlob xs) (tails fn)+matchGlob (x:xs) (y:ys) = x == y && matchGlob xs ys+matchGlob "" "" = True+matchGlob _ _   = False++-- | Splits semicolon-separated list+splitBySemi :: String -> [String]+splitBySemi "" = []+splitBySemi xs =+  let (pref, suff) = break (==';') xs+  in  case suff of+         []       -> [pref]+         (';':ys) -> pref : splitBySemi ys+         _        -> error $ "The impossible happened (splitBySemi)"+ -- | Like >>, but returns the operation on the left. -- (Suggested by Tillmann Rendel on Haskell-cafe list.) (>>~) :: (Monad m) => m a -> m b -> m a@@ -170,7 +193,7 @@ #else compileRegex regexpStr =   case unsafePerformIO $ compile (compAnchored) (execNotEmpty) ('.' : escapeRegex regexpStr) of-        Left _ -> error $ "Error compiling regex: " ++ regexpStr+        Left _ -> error $ "Error compiling regex: " ++ show regexpStr         Right r -> r #endif
Text/Highlighting/Kate/Format.hs view
@@ -20,6 +20,9 @@                   | 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.)                   deriving (Eq, Show, Read)  -- | Format a list of highlighted @SourceLine@s as XHtml.@@ -34,26 +37,28 @@   in  if OptNumberLines `elem` opts          then let lnTitle = title "Click to toggle line numbers"                   lnOnClick = strAttr "onclick" "with (this.firstChild.style) { display = (display == '') ? 'none' : '' }"-                  lineNumbers = td ! [theclass "lineNumbers", lnTitle, lnOnClick] $ pre <<+                  nums = td ! [theclass "nums", 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 $ unwords ["sourceCode", lang]] $ code-              in  table ! [theclass "sourceCode"] $ tr << [lineNumbers, sourceCode]+              in  table ! [theclass "sourceCode"] $ tr << [nums, sourceCode]          else pre ! [theclass $ unwords ["sourceCode", lang]] $ code  labeledSourceToHtml :: [FormatOption] -> LabeledSource -> Html-labeledSourceToHtml opts (syntaxType, txt) =-  let classes = unwords $ filter (/= "") $ map removeSpaces syntaxType-  in if null classes -        then toHtml txt-        else let attribs = [theclass classes] ++ -                           if OptTitleAttributes `elem` opts-                              then [title classes] -                              else []-             in  thespan ! attribs << txt +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 =@@ -73,18 +78,16 @@   \   { 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\ -  \pre.sourceCode { }\n\ -  \pre.sourceCode span.Normal { }\n\ -  \pre.sourceCode span.Keyword { color: #007020; font-weight: bold; } \n\ -  \pre.sourceCode span.DataType { color: #902000; }\n\ -  \pre.sourceCode span.DecVal { color: #40a070; }\n\ -  \pre.sourceCode span.BaseN { color: #40a070; }\n\ -  \pre.sourceCode span.Float { color: #40a070; }\n\ -  \pre.sourceCode span.Char { color: #4070a0; }\n\ -  \pre.sourceCode span.String { color: #4070a0; }\n\ -  \pre.sourceCode span.Comment { color: #60a0b0; font-style: italic; }\n\ -  \pre.sourceCode span.Others { color: #007020; }\n\ -  \pre.sourceCode span.Alert { color: red; font-weight: bold; }\n\ -  \pre.sourceCode span.Function { color: #06287e; }\n\ -  \pre.sourceCode span.RegionMarker { }\n\ -  \pre.sourceCode span.Error { color: red; font-weight: bold; }"+  \pre.sourceCode span.kw { color: #007020; font-weight: bold; } \n\ +  \pre.sourceCode span.dt { color: #902000; }\n\ +  \pre.sourceCode span.dv { color: #40a070; }\n\ +  \pre.sourceCode span.bn { color: #40a070; }\n\ +  \pre.sourceCode span.fl { color: #40a070; }\n\ +  \pre.sourceCode span.ch { color: #4070a0; }\n\ +  \pre.sourceCode span.st { color: #4070a0; }\n\ +  \pre.sourceCode span.co { color: #60a0b0; font-style: italic; }\n\ +  \pre.sourceCode span.ot { color: #007020; }\n\ +  \pre.sourceCode span.al { color: red; font-weight: bold; }\n\ +  \pre.sourceCode span.fu { color: #06287e; }\n\ +  \pre.sourceCode span.re { }\n\ +  \pre.sourceCode span.er { color: red; font-weight: bold; }"
Text/Highlighting/Kate/Syntax.hs view
@@ -1,7 +1,8 @@-module Text.Highlighting.Kate.Syntax ( highlightAs, languages, languagesByExtension ) where+module Text.Highlighting.Kate.Syntax ( highlightAs, languages, languagesByExtension,+                                       languagesByFilename ) where import Data.Char (toLower)-import Data.Maybe (fromMaybe) import Text.Highlighting.Kate.Definitions+import Text.Highlighting.Kate.Common (matchGlobs) import qualified Text.Highlighting.Kate.Syntax.Ada as Ada import qualified Text.Highlighting.Kate.Syntax.Alert as Alert import qualified Text.Highlighting.Kate.Syntax.Asp as Asp@@ -38,6 +39,7 @@ import qualified Text.Highlighting.Kate.Syntax.Nasm as Nasm import qualified Text.Highlighting.Kate.Syntax.Objectivec as Objectivec import qualified Text.Highlighting.Kate.Syntax.Ocaml as Ocaml+import qualified Text.Highlighting.Kate.Syntax.Octave as Octave import qualified Text.Highlighting.Kate.Syntax.Pascal as Pascal import qualified Text.Highlighting.Kate.Syntax.Perl as Perl import qualified Text.Highlighting.Kate.Syntax.Php as Php@@ -61,25 +63,20 @@  -- | List of supported languages. languages :: [String]-languages = ["Ada","Alert","Asp","Awk","Bash","Bibtex","C","Cmake","Coldfusion","Commonlisp","Cpp","Css","D","Djangotemplate","Doxygen","Dtd","Eiffel","Erlang","Fortran","Haskell","Html","Java","Javadoc","Javascript","Json","Latex","Lex","LiterateHaskell","Lua","Makefile","Matlab","Mediawiki","Modula3","Nasm","Objectivec","Ocaml","Pascal","Perl","Php","Postscript","Prolog","Python","Relaxngcompact","Rhtml","Ruby","Scala","Scheme","Sgml","Sql","SqlMysql","SqlPostgresql","Tcl","Texinfo","Xml","Xslt","Yacc"]+languages = ["Ada","Alert","Asp","Awk","Bash","Bibtex","C","Cmake","Coldfusion","Commonlisp","Cpp","Css","D","Djangotemplate","Doxygen","Dtd","Eiffel","Erlang","Fortran","Haskell","Html","Java","Javadoc","Javascript","Json","Latex","Lex","LiterateHaskell","Lua","Makefile","Matlab","Mediawiki","Modula3","Nasm","Objectivec","Ocaml","Octave","Pascal","Perl","Php","Postscript","Prolog","Python","Relaxngcompact","Rhtml","Ruby","Scala","Scheme","Sgml","Sql","SqlMysql","SqlPostgresql","Tcl","Texinfo","Xml","Xslt","Yacc"]  -- | List of language extensions. languageExtensions :: [(String, String)]-languageExtensions = [("Ada", Ada.syntaxExtensions), ("Alert", Alert.syntaxExtensions), ("Asp", Asp.syntaxExtensions), ("Awk", Awk.syntaxExtensions), ("Bash", Bash.syntaxExtensions), ("Bibtex", Bibtex.syntaxExtensions), ("C", C.syntaxExtensions), ("Cmake", Cmake.syntaxExtensions), ("Coldfusion", Coldfusion.syntaxExtensions), ("Commonlisp", Commonlisp.syntaxExtensions), ("Cpp", Cpp.syntaxExtensions), ("Css", Css.syntaxExtensions), ("D", D.syntaxExtensions), ("Djangotemplate", Djangotemplate.syntaxExtensions), ("Doxygen", Doxygen.syntaxExtensions), ("Dtd", Dtd.syntaxExtensions), ("Eiffel", Eiffel.syntaxExtensions), ("Erlang", Erlang.syntaxExtensions), ("Fortran", Fortran.syntaxExtensions), ("Haskell", Haskell.syntaxExtensions), ("Html", Html.syntaxExtensions), ("Java", Java.syntaxExtensions), ("Javadoc", Javadoc.syntaxExtensions), ("Javascript", Javascript.syntaxExtensions), ("Json", Json.syntaxExtensions), ("Latex", Latex.syntaxExtensions), ("Lex", Lex.syntaxExtensions), ("LiterateHaskell", LiterateHaskell.syntaxExtensions), ("Lua", Lua.syntaxExtensions), ("Makefile", Makefile.syntaxExtensions), ("Matlab", Matlab.syntaxExtensions), ("Mediawiki", Mediawiki.syntaxExtensions), ("Modula3", Modula3.syntaxExtensions), ("Nasm", Nasm.syntaxExtensions), ("Objectivec", Objectivec.syntaxExtensions), ("Ocaml", Ocaml.syntaxExtensions), ("Pascal", Pascal.syntaxExtensions), ("Perl", Perl.syntaxExtensions), ("Php", Php.syntaxExtensions), ("Postscript", Postscript.syntaxExtensions), ("Prolog", Prolog.syntaxExtensions), ("Python", Python.syntaxExtensions), ("Relaxngcompact", Relaxngcompact.syntaxExtensions), ("Rhtml", Rhtml.syntaxExtensions), ("Ruby", Ruby.syntaxExtensions), ("Scala", Scala.syntaxExtensions), ("Scheme", Scheme.syntaxExtensions), ("Sgml", Sgml.syntaxExtensions), ("Sql", Sql.syntaxExtensions), ("SqlMysql", SqlMysql.syntaxExtensions), ("SqlPostgresql", SqlPostgresql.syntaxExtensions), ("Tcl", Tcl.syntaxExtensions), ("Texinfo", Texinfo.syntaxExtensions), ("Xml", Xml.syntaxExtensions), ("Xslt", Xslt.syntaxExtensions), ("Yacc", Yacc.syntaxExtensions)]+languageExtensions = [("Ada", Ada.syntaxExtensions), ("Alert", Alert.syntaxExtensions), ("Asp", Asp.syntaxExtensions), ("Awk", Awk.syntaxExtensions), ("Bash", Bash.syntaxExtensions), ("Bibtex", Bibtex.syntaxExtensions), ("C", C.syntaxExtensions), ("Cmake", Cmake.syntaxExtensions), ("Coldfusion", Coldfusion.syntaxExtensions), ("Commonlisp", Commonlisp.syntaxExtensions), ("Cpp", Cpp.syntaxExtensions), ("Css", Css.syntaxExtensions), ("D", D.syntaxExtensions), ("Djangotemplate", Djangotemplate.syntaxExtensions), ("Doxygen", Doxygen.syntaxExtensions), ("Dtd", Dtd.syntaxExtensions), ("Eiffel", Eiffel.syntaxExtensions), ("Erlang", Erlang.syntaxExtensions), ("Fortran", Fortran.syntaxExtensions), ("Haskell", Haskell.syntaxExtensions), ("Html", Html.syntaxExtensions), ("Java", Java.syntaxExtensions), ("Javadoc", Javadoc.syntaxExtensions), ("Javascript", Javascript.syntaxExtensions), ("Json", Json.syntaxExtensions), ("Latex", Latex.syntaxExtensions), ("Lex", Lex.syntaxExtensions), ("LiterateHaskell", LiterateHaskell.syntaxExtensions), ("Lua", Lua.syntaxExtensions), ("Makefile", Makefile.syntaxExtensions), ("Matlab", Matlab.syntaxExtensions), ("Mediawiki", Mediawiki.syntaxExtensions), ("Modula3", Modula3.syntaxExtensions), ("Nasm", Nasm.syntaxExtensions), ("Objectivec", Objectivec.syntaxExtensions), ("Ocaml", Ocaml.syntaxExtensions), ("Octave", Octave.syntaxExtensions), ("Pascal", Pascal.syntaxExtensions), ("Perl", Perl.syntaxExtensions), ("Php", Php.syntaxExtensions), ("Postscript", Postscript.syntaxExtensions), ("Prolog", Prolog.syntaxExtensions), ("Python", Python.syntaxExtensions), ("Relaxngcompact", Relaxngcompact.syntaxExtensions), ("Rhtml", Rhtml.syntaxExtensions), ("Ruby", Ruby.syntaxExtensions), ("Scala", Scala.syntaxExtensions), ("Scheme", Scheme.syntaxExtensions), ("Sgml", Sgml.syntaxExtensions), ("Sql", Sql.syntaxExtensions), ("SqlMysql", SqlMysql.syntaxExtensions), ("SqlPostgresql", SqlPostgresql.syntaxExtensions), ("Tcl", Tcl.syntaxExtensions), ("Texinfo", Texinfo.syntaxExtensions), ("Xml", Xml.syntaxExtensions), ("Xslt", Xslt.syntaxExtensions), ("Yacc", Yacc.syntaxExtensions)]  -- | Returns a list of languages appropriate for the given file extension. languagesByExtension :: String -> [String]-languagesByExtension ext = filter (hasExtension ext) languages+languagesByExtension ('.':ext) = languagesByFilename ("*." ++ ext)+languagesByExtension ext       = languagesByFilename ("*." ++ ext) --- | True if extension belongs to language.-hasExtension ext lang =-  let exts = fromMaybe "" (lookup lang languageExtensions)-      matchExtension _ [] = False-      matchExtension ext ('.':xs) =-        let (next, rest) = span (/=';') xs-        in  if next == ext then True else matchExtension ext rest-      matchExtension ext (_:xs) = matchExtension ext xs-  in  matchExtension (dropWhile (=='.') ext) exts+-- | Returns a list of languages appropriate for the given filename.+languagesByFilename :: FilePath -> [String]+languagesByFilename fn = [lang | (lang, globs) <- languageExtensions, matchGlobs fn globs]  -- | Highlight source code using a specified syntax definition. highlightAs :: String                        -- ^ Language syntax@@ -129,6 +126,7 @@         "nasm" -> Nasm.highlight         "objectivec" -> Objectivec.highlight         "ocaml" -> Ocaml.highlight+        "octave" -> Octave.highlight         "pascal" -> Pascal.highlight         "perl" -> Perl.highlight         "php" -> Php.highlight
+ Text/Highlighting/Kate/Syntax.hs.in view
@@ -0,0 +1,38 @@+module Text.Highlighting.Kate.Syntax ( highlightAs, languages, languagesByExtension,+                                       languagesByFilename ) where+import Data.Char (toLower)+import Text.Highlighting.Kate.Definitions+import Text.Highlighting.Kate.Common (matchGlobs)+@imports@++-- | List of supported languages.+languages :: [String]+languages = @languages@++-- | List of language extensions.+languageExtensions :: [(String, String)]+languageExtensions = @languageExtensions@++-- | Returns a list of languages appropriate for the given file extension.+languagesByExtension :: String -> [String]+languagesByExtension ('.':ext) = languagesByFilename ("*." ++ ext)+languagesByExtension ext       = languagesByFilename ("*." ++ ext)++-- | Returns a list of languages appropriate for the given filename.+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+highlightAs lang =+  let lang'  = map toLower lang+      lang'' = if lang' `elem` map (map toLower) languages+                  then lang'+                  else case languagesByExtension lang' of+                            [l]  -> map toLower l  -- go by extension if unambiguous+                            _    -> lang'+  in  case lang'' of+        @cases@+        _ -> (\_ -> Left ("Unknown language: " ++ lang))
Text/Highlighting/Kate/Syntax/Ada.hs view
@@ -5,11 +5,11 @@ import Text.Highlighting.Kate.Definitions import Text.Highlighting.Kate.Common import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "Ada"@@ -59,17 +59,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Keyword","Keyword"),("Pragmas","Keyword"),("Data Type","DataType"),("Decimal","DecVal"),("Base-N","BaseN"),("Float","Float"),("Char","Char"),("String","String"),("Comment","Comment"),("Symbol","Normal"),("Region Marker","RegionMarker")]+styles = [("Keyword","kw"),("Pragmas","kw"),("Data Type","dt"),("Decimal","dv"),("Base-N","bn"),("Float","fl"),("Char","ch"),("String","st"),("Comment","co"),("Region Marker","re")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Alert.hs view
@@ -5,11 +5,11 @@ import Text.Highlighting.Kate.Definitions import Text.Highlighting.Kate.Common import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "Alerts"@@ -56,17 +56,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Alert","Alert")]+styles = [("Alert","al")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Asp.hs view
@@ -5,11 +5,11 @@ import Text.Highlighting.Kate.Definitions import Text.Highlighting.Kate.Common import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "ASP"@@ -68,17 +68,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("ASP Text","Normal"),("Keyword","Keyword"),("Function","Keyword"),("Decimal","DecVal"),("Octal","BaseN"),("Hex","BaseN"),("Float","Float"),("String","String"),("Comment","Comment"),("Variable","Keyword"),("Control Structures","Keyword"),("Escape Code","Keyword"),("Other","Others"),("HTML Tag","Keyword"),("HTML Comment","Comment"),("Identifier","Others"),("Types","DataType")]+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")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Awk.hs view
@@ -6,11 +6,11 @@ import Text.Highlighting.Kate.Common import qualified Text.Highlighting.Kate.Syntax.Alert import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "AWK"@@ -59,17 +59,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal","Normal"),("Keyword","Keyword"),("Builtin","DataType"),("Function","Function"),("Decimal","DecVal"),("Float","Float"),("String","String"),("Comment","Comment"),("Pattern","String"),("Field","Others")]+styles = [("Keyword","kw"),("Builtin","dt"),("Function","fu"),("Decimal","dv"),("Float","fl"),("String","st"),("Comment","co"),("Pattern","st"),("Field","ot")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Bash.hs view
@@ -6,11 +6,11 @@ import Text.Highlighting.Kate.Common import qualified Text.Highlighting.Kate.Syntax.Alert import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "Bash"@@ -105,17 +105,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Comment","Comment"),("Keyword","Keyword"),("Control","Keyword"),("Builtin","Keyword"),("Command","Keyword"),("Redirection","Keyword"),("Escape","DataType"),("String SingleQ","String"),("String DoubleQ","String"),("Backquote","Keyword"),("String Transl.","String"),("String Escape","DataType"),("Variable","Others"),("Expression","Others"),("Function","Function"),("Path","Normal"),("Option","Normal"),("Error","Error")]+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
Text/Highlighting/Kate/Syntax/Bibtex.hs view
@@ -5,11 +5,11 @@ import Text.Highlighting.Kate.Definitions import Text.Highlighting.Kate.Common import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "BibTeX"@@ -58,17 +58,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Entry","Keyword"),("Command","Function"),("Field","DataType"),("Ref Key","Others"),("String","String"),("Char","Char")]+styles = [("Entry","kw"),("Command","fu"),("Field","dt"),("Ref Key","ot"),("String","st"),("Char","ch")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/C.hs view
@@ -7,11 +7,11 @@ import qualified Text.Highlighting.Kate.Syntax.Doxygen import qualified Text.Highlighting.Kate.Syntax.Alert import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "C"@@ -68,17 +68,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Keyword","Keyword"),("Data Type","DataType"),("Decimal","DecVal"),("Octal","BaseN"),("Hex","BaseN"),("Float","Float"),("Char","Char"),("String","String"),("String Char","Char"),("Comment","Comment"),("Symbol","Normal"),("Preprocessor","Others"),("Prep. Lib","Others"),("Alert","Alert"),("Region Marker","RegionMarker"),("Error","Error")]+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")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Cmake.hs view
@@ -6,11 +6,11 @@ import Text.Highlighting.Kate.Common import qualified Text.Highlighting.Kate.Syntax.Alert import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "CMake"@@ -59,17 +59,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Special Args","Others"),("Commands","Keyword"),("Macros","Keyword"),("Variable","DecVal"),("Comment","Comment"),("Region Marker","RegionMarker")]+styles = [("Special Args","ot"),("Commands","kw"),("Macros","kw"),("Variable","dv"),("Comment","co"),("Region Marker","re")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Coldfusion.hs view
@@ -5,11 +5,11 @@ import Text.Highlighting.Kate.Definitions import Text.Highlighting.Kate.Common import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "ColdFusion"@@ -76,17 +76,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Tags","Normal"),("Table Tags","Normal"),("Script Tags","Normal"),("Image Tags","Normal"),("Style Tags","Normal"),("Anchor Tags","Normal"),("Attribute Values","Normal"),("HTML Comment","Comment"),("CF Comment","Comment"),("Script Comment","Comment"),("CF Tags","Normal"),("Custom Tags","Normal"),("CFX Tags","Normal"),("Numbers","Normal"),("HTML Entities","Normal"),("Style Selectors","Normal"),("Style Properties","Normal"),("Style Values","Normal"),("Brackets","Normal"),("Script Numbers","Normal"),("Script Strings","Normal"),("Script Operators","Normal"),("Script Keywords","Normal"),("Script Functions","Function"),("Script Objects","Normal")]+styles = [("HTML Comment","co"),("CF Comment","co"),("Script Comment","co"),("Script Functions","fu")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Commonlisp.hs view
@@ -5,11 +5,11 @@ import Text.Highlighting.Kate.Definitions import Text.Highlighting.Kate.Common import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "Common Lisp"@@ -60,17 +60,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal","Normal"),("Keyword","Keyword"),("Operator","Keyword"),("Modifier","Keyword"),("Variable","Keyword"),("Definition","Keyword"),("Data","DataType"),("Decimal","DecVal"),("BaseN","BaseN"),("Float","Float"),("Function","Function"),("Char","Char"),("String","String"),("Comment","Comment"),("Region Marker","RegionMarker"),("Brackets","Normal")]+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")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Cpp.hs view
@@ -7,11 +7,11 @@ import qualified Text.Highlighting.Kate.Syntax.Doxygen import qualified Text.Highlighting.Kate.Syntax.Alert import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "C++"@@ -68,17 +68,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Keyword","Keyword"),("Extensions","Keyword"),("Data Type","DataType"),("Decimal","DecVal"),("Octal","BaseN"),("Hex","BaseN"),("Float","Float"),("Char","Char"),("String","String"),("String Char","Char"),("Comment","Comment"),("Symbol","Normal"),("Preprocessor","Others"),("Prep. Lib","Others"),("Region Marker","RegionMarker"),("Error","Error")]+styles = [("Keyword","kw"),("Extensions","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"),("Region Marker","re"),("Error","er")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Css.hs view
@@ -6,11 +6,11 @@ import Text.Highlighting.Kate.Common import qualified Text.Highlighting.Kate.Syntax.Alert import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "CSS"@@ -75,17 +75,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Property","Keyword"),("Unknown Property","Keyword"),("Media","DecVal"),("At Rule","DecVal"),("String","String"),("Value","DataType"),("Important","Keyword"),("Selector Attr","Char"),("Selector Id","Float"),("Selector Class","Float"),("Selector Pseudo","DecVal"),("Comment","Comment"),("Region Marker","RegionMarker"),("Alert","Alert"),("Error","Error")]+styles = [("Property","kw"),("Unknown Property","kw"),("Media","dv"),("At Rule","dv"),("String","st"),("Value","dt"),("Important","kw"),("Selector Attr","ch"),("Selector Id","fl"),("Selector Class","fl"),("Selector Pseudo","dv"),("Comment","co"),("Region Marker","re"),("Alert","al"),("Error","er")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/D.hs view
@@ -5,11 +5,11 @@ import Text.Highlighting.Kate.Definitions import Text.Highlighting.Kate.Common import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "D"@@ -74,17 +74,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Keyword","Keyword"),("Type","DataType"),("Integer","DecVal"),("Binary","BaseN"),("Octal","BaseN"),("Hex","BaseN"),("Float","Float"),("LibrarySymbols","DataType"),("Deprecated","Comment"),("SpecialTokens","Normal"),("Module","Keyword"),("Module Name","Normal"),("Linkage","Keyword"),("Linkage Type","Normal"),("Debug","Keyword"),("Assert","Keyword"),("Version","Keyword"),("Version Type","Normal"),("Unit Test","Keyword"),("Pragma","Keyword"),("EscapeString","String"),("EscapeSequence","String"),("String","String"),("Char","Char"),("RawString","String"),("BQString","String"),("HexString","String"),("Comment","Comment"),("Error","Error")]+styles = [("Keyword","kw"),("Type","dt"),("Integer","dv"),("Binary","bn"),("Octal","bn"),("Hex","bn"),("Float","fl"),("LibrarySymbols","dt"),("Deprecated","co"),("Module","kw"),("Linkage","kw"),("Debug","kw"),("Assert","kw"),("Version","kw"),("Unit Test","kw"),("Pragma","kw"),("EscapeString","st"),("EscapeSequence","st"),("String","st"),("Char","ch"),("RawString","st"),("BQString","st"),("HexString","st"),("Comment","co"),("Error","er")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Djangotemplate.hs view
@@ -8,11 +8,11 @@ import qualified Text.Highlighting.Kate.Syntax.Css import qualified Text.Highlighting.Kate.Syntax.Javascript import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "Django HTML Template"@@ -97,17 +97,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Comment","Comment"),("CDATA","BaseN"),("Processing Instruction","Keyword"),("Doctype","DataType"),("Element","Keyword"),("Attribute","Others"),("Value","String"),("EntityRef","DecVal"),("PEntityRef","DecVal"),("Error","Error"),("Template Var","Function"),("Template Tag","Function"),("Template Tag Argument","Function"),("Template String","String"),("Template Comment","Comment"),("Template Filter","Others"),("Mismatched Block Tag","Error")]+styles = [("Comment","co"),("CDATA","bn"),("Processing Instruction","kw"),("Doctype","dt"),("Element","kw"),("Attribute","ot"),("Value","st"),("EntityRef","dv"),("PEntityRef","dv"),("Error","er"),("Template Var","fu"),("Template Tag","fu"),("Template Tag Argument","fu"),("Template String","st"),("Template Comment","co"),("Template Filter","ot"),("Mismatched Block Tag","er")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Doxygen.hs view
@@ -6,11 +6,11 @@ import Text.Highlighting.Kate.Common import qualified Text.Highlighting.Kate.Syntax.Alert import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "Doxygen"@@ -81,17 +81,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Tags","Keyword"),("Word","Keyword"),("HTML Tag","Keyword"),("Description","String"),("Comment","Comment"),("Region","RegionMarker"),("Identifier","Others"),("HTML Comment","Comment"),("Types","DataType")]+styles = [("Tags","kw"),("Word","kw"),("HTML Tag","kw"),("Description","st"),("Comment","co"),("Region","re"),("Identifier","ot"),("HTML Comment","co"),("Types","dt")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Dtd.hs view
@@ -6,11 +6,11 @@ import Text.Highlighting.Kate.Common import qualified Text.Highlighting.Kate.Syntax.Alert import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "DTD"@@ -62,17 +62,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal","Normal"),("Comment","Comment"),("Processing Instruction","Keyword"),("Declaration","DataType"),("Name","Function"),("Delimiter","DecVal"),("Symbol","Float"),("Keyword","Keyword"),("String","String"),("Entity","DecVal"),("Local","DecVal")]+styles = [("Comment","co"),("Processing Instruction","kw"),("Declaration","dt"),("Name","fu"),("Delimiter","dv"),("Symbol","fl"),("Keyword","kw"),("String","st"),("Entity","dv"),("Local","dv")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Eiffel.hs view
@@ -5,11 +5,11 @@ import Text.Highlighting.Kate.Definitions import Text.Highlighting.Kate.Common import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "Eiffel"@@ -58,17 +58,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Keyword","Keyword"),("Predefined entities","Others"),("Assertions","Others"),("Decimal","DecVal"),("Float","Float"),("Char","Char"),("String","String"),("Comment","Comment")]+styles = [("Keyword","kw"),("Predefined entities","ot"),("Assertions","ot"),("Decimal","dv"),("Float","fl"),("Char","ch"),("String","st"),("Comment","co")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Erlang.hs view
@@ -6,11 +6,11 @@ import Text.Highlighting.Kate.Common import qualified Text.Highlighting.Kate.Syntax.Alert import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "Erlang"@@ -61,17 +61,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Keyword","Keyword"),("Pragma","Keyword"),("Function","Function"),("Separator","Function"),("Operator","Keyword"),("Variable","DataType"),("Integer","DecVal"),("Number","BaseN"),("Float","Float"),("Atom","Char"),("String","String"),("Comment","Comment")]+styles = [("Keyword","kw"),("Pragma","kw"),("Function","fu"),("Separator","fu"),("Operator","kw"),("Variable","dt"),("Integer","dv"),("Number","bn"),("Float","fl"),("Atom","ch"),("String","st"),("Comment","co")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Fortran.hs view
@@ -5,11 +5,11 @@ import Text.Highlighting.Kate.Definitions import Text.Highlighting.Kate.Common import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "Fortran"@@ -74,17 +74,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Keyword","Keyword"),("Data Type","DataType"),("Decimal","DecVal"),("Float","Float"),("String","String"),("Comment","Comment"),("Symbol","Normal"),("Preprocessor","Others"),("Operator","Keyword"),("Logical","Others"),("IO Function","Function"),("Elemental Procedure","Keyword"),("Inquiry Function","Function"),("Transformational Function","Function"),("Non elemental subroutine","Keyword")]+styles = [("Keyword","kw"),("Data Type","dt"),("Decimal","dv"),("Float","fl"),("String","st"),("Comment","co"),("Preprocessor","ot"),("Operator","kw"),("Logical","ot"),("IO Function","fu"),("Elemental Procedure","kw"),("Inquiry Function","fu"),("Transformational Function","fu"),("Non elemental subroutine","kw")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Haskell.hs view
@@ -1,15 +1,15 @@-{- This module was generated from data in the Kate syntax highlighting file haskell.xml, version 1.04,-   by  Marcel Martin (mmar@freenet.de) -}+{- This module was generated from data in the Kate syntax highlighting file haskell.xml, version 2.0.3,+   by  Nicolas Wu (zenzike@gmail.com) -}  module Text.Highlighting.Kate.Syntax.Haskell ( highlight, parseExpression, syntaxName, syntaxExtensions ) where import Text.Highlighting.Kate.Definitions import Text.Highlighting.Kate.Common import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "Haskell"@@ -31,7 +31,7 @@   st <- getState   let oldLang = synStLanguage st   setState $ st { synStLanguage = "Haskell" }-  context <- currentContext <|> (pushContext "normal" >> currentContext)+  context <- currentContext <|> (pushContext "code" >> currentContext)   result <- parseRules context   updateState $ \st -> st { synStLanguage = oldLang }   return result@@ -42,7 +42,7 @@   result <- manyTill parseSourceLine eof   return $ map normalizeHighlighting result -startingState = SyntaxState {synStContexts = fromList [("Haskell",["normal"])], synStLanguage = "Haskell", synStCurrentLine = "", synStCharsParsedInLine = 0, synStPrevChar = '\n', synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = fromList [("Haskell",["code"])], synStLanguage = "Haskell", synStCurrentLine = "", synStCharsParsedInLine = 0, synStPrevChar = '\n', synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  parseSourceLine = manyTill parseExpressionInternal pEndLine @@ -50,91 +50,108 @@   newline <|> (eof >> return '\n')   context <- currentContext   case context of-    "normal" -> return ()-    "comment_single_line" -> (popContext >> return ())-    "comment_multi_line" -> return ()+    "code" -> return ()+    "comment" -> (popContext >> return ())+    "comments" -> return ()+    "char" -> (popContext >> return ())     "string" -> return ()     "infix" -> return ()-    "single_char" -> (popContext >> return ())-    "function_definition" -> (popContext >> return ())     _ -> return ()   lineContents <- lookAhead wholeLine   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Module Name","Normal"),("Keyword","Keyword"),("Function","Function"),("Function Definition","Function"),("Class","Keyword"),("Decimal","DecVal"),("Float","Float"),("Char","Char"),("String","String"),("Constructor","Others"),("Comment","Comment"),("Data Constructor","Keyword"),("Type Constructor","DataType"),("Infix Operator","Others")]+styles = [("Comment","co"),("Pragma","ot"),("Keyword","kw"),("Type Prelude","dt"),("Function Prelude","fu"),("Data Prelude","kw"),("Class Prelude","kw"),("Operator","fu"),("Type","dt"),("Decimal","dv"),("Float","fl"),("Char","ch"),("String","st"),("Function Infix","ot"),("EnumFromTo","ot")]  parseExpressionInternal = do   context <- currentContext   parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes)) -list_keywords = Set.fromList $ words $ "as case class data deriving do else if import in infixl infixr instance let module of primitive qualified then type where"-list_infix_operators = Set.fromList $ words $ "quot rem div mod elem notElem seq"-list_functions = Set.fromList $ words $ "FilePath IOError abs acos acosh all and any appendFile approxRational asTypeOf asin asinh atan atan2 atanh basicIORun break catch ceiling chr compare concat concatMap const cos cosh curry cycle decodeFloat denominator digitToInt div divMod drop dropWhile either elem encodeFloat enumFrom enumFromThen enumFromThenTo enumFromTo error even exp exponent fail filter flip floatDigits floatRadix floatRange floor fmap foldl foldl1 foldr foldr1 fromDouble fromEnum fromInt fromInteger fromIntegral fromRational fst gcd getChar getContents getLine head id inRange index init intToDigit interact ioError isAlpha isAlphaNum isAscii isControl isDenormalized isDigit isHexDigit isIEEE isInfinite isLower isNaN isNegativeZero isOctDigit isPrint isSpace isUpper iterate last lcm length lex lexDigits lexLitChar lines log logBase lookup map mapM mapM_ max maxBound maximum maybe min minBound minimum mod negate not notElem null numerator odd or ord otherwise pi pred primExitWith print product properFraction putChar putStr putStrLn quot quotRem range rangeSize read readDec readFile readFloat readHex readIO readInt readList readLitChar readLn readOct readParen readSigned reads readsPrec realToFrac recip rem repeat replicate return reverse round scaleFloat scanl scanl1 scanr scanr1 seq sequence sequence_ show showChar showInt showList showLitChar showParen showSigned showString shows showsPrec significand signum sin sinh snd span splitAt sqrt subtract succ sum tail take takeWhile tan tanh threadToIOResult toEnum toInt toInteger toLower toRational toUpper truncate uncurry undefined unlines until unwords unzip unzip3 userError words writeFile zip zip3 zipWith zipWith3"-list_type_constructors = Set.fromList $ words $ "Bool Char Double Either Float IO Integer Int Maybe Ordering Rational Ratio ReadS ShowS String"-list_classes = Set.fromList $ words $ "Bounded Enum Eq Floating Fractional Functor Integral Ix Monad Num Ord Read RealFloat RealFrac Real Show"-list_data_constructors = Set.fromList $ words $ "EQ False GT Just LT Left Nothing Right True"+list_keywords = Set.fromList $ words $ "as case class data deriving do else hiding if import in infixl infixr instance let module newtype of primitive qualified then type where"+list_prelude_function = Set.fromList $ words $ "FilePath IOError abs acos acosh all and any appendFile approxRational asTypeOf asin asinh atan atan2 atanh basicIORun break catch ceiling chr compare concat concatMap const cos cosh curry cycle decodeFloat denominator digitToInt div divMod drop dropWhile either elem encodeFloat enumFrom enumFromThen enumFromThenTo enumFromTo error even exp exponent fail filter flip floatDigits floatRadix floatRange floor fmap foldl foldl1 foldr foldr1 fromDouble fromEnum fromInt fromInteger fromIntegral fromRational fst gcd getChar getContents getLine group head id inRange index init intToDigit interact ioError isAlpha isAlphaNum isAscii isControl isDenormalized isDigit isHexDigit isIEEE isInfinite isLower isNaN isNegativeZero isOctDigit isPrint isSpace isUpper iterate last lcm length lex lexDigits lexLitChar lines log logBase lookup map mapM mapM_ max maxBound maximum maybe min minBound minimum mod negate not notElem null numerator odd or ord otherwise pack pi pred primExitWith print product properFraction putChar putStr putStrLn quot quotRem range rangeSize read readDec readFile readFloat readHex readIO readInt readList readLitChar readLn readOct readParen readSigned reads readsPrec realToFrac recip rem repeat replicate return reverse round scaleFloat scanl scanl1 scanr scanr1 seq sequence sequence_ show showChar showInt showList showLitChar showParen showSigned showString shows showsPrec significand signum sin sinh snd sort span splitAt sqrt subtract succ sum tail take takeWhile tan tanh threadToIOResult toEnum toInt toInteger toLower toRational toUpper truncate uncurry undefined unlines until unwords unzip unzip3 userError words writeFile zip zip3 zipWith zipWith3"+list_prelude_class = Set.fromList $ words $ "Bounded Enum Eq Floating Fractional Functor Integral Ix Monad Num Ord Read Real RealFloat RealFrac Show"+list_prelude_type = Set.fromList $ words $ "Bool Char Double Either FilePath Float Int Integer IO IOError Maybe Ordering Ratio Rational ReadS ShowS String ByteString"+list_prelude_data = Set.fromList $ words $ "False True Left Right Just Nothing EQ LT GT" -regex_'2d'2d'24 = compileRegex "--$"-regex_'2d'2d'5b_A'2dZa'2dz0'2d9'5c'2d'2c'3b'60'5d'2e'2a'24 = compileRegex "--[ A-Za-z0-9\\-,;`].*$"-regex_'28'5bA'2dZ'5d'5bA'2dZa'2dz0'2d9'5d'2a'5c'2e'29'2b'5bA'2dZ'5d'5bA'2dZa'2dz0'2d9'5d'2a = compileRegex "([A-Z][A-Za-z0-9]*\\.)+[A-Z][A-Za-z0-9]*"-regex_'5cw'5b'27'5d'2b = compileRegex "\\w[']+"-regex_'5ba'2dz'5f'5d'2b'5cw'2a'27'2a'5cs'2a'3a'3a = compileRegex "[a-z_]+\\w*'*\\s*::"+regex_'5c'7b'2d'23'2e'2a'23'2d'5c'7d = compileRegex "\\{-#.*#-\\}"+regex_'5c'7b'2d'5b'5e'23'5d'3f = compileRegex "\\{-[^#]?"+regex_'2d'2d'5b'5e'5c'2d'21'23'5c'24'25'26'5c'2a'5c'2b'2f'3c'3d'3e'5c'3f'5c'40'5c'5e'5c'7c'7e'5c'2e'3a'5d'2e'2a'24 = compileRegex "--[^\\-!#\\$%&\\*\\+/<=>\\?\\@\\^\\|~\\.:].*$"+regex_'28'3a'3a'7c'3d'3e'7c'5c'2d'3e'7c'3c'5c'2d'29 = compileRegex "(::|=>|\\->|<\\-)"+regex_'5cs'2a'5ba'2dz'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a'5cs'2a'28'3f'3d'3a'3a'5b'5e'5c'2d'21'23'5c'24'25'26'5c'2a'5c'2b'2f'3c'3d'3e'5c'3f'5c'40'5c'5e'5c'7c'7e'5c'2e'3a'5d'29 = compileRegex "\\s*[a-z][a-zA-Z0-9_']*\\s*(?=::[^\\-!#\\$%&\\*\\+/<=>\\?\\@\\^\\|~\\.:])"+regex_'5cs'2a'28'5c'28'5b'5c'2d'21'23'5c'24'25'26'5c'2a'5c'2b'2f'3c'3d'3e'5c'3f'5c'40'5c'5e'5c'7c'7e'5c'2e'3a'5d'2a'5c'29'29'2a'5cs'2a'28'3f'3d'3a'3a'5b'5e'5c'2d'21'23'5c'24'25'26'5c'2a'5c'2b'2f'3c'3d'3e'5c'3f'5c'40'5c'5e'5c'7c'7e'5c'2e'3a'5d'29 = compileRegex "\\s*(\\([\\-!#\\$%&\\*\\+/<=>\\?\\@\\^\\|~\\.:]*\\))*\\s*(?=::[^\\-!#\\$%&\\*\\+/<=>\\?\\@\\^\\|~\\.:])"+regex_'28'5bA'2dZ'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a'5c'2e'29'2a'5ba'2dz'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a = compileRegex "([A-Z][a-zA-Z0-9_']*\\.)*[a-z][a-zA-Z0-9_']*"+regex_'28'5bA'2dZ'5d'5ba'2dzA'2dZ0'2d0'5f'27'5d'2a'5c'2e'29'2a'5b'5c'2d'21'23'5c'24'25'26'5c'2a'5c'2b'2f'3c'3d'3e'5c'3f'5c'40'5c'5e'5c'7c'7e'5c'2e'3a'5d'2b = compileRegex "([A-Z][a-zA-Z0-0_']*\\.)*[\\-!#\\$%&\\*\\+/<=>\\?\\@\\^\\|~\\.:]+"+regex_'28'5bA'2dZ'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a'5c'2e'29'2a'5bA'2dZ'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a = compileRegex "([A-Z][a-zA-Z0-9_']*\\.)*[A-Z][a-zA-Z0-9_']*"+regex_'5cd'2b'5c'2e'5cd'2b = compileRegex "\\d+\\.\\d+" regex_'5c'5c'2e = compileRegex "\\\\." -defaultAttributes = [("normal","Normal Text"),("comment_single_line","Comment"),("comment_multi_line","Comment"),("string","String"),("infix","Infix Operator"),("single_char","Char"),("function_definition","Function Definition")]+defaultAttributes = [("code","Normal"),("comment","Comment"),("comments","Comment"),("char","Char"),("string","String"),("infix","Function Infix")] -parseRules "normal" = -  do (attr, result) <- (((pDetect2Chars False '{' '-' >>= withAttribute "Comment") >>~ pushContext "comment_multi_line")-                        <|>-                        ((pRegExpr regex_'2d'2d'24 >>= withAttribute "Comment") >>~ pushContext "comment_single_line")+parseRules "code" = +  do (attr, result) <- (((pRegExpr regex_'5c'7b'2d'23'2e'2a'23'2d'5c'7d >>= withAttribute "Pragma"))                         <|>-                        ((pRegExpr regex_'2d'2d'5b_A'2dZa'2dz0'2d9'5c'2d'2c'3b'60'5d'2e'2a'24 >>= withAttribute "Comment") >>~ pushContext "comment_single_line")+                        ((pRegExpr regex_'5c'7b'2d'5b'5e'23'5d'3f >>= withAttribute "Comment") >>~ pushContext "comments")                         <|>-                        ((pRegExpr regex_'28'5bA'2dZ'5d'5bA'2dZa'2dz0'2d9'5d'2a'5c'2e'29'2b'5bA'2dZ'5d'5bA'2dZa'2dz0'2d9'5d'2a >>= withAttribute "Module Name"))+                        ((pRegExpr regex_'2d'2d'5b'5e'5c'2d'21'23'5c'24'25'26'5c'2a'5c'2b'2f'3c'3d'3e'5c'3f'5c'40'5c'5e'5c'7c'7e'5c'2e'3a'5d'2e'2a'24 >>= withAttribute "Comment") >>~ pushContext "comment")                         <|>                         ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_keywords >>= withAttribute "Keyword"))                         <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_classes >>= withAttribute "Class"))+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_prelude_function >>= withAttribute "Function Prelude"))                         <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_type_constructors >>= withAttribute "Type Constructor"))+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_prelude_type >>= withAttribute "Type Prelude"))                         <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_functions >>= withAttribute "Function"))+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_prelude_data >>= withAttribute "Data Prelude"))                         <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_data_constructors >>= withAttribute "Data Constructor"))+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_prelude_class >>= withAttribute "Class Prelude"))                         <|>-                        ((pDetectChar False '"' >>= withAttribute "String") >>~ pushContext "string")+                        ((pRegExpr regex_'28'3a'3a'7c'3d'3e'7c'5c'2d'3e'7c'3c'5c'2d'29 >>= withAttribute "Special"))                         <|>-                        ((pDetectChar False '`' >>= withAttribute "Infix Operator") >>~ pushContext "infix")+                        ((pAnyChar "\8594\8592\8658\8704\8707" >>= withAttribute "Special"))                         <|>-                        ((pRegExpr regex_'5cw'5b'27'5d'2b >>= withAttribute "Normal Text"))+                        ((pRegExpr regex_'5cs'2a'5ba'2dz'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a'5cs'2a'28'3f'3d'3a'3a'5b'5e'5c'2d'21'23'5c'24'25'26'5c'2a'5c'2b'2f'3c'3d'3e'5c'3f'5c'40'5c'5e'5c'7c'7e'5c'2e'3a'5d'29 >>= withAttribute "Signature"))                         <|>-                        ((pDetectChar False '\'' >>= withAttribute "Char") >>~ pushContext "single_char")+                        ((pRegExpr regex_'5cs'2a'28'5c'28'5b'5c'2d'21'23'5c'24'25'26'5c'2a'5c'2b'2f'3c'3d'3e'5c'3f'5c'40'5c'5e'5c'7c'7e'5c'2e'3a'5d'2a'5c'29'29'2a'5cs'2a'28'3f'3d'3a'3a'5b'5e'5c'2d'21'23'5c'24'25'26'5c'2a'5c'2b'2f'3c'3d'3e'5c'3f'5c'40'5c'5e'5c'7c'7e'5c'2e'3a'5d'29 >>= withAttribute "Signature"))                         <|>-                        ((pRegExpr regex_'5ba'2dz'5f'5d'2b'5cw'2a'27'2a'5cs'2a'3a'3a >>= withAttribute "Function Definition"))+                        ((pRegExpr regex_'28'5bA'2dZ'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a'5c'2e'29'2a'5ba'2dz'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a >>= withAttribute "Function"))                         <|>-                        ((pFloat >>= withAttribute "Float"))+                        ((pRegExpr regex_'28'5bA'2dZ'5d'5ba'2dzA'2dZ0'2d0'5f'27'5d'2a'5c'2e'29'2a'5b'5c'2d'21'23'5c'24'25'26'5c'2a'5c'2b'2f'3c'3d'3e'5c'3f'5c'40'5c'5e'5c'7c'7e'5c'2e'3a'5d'2b >>= withAttribute "Operator"))                         <|>-                        ((pInt >>= withAttribute "Decimal")))+                        ((pRegExpr regex_'28'5bA'2dZ'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a'5c'2e'29'2a'5bA'2dZ'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a >>= withAttribute "Type"))+                        <|>+                        ((pInt >>= withAttribute "Decimal"))+                        <|>+                        ((pRegExpr regex_'5cd'2b'5c'2e'5cd'2b >>= withAttribute "Float"))+                        <|>+                        ((pDetectChar False '\'' >>= withAttribute "Char") >>~ pushContext "char")+                        <|>+                        ((pDetectChar False '"' >>= withAttribute "String") >>~ pushContext "string")+                        <|>+                        ((pDetectChar False '`' >>= withAttribute "Function Infix") >>~ pushContext "infix")+                        <|>+                        ((pDetect2Chars False '.' '.' >>= withAttribute "EnumFromTo")))      return (attr, result) -parseRules "comment_single_line" = +parseRules "comment" =    pzero -parseRules "comment_multi_line" = +parseRules "comments" =    do (attr, result) <- ((pDetect2Chars False '-' '}' >>= withAttribute "Comment") >>~ (popContext >> return ()))      return (attr, result) +parseRules "char" = +  do (attr, result) <- (((pRegExpr regex_'5c'5c'2e >>= withAttribute "Char"))+                        <|>+                        ((pDetectChar False '\'' >>= withAttribute "Char") >>~ (popContext >> return ())))+     return (attr, result)+ parseRules "string" =    do (attr, result) <- (((pRegExpr regex_'5c'5c'2e >>= withAttribute "String"))                         <|>@@ -142,17 +159,7 @@      return (attr, result)  parseRules "infix" = -  do (attr, result) <- ((pDetectChar False '`' >>= withAttribute "Infix Operator") >>~ (popContext >> return ()))-     return (attr, result)--parseRules "single_char" = -  do (attr, result) <- (((pRegExpr regex_'5c'5c'2e >>= withAttribute "Char"))-                        <|>-                        ((pDetectChar False '\'' >>= withAttribute "Char") >>~ (popContext >> return ())))-     return (attr, result)--parseRules "function_definition" = -  do (attr, result) <- ((pDetectChar False ';' >>= withAttribute "Function Definition") >>~ (popContext >> return ()))+  do (attr, result) <- ((pDetectChar False '`' >>= withAttribute "Function Infix") >>~ (popContext >> return ()))      return (attr, result)  parseRules x = fail $ "Unknown context" ++ x
Text/Highlighting/Kate/Syntax/Html.hs view
@@ -8,10 +8,9 @@ import qualified Text.Highlighting.Kate.Syntax.Css import qualified Text.Highlighting.Kate.Syntax.Javascript import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList)  -- | Full name of language. syntaxName :: String@@ -85,17 +84,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Comment","Comment"),("CDATA","BaseN"),("Processing Instruction","Keyword"),("Doctype","DataType"),("Element","Keyword"),("Attribute","Others"),("Value","String"),("EntityRef","DecVal"),("PEntityRef","DecVal"),("Error","Error")]+styles = [("Comment","co"),("CDATA","bn"),("Processing Instruction","kw"),("Doctype","dt"),("Element","kw"),("Attribute","ot"),("Value","st"),("EntityRef","dv"),("PEntityRef","dv"),("Error","er")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Java.hs view
@@ -6,11 +6,11 @@ import Text.Highlighting.Kate.Common import qualified Text.Highlighting.Kate.Syntax.Javadoc import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "Java"@@ -67,17 +67,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Keyword","Keyword"),("Function","Function"),("StaticImports","Keyword"),("Imports","Keyword"),("Data Type","DataType"),("Decimal","DecVal"),("Octal","BaseN"),("Hex","BaseN"),("Float","Float"),("Char","Char"),("String","String"),("String Char","Char"),("PrintfString","String"),("Comment","Comment"),("Symbol","Normal"),("Java15","Normal")]+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"),("PrintfString","st"),("Comment","co")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Javadoc.hs view
@@ -6,10 +6,9 @@ import Text.Highlighting.Kate.Common import qualified Text.Highlighting.Kate.Syntax.Html import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList)  -- | Full name of language. syntaxName :: String@@ -64,17 +63,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("BlockTag","Keyword"),("InlineTag","Keyword"),("JavadocParam","Keyword"),("SeeTag","Keyword"),("JavadocFS","Comment"),("Javadoc","Comment")]+styles = [("BlockTag","kw"),("InlineTag","kw"),("JavadocParam","kw"),("SeeTag","kw"),("JavadocFS","co"),("Javadoc","co")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Javascript.hs view
@@ -6,11 +6,11 @@ import Text.Highlighting.Kate.Common import qualified Text.Highlighting.Kate.Syntax.Alert import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "JavaScript"@@ -67,17 +67,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Keyword","Keyword"),("Function","Function"),("Objects","Keyword"),("Math","Keyword"),("Events","Keyword"),("Data Type","DataType"),("Decimal","DecVal"),("Float","Float"),("Char","Char"),("String","String"),("String Char","Char"),("Comment","Comment"),("Symbol","Normal"),("Regular Expression","Others"),("Pattern Internal Operator","Float"),("Pattern Character Class","BaseN"),("Region Marker","RegionMarker")]+styles = [("Keyword","kw"),("Function","fu"),("Objects","kw"),("Math","kw"),("Events","kw"),("Data Type","dt"),("Decimal","dv"),("Float","fl"),("Char","ch"),("String","st"),("String Char","ch"),("Comment","co"),("Regular Expression","ot"),("Pattern Internal Operator","fl"),("Pattern Character Class","bn"),("Region Marker","re")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Json.hs view
@@ -5,11 +5,11 @@ import Text.Highlighting.Kate.Definitions import Text.Highlighting.Kate.Common import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "JSON"@@ -61,17 +61,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Style_Normal","Normal"),("Style_Seperator_Pair","Normal"),("Style_Seperator_Array","Normal"),("Style_Decimal","DecVal"),("Style_Float","Float"),("Style_String_Key","DataType"),("Style_String_Value","String"),("Style_String_Key_Char","DataType"),("Style_String_Value_Char","String"),("Style_Keyword","DecVal"),("Style_Error","Error")]+styles = [("Style_Decimal","dv"),("Style_Float","fl"),("Style_String_Key","dt"),("Style_String_Value","st"),("Style_String_Key_Char","dt"),("Style_String_Value_Char","st"),("Style_Keyword","dv"),("Style_Error","er")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Latex.hs view
@@ -5,10 +5,9 @@ import Text.Highlighting.Kate.Definitions import Text.Highlighting.Kate.Common import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList)  -- | Full name of language. syntaxName :: String@@ -93,17 +92,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Keyword","Normal"),("Comment","Comment"),("Error","Alert"),("Math","Normal"),("Structure","Normal"),("Keyword Mathmode","Normal"),("Environment","Normal"),("Verbatim","Normal"),("Region Marker","RegionMarker"),("Bullet","Normal"),("Alert","Alert"),("Structure Text","Normal"),("Structure Keyword","Normal"),("Structure Math","Normal"),("Structure Keyword Mathmode","Normal")]+styles = [("Comment","co"),("Error","al"),("Region Marker","re"),("Alert","al")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Lex.hs view
@@ -6,10 +6,9 @@ import Text.Highlighting.Kate.Common import qualified Text.Highlighting.Kate.Syntax.Cpp import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList)  -- | Full name of language. syntaxName :: String@@ -77,17 +76,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Definition","DataType"),("Comment","Comment"),("Content-Type Delimiter","BaseN"),("Directive","Keyword"),("RegExpr","String"),("Backslash Code","String"),("Alert","Alert")]+styles = [("Definition","dt"),("Comment","co"),("Content-Type Delimiter","bn"),("Directive","kw"),("RegExpr","st"),("Backslash Code","st"),("Alert","al")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/LiterateHaskell.hs view
@@ -1,14 +1,14 @@-{- This module was generated from data in the Kate syntax highlighting file literate-haskell.xml, version 1.04,-   by  Marcel Martin (mmar@freenet.de) -}+{- This module was generated from data in the Kate syntax highlighting file literate-haskell.xml, version 2.0.1,+   by  Nicolas Wu (zenzike@gmail.com) -}  module Text.Highlighting.Kate.Syntax.LiterateHaskell ( highlight, parseExpression, syntaxName, syntaxExtensions ) where import Text.Highlighting.Kate.Definitions import Text.Highlighting.Kate.Common+import qualified Text.Highlighting.Kate.Syntax.Haskell import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList)  -- | Full name of language. syntaxName :: String@@ -31,7 +31,7 @@   st <- getState   let oldLang = synStLanguage st   setState $ st { synStLanguage = "Literate Haskell" }-  context <- currentContext <|> (pushContext "literate-normal" >> currentContext)+  context <- currentContext <|> (pushContext "text" >> currentContext)   result <- parseRules context   updateState $ \st -> st { synStLanguage = oldLang }   return result@@ -42,7 +42,7 @@   result <- manyTill parseSourceLine eof   return $ map normalizeHighlighting result -startingState = SyntaxState {synStContexts = fromList [("Literate Haskell",["literate-normal"])], synStLanguage = "Literate Haskell", synStCurrentLine = "", synStCharsParsedInLine = 0, synStPrevChar = '\n', synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = fromList [("Literate Haskell",["text"])], synStLanguage = "Literate Haskell", synStCurrentLine = "", synStCharsParsedInLine = 0, synStPrevChar = '\n', synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  parseSourceLine = manyTill parseExpressionInternal pEndLine @@ -50,107 +50,72 @@   newline <|> (eof >> return '\n')   context <- currentContext   case context of-    "literate-normal" -> return ()+    "text" -> return ()     "normal" -> (popContext >> return ())-    "comment_single_line" -> (popContext >> popContext >> return ())-    "comment_multi_line" -> return ()-    "string" -> return ()-    "infix" -> return ()-    "single_char" -> (popContext >> return ())-    "function_definition" -> (popContext >> return ())+    "normals" -> return ()+    "comments'" -> pushContext "uncomments"+    "uncomments" -> return ()+    "recomments" -> (popContext >> return ())     _ -> return ()   lineContents <- lookAhead wholeLine   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Keyword","Keyword"),("Function","Function"),("Function Definition","Function"),("Class","Keyword"),("Decimal","DecVal"),("Float","Float"),("Char","Char"),("String","String"),("Constructor","Others"),("Comment","Comment"),("Data Constructor","Keyword"),("Type Constructor","DataType"),("Infix Operator","Others"),("Special","Char")]+styles = [("Comment","co")]  parseExpressionInternal = do   context <- currentContext   parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes)) -list_keywords = Set.fromList $ words $ "case class data deriving do else if in infixl infixr instance let module of primitive then type where"-list_infix_operators = Set.fromList $ words $ "quot rem div mod elem notElem seq"-list_functions = Set.fromList $ words $ "FilePath IOError abs acos acosh all and any appendFile approxRational asTypeOf asin asinh atan atan2 atanh basicIORun break catch ceiling chr compare concat concatMap const cos cosh curry cycle decodeFloat denominator digitToInt div divMod drop dropWhile either elem encodeFloat enumFrom enumFromThen enumFromThenTo enumFromTo error even exp exponent fail filter flip floatDigits floatRadix floatRange floor fmap foldl foldl1 foldr foldr1 fromDouble fromEnum fromInt fromInteger fromIntegral fromRational fst gcd getChar getContents getLine head id inRange index init intToDigit interact ioError isAlpha isAlphaNum isAscii isControl isDenormalized isDigit isHexDigit isIEEE isInfinite isLower isNaN isNegativeZero isOctDigit isPrint isSpace isUpper iterate last lcm length lex lexDigits lexLitChar lines log logBase lookup map mapM mapM_ max maxBound maximum maybe min minBound minimum mod negate not notElem null numerator odd or ord otherwise pi pred primExitWith print product properFraction putChar putStr putStrLn quot quotRem range rangeSize read readDec readFile readFloat readHex readIO readInt readList readLitChar readLn readOct readParen readSigned reads readsPrec realToFrac recip rem repeat replicate return reverse round scaleFloat scanl scanl1 scanr scanr1 seq sequence sequence_ show showChar showInt showList showLitChar showParen showSigned showString shows showsPrec significand signum sin sinh snd span splitAt sqrt subtract succ sum tail take takeWhile tan tanh threadToIOResult toEnum toInt toInteger toLower toRational toUpper truncate uncurry undefined unlines until unwords unzip unzip3 userError words writeFile zip zip3 zipWith zipWith3"-list_type_constructors = Set.fromList $ words $ "Bool Char Double Either Float IO Integer Int Maybe Ordering Rational Ratio ReadS ShowS String"-list_classes = Set.fromList $ words $ "Bounded Enum Eq Floating Fractional Functor Integral Ix Monad Num Ord Read RealFloat RealFrac Real Show"-list_data_constructors = Set.fromList $ words $ "EQ False GT Just LT Left Nothing Right True" -regex_'5cw'5b'27'5d'2b = compileRegex "\\w[']+"-regex_'5cs'2a'5ba'2dz'5f'5d'2b'5cw'2a'27'2a'5cs'2a'3a'3a = compileRegex "\\s*[a-z_]+\\w*'*\\s*::"-regex_'5c'5c'2e = compileRegex "\\\\."--defaultAttributes = [("literate-normal","Comment"),("normal","Normal Text"),("comment_single_line","Comment"),("comment_multi_line","Comment"),("string","String"),("infix","Infix Operator"),("single_char","Char"),("function_definition","Function Definition")]+regex_'5c'7b'2d'5b'5e'23'5d = compileRegex "\\{-[^#]" -parseRules "literate-normal" = -  do (attr, result) <- ((pColumn 0 >> pDetectChar False '>' >>= withAttribute "Special") >>~ pushContext "normal")-     return (attr, result)+defaultAttributes = [("text","Text"),("normal","Normal"),("normals","Normal"),("comments'","Comment"),("uncomments","Text"),("recomments","Comment")] -parseRules "normal" = -  do (attr, result) <- (((pDetect2Chars False '{' '-' >>= withAttribute "Comment") >>~ pushContext "comment_multi_line")-                        <|>-                        ((pDetect2Chars False '-' '-' >>= withAttribute "Comment") >>~ pushContext "comment_single_line")-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_keywords >>= withAttribute "Keyword"))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_classes >>= withAttribute "Class"))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_type_constructors >>= withAttribute "Type Constructor"))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_functions >>= withAttribute "Function"))-                        <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_data_constructors >>= withAttribute "Data Constructor"))-                        <|>-                        ((pDetectChar False '"' >>= withAttribute "String") >>~ pushContext "string")-                        <|>-                        ((pDetectChar False '`' >>= withAttribute "Infix Operator") >>~ pushContext "infix")-                        <|>-                        ((pRegExpr regex_'5cw'5b'27'5d'2b >>= withAttribute "Normal Text"))-                        <|>-                        ((pDetectChar False '\'' >>= withAttribute "Char") >>~ pushContext "single_char")+parseRules "text" = +  do (attr, result) <- (((pColumn 0 >> pDetectChar False '>' >>= withAttribute "BirdTrack") >>~ pushContext "normal")                         <|>-                        ((pRegExpr regex_'5cs'2a'5ba'2dz'5f'5d'2b'5cw'2a'27'2a'5cs'2a'3a'3a >>= withAttribute "Function Definition"))+                        ((pColumn 0 >> pDetectChar False '<' >>= withAttribute "BirdTrack") >>~ pushContext "normal")                         <|>-                        ((pFloat >>= withAttribute "Float"))+                        ((pString False "\\begin{code}" >>= withAttribute "Text") >>~ pushContext "normals")                         <|>-                        ((pInt >>= withAttribute "Decimal")))+                        ((pString False "\\begin{spec}" >>= withAttribute "Text") >>~ pushContext "normals"))      return (attr, result) -parseRules "comment_single_line" = -  pzero--parseRules "comment_multi_line" = -  do (attr, result) <- ((pDetect2Chars False '-' '}' >>= withAttribute "Comment") >>~ (popContext >> return ()))+parseRules "normal" = +  do (attr, result) <- (((pRegExpr regex_'5c'7b'2d'5b'5e'23'5d >>= withAttribute "Comment") >>~ pushContext "comments'")+                        <|>+                        ((Text.Highlighting.Kate.Syntax.Haskell.parseExpression >>= ((withAttribute "") . snd))))      return (attr, result) -parseRules "string" = -  do (attr, result) <- (((pRegExpr regex_'5c'5c'2e >>= withAttribute "String"))+parseRules "normals" = +  do (attr, result) <- (((pString False "\\end{code}" >>= withAttribute "Normal") >>~ (popContext >> return ()))                         <|>-                        ((pDetectChar False '"' >>= withAttribute "String") >>~ (popContext >> return ())))+                        ((pString False "\\end{spec}" >>= withAttribute "Normal") >>~ (popContext >> return ()))+                        <|>+                        ((Text.Highlighting.Kate.Syntax.Haskell.parseExpression >>= ((withAttribute "") . snd))))      return (attr, result) -parseRules "infix" = -  do (attr, result) <- ((pDetectChar False '`' >>= withAttribute "Infix Operator") >>~ (popContext >> return ()))+parseRules "comments'" = +  do (attr, result) <- ((pDetect2Chars False '-' '}' >>= withAttribute "Comment") >>~ (popContext >> return ()))      return (attr, result) -parseRules "single_char" = -  do (attr, result) <- (((pRegExpr regex_'5c'5c'2e >>= withAttribute "Char"))+parseRules "uncomments" = +  do (attr, result) <- (((pColumn 0 >> pDetectChar False '>' >>= withAttribute "BirdTrack") >>~ pushContext "recomments")                         <|>-                        ((pDetectChar False '\'' >>= withAttribute "Char") >>~ (popContext >> return ())))+                        ((pColumn 0 >> pDetectChar False '<' >>= withAttribute "BirdTrack") >>~ pushContext "recomments"))      return (attr, result) -parseRules "function_definition" = -  do (attr, result) <- ((pDetectChar False ';' >>= withAttribute "Function Definition") >>~ (popContext >> return ()))+parseRules "recomments" = +  do (attr, result) <- ((pDetect2Chars False '-' '}' >>= withAttribute "Comment") >>~ (popContext >> popContext >> popContext >> return ()))      return (attr, result)  parseRules x = fail $ "Unknown context" ++ x
Text/Highlighting/Kate/Syntax/Lua.hs view
@@ -6,11 +6,11 @@ import Text.Highlighting.Kate.Common import qualified Text.Highlighting.Kate.Syntax.Doxygen import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "Lua"@@ -63,17 +63,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Alerts","Alert"),("BFunc","Function"),("Comment","Comment"),("Constant","Keyword"),("Control","Keyword"),("Error","Error"),("Keyword","Keyword"),("Normal Text","Normal"),("Numbers","DecVal"),("Strings","String"),("Symbols","Others"),("Variable","Keyword")]+styles = [("Alerts","al"),("BFunc","fu"),("Comment","co"),("Constant","kw"),("Control","kw"),("Error","er"),("Keyword","kw"),("Numbers","dv"),("Strings","st"),("Symbols","ot"),("Variable","kw")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Makefile.hs view
@@ -5,11 +5,11 @@ import Text.Highlighting.Kate.Definitions import Text.Highlighting.Kate.Common import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "Makefile"@@ -61,17 +61,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Keyword","Keyword"),("Comment","Comment"),("String","String"),("Variable","DataType"),("Target","DecVal"),("Section","Others"),("Operator","Char"),("Commands","BaseN"),("Special","Float")]+styles = [("Keyword","kw"),("Comment","co"),("String","st"),("Variable","dt"),("Target","dv"),("Section","ot"),("Operator","ch"),("Commands","bn"),("Special","fl")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Matlab.hs view
@@ -5,11 +5,11 @@ import Text.Highlighting.Kate.Definitions import Text.Highlighting.Kate.Common import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "Matlab"@@ -57,17 +57,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Variable","Normal"),("Operator","Normal"),("Number","Float"),("Delimiter","Normal"),("String","String"),("System","BaseN"),("Incomplete String","Char"),("Keyword","Normal"),("Comment","Comment")]+styles = [("Number","fl"),("String","st"),("System","bn"),("Incomplete String","ch"),("Comment","co")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Mediawiki.hs view
@@ -5,10 +5,9 @@ import Text.Highlighting.Kate.Definitions import Text.Highlighting.Kate.Common import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList)  -- | Full name of language. syntaxName :: String@@ -67,17 +66,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal","Normal"),("Link","Others"),("URL","Others"),("Comment","Comment"),("Section","Keyword"),("HTML-Entity","DecVal"),("HTML-Tag","Keyword"),("Wiki-Tag","DecVal"),("Error","Error"),("NoWiki","Normal"),("Unformatted","Normal")]+styles = [("Link","ot"),("URL","ot"),("Comment","co"),("Section","kw"),("HTML-Entity","dv"),("HTML-Tag","kw"),("Wiki-Tag","dv"),("Error","er")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Modula3.hs view
@@ -5,11 +5,11 @@ import Text.Highlighting.Kate.Definitions import Text.Highlighting.Kate.Common import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "Modula-3"@@ -59,17 +59,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Keyword","Keyword"),("Operator","Keyword"),("Type","DataType"),("Integer","BaseN"),("Real","Float"),("Constant","DecVal"),("String","String"),("Char","Char"),("Pervasive","Function"),("StdLib","Function"),("Comment","Comment"),("Pragma","Others")]+styles = [("Keyword","kw"),("Operator","kw"),("Type","dt"),("Integer","bn"),("Real","fl"),("Constant","dv"),("String","st"),("Char","ch"),("Pervasive","fu"),("StdLib","fu"),("Comment","co"),("Pragma","ot")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Nasm.hs view
@@ -5,11 +5,11 @@ import Text.Highlighting.Kate.Definitions import Text.Highlighting.Kate.Common import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "Intel x86 (NASM)"@@ -59,17 +59,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Registers","Keyword"),("Instructions","Keyword"),("NASM Keywords","Keyword"),("Comment","Comment"),("Label","Function"),("Data","DataType"),("BaseN","BaseN"),("Float","Float"),("Number","DecVal"),("Char","Char"),("String","String"),("Preprocessor","Others")]+styles = [("Registers","kw"),("Instructions","kw"),("NASM Keywords","kw"),("Comment","co"),("Label","fu"),("Data","dt"),("BaseN","bn"),("Float","fl"),("Number","dv"),("Char","ch"),("String","st"),("Preprocessor","ot")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Objectivec.hs view
@@ -6,11 +6,11 @@ import Text.Highlighting.Kate.Common import qualified Text.Highlighting.Kate.Syntax.Doxygen import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "Objective-C"@@ -62,17 +62,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Keyword","Keyword"),("Data Type","DataType"),("Decimal","DecVal"),("Octal","BaseN"),("Hex","BaseN"),("Float","Float"),("Char","Char"),("String","String"),("String Char","Char"),("Comment","Comment"),("Symbol","Normal"),("Preprocessor","Others"),("Prep. Lib","Others")]+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")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Ocaml.hs view
@@ -5,11 +5,11 @@ import Text.Highlighting.Kate.Definitions import Text.Highlighting.Kate.Common import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "Objective Caml"@@ -59,17 +59,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Identifier","Normal"),("Keyword","Keyword"),("Revised Syntax Keyword","Normal"),("Core Data Type","DataType"),("Decimal","DecVal"),("Hexadecimal","BaseN"),("Octal","BaseN"),("Binary","BaseN"),("Float","Float"),("Character","Char"),("String","String"),("Escaped characters","Char"),("Comment","Comment"),("Camlp4 Quotation","String"),("Directive","Others")]+styles = [("Keyword","kw"),("Core Data Type","dt"),("Decimal","dv"),("Hexadecimal","bn"),("Octal","bn"),("Binary","bn"),("Float","fl"),("Character","ch"),("String","st"),("Escaped characters","ch"),("Comment","co"),("Camlp4 Quotation","st"),("Directive","ot")]  parseExpressionInternal = do   context <- currentContext
+ Text/Highlighting/Kate/Syntax/Octave.hs view
@@ -0,0 +1,216 @@+{- This module was generated from data in the Kate syntax highlighting file octave.xml, version 1.01,+   by  Luis Silvestre and Federico Zenith -}++module Text.Highlighting.Kate.Syntax.Octave ( highlight, parseExpression, syntaxName, syntaxExtensions ) where+import Text.Highlighting.Kate.Definitions+import Text.Highlighting.Kate.Common+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 = "Octave"++-- | Filename extensions for this language.+syntaxExtensions :: String+syntaxExtensions = "*.octave;*.m;*.M"++-- | 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 = "Octave" }+  context <- currentContext <|> (pushContext "_normal" >> 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 [("Octave",["_normal"])], synStLanguage = "Octave", synStCurrentLine = "", synStCharsParsedInLine = 0, synStPrevChar = '\n', synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}++parseSourceLine = manyTill parseExpressionInternal pEndLine++pEndLine = do+  newline <|> (eof >> return '\n')+  context <- currentContext+  case context of+    "_normal" -> return ()+    "_adjoint" -> (popContext >> return ())+    _ -> return ()+  lineContents <- lookAhead wholeLine+  updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }++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 = [("Number","fl"),("String","st"),("String Char","ch"),("Incomplete String","ch"),("Comment","co"),("Functions","fu"),("Forge","fu"),("Builtin","bn"),("Commands","fu")]++parseExpressionInternal = do+  context <- currentContext+  parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes))++list_keywords = Set.fromList $ words $ "all_va_args break case continue else elseif end_unwind_protect global gplot gsplot otherwise persistent replot return static until unwind_protect unwind_protect_cleanup varargin varargout"+list_builtin = Set.fromList $ words $ "argv e eps false F_DUPFD F_GETFD F_GETFL filesep F_SETFD F_SETFL i I inf Inf j J NA nan NaN O_APPEND O_ASYNC O_CREAT OCTAVE_HOME OCTAVE_VERSION O_EXCL O_NONBLOCK O_RDONLY O_RDWR O_SYNC O_TRUNC O_WRONLY pi program_invocation_name program_name P_tmpdir realmax realmin SEEK_CUR SEEK_END SEEK_SET SIG stderr stdin stdout true ans automatic_replot beep_on_error completion_append_char crash_dumps_octave_core current_script_file_name debug_on_error debug_on_interrupt debug_on_warning debug_symtab_lookups DEFAULT_EXEC_PATH DEFAULT_LOADPATH default_save_format echo_executing_commands EDITOR EXEC_PATH FFTW_WISDOM_PROGRAM fixed_point_format gnuplot_binary gnuplot_command_axes gnuplot_command_end gnuplot_command_plot gnuplot_command_replot gnuplot_command_splot gnuplot_command_title gnuplot_command_using gnuplot_command_with gnuplot_has_frames history_file history_size ignore_function_time_stamp IMAGEPATH INFO_FILE INFO_PROGRAM __kluge_procbuf_delay__ LOADPATH MAKEINFO_PROGRAM max_recursion_depth octave_core_file_format octave_core_file_limit octave_core_file_name output_max_field_width output_precision page_output_immediately PAGER page_screen_output print_answer_id_name print_empty_dimensions print_rhs_assign_val PS1 PS2 PS4 save_header_format_string save_precision saving_history sighup_dumps_octave_core sigterm_dumps_octave_core silent_functions split_long_rows string_fill_char struct_levels_to_print suppress_verbose_help_message variables_can_hide_functions warn_assign_as_truth_value warn_divide_by_zero warn_empty_list_elements warn_fortran_indexing warn_function_name_clash warn_future_time_stamp warn_imag_to_real warn_matlab_incompatible warn_missing_semicolon warn_neg_dim_as_zero warn_num_to_str warn_precedence_change warn_reload_forces_clear warn_resize_on_range_error warn_separator_insert warn_single_quote_string warn_str_to_num warn_undefined_return_values warn_variable_switch_label whos_line_format"+list_commands = Set.fromList $ words $ "casesen cd chdir clear dbclear dbstatus dbstop dbtype dbwhere diary echo edit_history __end__ format gset gshow help history hold iskeyword isvarname load ls mark_as_command mislocked mlock more munlock run_history save set show type unmark_command which who whos"+list_functions = Set.fromList $ words $ "abs acos acosh all angle any append arg argnames asin asinh assignin atan atan2 atanh atexit bitand bitmax bitor bitshift bitxor casesen cat cd ceil cell cell2struct cellstr char chdir class clc clear clearplot clg closeplot completion_matches conj conv convmtx cos cosh cumprod cumsum dbclear dbstatus dbstop dbtype dbwhere deconv det dftmtx diag diary disp document do_string_escapes double dup2 echo edit_history __end__ erf erfc ERRNO error __error_text__ error_text eval evalin exec exist exit exp eye fclose fcntl fdisp feof ferror feval fflush fft fgetl fgets fieldnames file_in_loadpath file_in_path filter find find_first_of_in_loadpath finite fix floor fmod fnmatch fopen fork format formula fprintf fputs fread freport frewind fscanf fseek ftell func2str functions fwrite gamma gammaln getegid getenv geteuid getgid getpgrp getpid getppid getuid glob graw gset gshow help history hold home horzcat ifft imag inline input input_event_hook int16 int32 int64 int8 intmax intmin inv inverse ipermute isalnum isalpha isascii isbool iscell iscellstr ischar iscntrl iscomplex isdigit isempty isfield isfinite isglobal isgraph ishold isieee isinf iskeyword islist islogical islower ismatrix isna isnan is_nan_or_na isnumeric isprint ispunct isreal isspace isstream isstreamoff isstruct isupper isvarname isxdigit kbhit keyboard kill lasterr lastwarn length lgamma link linspace list load log log10 ls lstat lu mark_as_command mislocked mkdir mkfifo mkstemp mlock more munlock nargin nargout native_float_format ndims nth numel octave_config_info octave_tmp_file_name ones pause pclose permute pipe popen printf __print_symbol_info__ __print_symtab_info__ prod purge_tmp_files putenv puts pwd quit rank readdir readlink read_readline_init_file real rehash rename reshape reverse rmdir rmfield roots round run_history save scanf set shell_cmd show sign sin sinh size sizeof sleep sort source splice sprintf sqrt squeeze sscanf stat str2func streamoff struct struct2cell sum sumsq symlink system tan tanh tilde_expand tmpfile tmpnam toascii __token_count__ tolower toupper type typeinfo uint16 uint32 uint64 uint8 umask undo_string_escapes unlink unmark_command usage usleep va_arg va_start vectorize vertcat vr_val waitpid warning warranty which who whos zeros airy balance besselh besseli besselj besselk bessely betainc chol colloc daspk daspk_options dasrt dasrt_options dassl dassl_options det eig endgrent endpwent expm fft fft2 fftn fftw_wisdom filter find fsolve fsolve_options gammainc gcd getgrent getgrgid getgrnam getpwent getpwnam getpwuid getrusage givens gmtime hess ifft ifft2 ifftn inv inverse kron localtime lpsolve lpsolve_options lsode lsode_options lu max min minmax mktime odessa odessa_options pinv qr quad quad_options qz rand randn schur setgrent setpwent sort sqrtm strftime strptime svd syl time abcddim __abcddims__ acot acoth acsc acsch analdemo anova arch_fit arch_rnd arch_test are arma_rnd asctime asec asech autocor autocov autoreg_matrix axis axis2dlim __axis_label__ bar bartlett bartlett_test base2dec bddemo beep bessel beta beta_cdf betai beta_inv beta_pdf beta_rnd bin2dec bincoeff binomial_cdf binomial_inv binomial_pdf binomial_rnd bitcmp bitget bitset blackman blanks bode bode_bounds __bodquist__ bottom_title bug_report buildssic c2d cart2pol cart2sph cauchy_cdf cauchy_inv cauchy_pdf cauchy_rnd cellidx center chisquare_cdf chisquare_inv chisquare_pdf chisquare_rnd chisquare_test_homogeneity chisquare_test_independence circshift clock cloglog close colormap columns com2str comma common_size commutation_matrix compan complement computer cond contour controldemo conv cor corrcoef cor_test cot coth cov cputime create_set cross csc csch ctime ctrb cut d2c damp dare date dcgain deal deblank dec2base dec2bin dec2hex deconv delete DEMOcontrol demoquat detrend dezero dgkfdemo dgram dhinfdemo diff diffpara dir discrete_cdf discrete_inv discrete_pdf discrete_rnd dkalman dlqe dlqg dlqr dlyap dmr2d dmult dot dre dump_prefs duplication_matrix durbinlevinson empirical_cdf empirical_inv empirical_pdf empirical_rnd erfinv __errcomm__ errorbar __errplot__ etime exponential_cdf exponential_inv exponential_pdf exponential_rnd f_cdf fftconv fftfilt fftshift figure fileparts findstr f_inv fir2sys flipdim fliplr flipud flops f_pdf fractdiff frdemo freqchkw __freqresp__ freqz freqz_plot f_rnd f_test_regression fullfile fv fvl gamma_cdf gammai gamma_inv gamma_pdf gamma_rnd geometric_cdf geometric_inv geometric_pdf geometric_rnd gls gram gray gray2ind grid h2norm h2syn hamming hankel hanning hex2dec hilb hinf_ctr hinfdemo hinfnorm hinfsyn hinfsyn_chk hinfsyn_ric hist hotelling_test hotelling_test_2 housh hsv2rgb hurst hypergeometric_cdf hypergeometric_inv hypergeometric_pdf hypergeometric_rnd image imagesc impulse imshow ind2gray ind2rgb ind2sub index int2str intersection invhilb iqr irr isa is_abcd is_bool is_complex is_controllable isdefinite is_detectable is_dgkf is_digital is_duplicate_entry is_global is_leap_year isletter is_list is_matrix is_observable ispc is_sample is_scalar isscalar is_signal_list is_siso is_square issquare is_stabilizable is_stable isstr is_stream is_struct is_symmetric issymmetric isunix is_vector isvector jet707 kendall kolmogorov_smirnov_cdf kolmogorov_smirnov_test kolmogorov_smirnov_test_2 kruskal_wallis_test krylov krylovb kurtosis laplace_cdf laplace_inv laplace_pdf laplace_rnd lcm lin2mu listidx list_primes loadaudio loadimage log2 logical logistic_cdf logistic_inv logistic_pdf logistic_regression logistic_regression_derivatives logistic_regression_likelihood logistic_rnd logit loglog loglogerr logm lognormal_cdf lognormal_inv lognormal_pdf lognormal_rnd logspace lower lqe lqg lqr lsim ltifr lyap mahalanobis manova mcnemar_test mean meansq median menu mesh meshdom meshgrid minfo mod moddemo moment mplot mu2lin multiplot nargchk nextpow2 nichols norm normal_cdf normal_inv normal_pdf normal_rnd not nper npv ntsc2rgb null num2str nyquist obsv ocean ols oneplot ord2 orth __outlist__ pack packedform packsys parallel paren pascal_cdf pascal_inv pascal_pdf pascal_rnd path periodogram perror place playaudio plot plot_border __plr__ __plr1__ __plr2__ __plt__ __plt1__ __plt2__ __plt2mm__ __plt2mv__ __plt2ss__ __plt2vm__ __plt2vv__ __pltopt__ __pltopt1__ pmt poisson_cdf poisson_inv poisson_pdf poisson_rnd pol2cart polar poly polyder polyderiv polyfit polyinteg polyout polyreduce polyval polyvalm popen2 postpad pow2 ppplot prepad probit prompt prop_test_2 pv pvl pzmap qconj qcoordinate_plot qderiv qderivmat qinv qmult qqplot qtrans qtransv qtransvmat quaternion qzhess qzval randperm range rank ranks rate record rectangle_lw rectangle_sw rem repmat residue rgb2hsv rgb2ind rgb2ntsc rindex rldemo rlocus roots rot90 rotdim rotg rows run_cmd run_count run_test saveaudio saveimage sec sech semicolon semilogx semilogxerr semilogy semilogyerr series setaudio setstr shg shift shiftdim sign_test sinc sinetone sinewave skewness sombrero sortcom spearman spectral_adf spectral_xdf spencer sph2cart split ss ss2sys ss2tf ss2zp stairs starp statistics std stdnormal_cdf stdnormal_inv stdnormal_pdf stdnormal_rnd step __stepimp__ stft str2mat str2num strappend strcat strcmp strerror strjust strrep struct_contains struct_elements studentize sub2ind subplot substr subwindow swap swapcols swaprows sylvester_matrix synthesis sys2fir sys2ss sys2tf sys2zp sysadd sysappend syschnames __syschnamesl__ syschtsam __sysconcat__ sysconnect syscont __syscont_disc__ __sysdefioname__ __sysdefstname__ sysdimensions sysdisc sysdup sysgetsignals sysgettsam sysgettype sysgroup __sysgroupn__ sysidx sysmin sysmult sysout sysprune sysreorder sysrepdemo sysscale syssetsignals syssub sysupdate table t_cdf tempdir tempname texas_lotto tf tf2ss tf2sys __tf2sysl__ tf2zp __tfl__ tfout tic t_inv title toc toeplitz top_title t_pdf trace triangle_lw triangle_sw tril triu t_rnd t_test t_test_2 t_test_regression tzero tzero2 ugain uniform_cdf uniform_inv uniform_pdf uniform_rnd union unix unpacksys unwrap upper u_test values vander var var_test vec vech version vol weibull_cdf weibull_inv weibull_pdf weibull_rnd welch_test wgt1o wiener_rnd wilcoxon_test xlabel xor ylabel yulewalker zgfmul zgfslv zginit __zgpbal__ zgreduce zgrownorm zgscal zgsgiv zgshsr zlabel zp zp2ss __zp2ssg2__ zp2sys zp2tf zpout z_test z_test_2"+list_forge = Set.fromList $ words $ "airy_Ai airy_Ai_deriv airy_Ai_deriv_scaled airy_Ai_scaled airy_Bi airy_Bi_deriv airy_Bi_deriv_scaled airy_Bi_scaled airy_zero_Ai airy_zero_Ai_deriv airy_zero_Bi airy_zero_Bi_deriv atanint bchdeco bchenco bessel_il_scaled bessel_In bessel_In_scaled bessel_Inu bessel_Inu_scaled bessel_jl bessel_Jn bessel_Jnu bessel_kl_scaled bessel_Kn bessel_Kn_scaled bessel_Knu bessel_Knu_scaled bessel_lnKnu bessel_yl bessel_Yn bessel_Ynu bessel_zero_J0 bessel_zero_J1 beta_gsl bfgsmin bisectionstep builtin bwfill bwlabel cell2csv celleval Chi chol Ci clausen conicalP_0 conicalP_1 conicalP_half conicalP_mhalf conv2 cordflt2 coupling_3j coupling_6j coupling_9j csv2cell csvconcat csvexplode cyclgen cyclpoly dawson debye_1 debye_2 debye_3 debye_4 deref dispatch dispatch_help display_fixed_operations dlmread ellint_Ecomp ellint_Kcomp ellipj erfc_gsl erf_gsl erf_Q erf_Z _errcore eta eta_int expint_3 expint_E1 expint_E2 expint_Ei expm1 exp_mult exprel exprel_2 exprel_n fabs fangle farg fatan2 fceil fconj fcos fcosh fcumprod fcumsum fdiag fermi_dirac_3half fermi_dirac_half fermi_dirac_inc_0 fermi_dirac_int fermi_dirac_mhalf fexp ffloor fimag finitedifference fixed flog flog10 fprod freal freshape fround fsin fsinh fsqrt fsum fsumsq ftan ftanh full gamma_gsl gamma_inc gamma_inc_P gamma_inc_Q gammainv_gsl gammastar gdet gdiag gexp gf gfilter _gfweight ginv ginverse glog glu gpick gprod grab grank graycomatrix __grcla__ __grclf__ __grcmd__ greshape __grexit__ __grfigure__ __grgetstat__ __grhold__ __grinit__ __grishold__ __grnewset__ __grsetgraph__ gsl_sf gsqrt gsum gsumsq gtext gzoom hazard houghtf hyperg_0F1 hzeta is_complex_sparse isfixed isgalois isprimitive is_real_sparse is_sparse jpgread jpgwrite lambert_W0 lambert_Wm1 legendre_Pl legendre_Plm legendre_Ql legendre_sphPlm legendre_sphPlm_array leval listen lnbeta lncosh lngamma_gsl lnpoch lnsinh log_1plusx log_1plusx_mx log_erfc lp make_sparse mark_for_deletion medfilt1 newtonstep nnz numgradient numhessian pchip_deriv pngread pngwrite poch pochrel pretty primpoly psi psi_1_int psi_1piy psi_n rand rande randn randp regexp remez reset_fixed_operations rotate_scale rsdec rsenc samin SBBacksub SBEig SBFactor SBProd SBSolve Shi Si sinc_gsl spabs sparse spfind spimag spinv splu spreal SymBand synchrotron_1 synchrotron_2 syndtable taylorcoeff transport_2 transport_3 transport_4 transport_5 trisolve waitbar xmlread zeta zeta_int aar aarmam ac2poly ac2rc acorf acovf addpath ademodce adim adsmax amodce anderson_darling_cdf anderson_darling_test anovan apkconst append_save applylut ar2poly ar2rc arburg arcext arfit2 ar_spa aryule assert au aucapture auload auplot aurecord ausave autumn average_moments awgn azimuth BandToFull BandToSparse base64encode battery bchpoly bestblk best_dir best_dir_cov betaln bfgs bfgsmin_example bi2de biacovf bilinear bisdemo bispec biterr blkdiag blkproc bmpwrite bone bound_convex boxcar boxplot brighten bs_gradient butter buttord bwborder bweuler bwlabel bwmorph bwselect calendar cceps cdiff cellstr char cheb cheb1ord cheb2ord chebwin cheby1 cheby2 chirp clf clip cmpermute cmunique cohere col2im colfilt colorgradient comms compand complex concat conndef content contents Contents contourf convhull convmtx cool copper corr2 cosets count covm cplxpair cquadnd create_lookup_table crule crule2d crule2dgen csape csapi csd csvread csvwrite ctranspose cumtrapz czt d2_min datenum datestr datevec dct dct2 dctmtx de2bi deal decimate decode deg2rad del2 delaunay delaunay3 delta_method demo demodmap deriv detrend dfdp dftmtx dhbar dilate dispatch distance dlmread dlmwrite dos double drawnow durlev dxfwrite edge edit ellip ellipdemo ellipj ellipke ellipord __ellip_ws __ellip_ws_min encode eomday erode example ExampleEigenValues ExampleGenEigenValues expdemo expfit eyediagram factor factorial fail fcnchk feedback fem_test ff2n fftconv2 fieldnames fill fill3 filter2 filtfilt filtic findsym fir1 fir2 fixedpoint flag flag_implicit_samplerate flattopwin flix float fmin fminbnd fmins fminunc fnder fnplt fnval fplot freqs freqs_plot fsort fullfact FullToBand funm fzero gammaln gapTest gaussian gausswin gconv gconvmtx gdeconv gdftmtx gen2par geomean getfield getfields gfft gftable gfweight gget gifft ginput gmm_estimate gmm_example gmm_obj gmm_results gmm_variance gmm_variance_inefficient gquad gquad2d gquad2d6 gquad2dgen gquad6 gquadnd grace_octave_path gradient grayslice grep grid griddata groots grpdelay grule grule2d grule2dgen hadamard hammgen hankel hann harmmean hilbert histeq histfit histo histo2 histo3 histo4 hot hsv hup idct idct2 idplot idsim ifftshift im2bw im2col imadjust imginfo imhist imnoise impad impz imread imrotate imshear imtranslate imwrite innerfun inputname interp interp1 interp2 interpft intersect invest0 invest1 invfdemo invfreq invfreqs invfreqz inz irsa_act irsa_actcore irsa_check irsa_dft irsa_dftfp irsa_genreal irsa_idft irsa_isregular irsa_jitsp irsa_mdsp irsa_normalize irsa_plotdft irsa_resample irsa_rgenreal isa isbw isdir isequal isfield isgray isind ismember isprime isrgb issparse isunix jet kaiser kaiserord lambertw lattice lauchli leasqr leasqrdemo legend legendre levinson lin2mu line_min lloyds lookup lookup_table lpc lp_test mad magic makelut MakeShears map mat2gray mat2str mdsmax mean2 medfilt2 meshc minimize minpol mkpp mktheta mle_estimate mle_example mle_obj mle_results mle_variance modmap mu2lin mvaar mvar mvfilter mvfreqz myfeval nanmax nanmean nanmedian nanmin nanstd nansum ncauer nchoosek ncrule ndims nelder_mead_min newmark nlfilter nlnewmark __nlnewmark_fcn__ nmsmax nonzeros normplot now nrm nthroot nze OCTAVE_FORGE_VERSION ode23 ode45 ode78 optimset ordfilt2 orient pacf padarray parameterize parcor pareto pascal patch pburg pcg pchip pcolor pcr peaks penddot pendulum perms pie pink plot3 __plt3__ poly2ac poly2ar poly_2_ex poly2mask poly2rc poly2sym poly2th polyarea polyconf polyder polyderiv polygcd polystab __power ppval prctile prettyprint prettyprint_c primes princomp print prism proplan pulstran pwelch pyulear qaskdeco qaskenco qtdecomp qtgetblk qtsetblk quad2dc quad2dcgen quad2dg quad2dggen quadc quadg quadl quadndg quantiz quiver rad2deg rainbow randerr randint randsrc rat rats rc2ac rc2ar rc2poly rceps read_options read_pdb rectpuls resample rgb2gray rk2fixed rk4fixed rk8fixed rmfield rmle rmpath roicolor rosser rotparams rotv rref rsdecof rsencof rsgenpoly samin_example save_vrml sbispec scale_data scatter scatterplot select_3D_points selmo setdiff setfield setfields setxor sftrans sgolay sgolayfilt sinvest1 slurp_file sortrows sound soundsc spdiags specgram speed speye spfun sphcat spline splot spones sprand sprandn spring spstats spsum sp_test sptest spvcat spy std2 stem str2double strcmpi stretchlim strfind strmatch strncmp strncmpi strsort strtok strtoz struct strvcat summer sumskipnan surf surfc sym2poly symerr symfsolve tabulate tar temp_name test test_d2_min_1 test_d2_min_2 test_d2_min_3 test_ellipj test_fminunc_1 testimio test_inline_1 test_min_1 test_min_2 test_min_3 test_min_4 test_minimize_1 test_nelder_mead_min_1 test_nelder_mead_min_2 test_sncndn test_struct test_vmesh test_vrml_faces test_wpolyfit text textread tf2zp tfe thfm tics toeplitz toggle_grace_use transpose trapz triang tril trimmean tripuls trisolve triu tsademo tsearchdemo ucp uintlut unique unix unmkpp unscale_parameters vec2mat view vmesh voronoi voronoin vrml_arrow vrml_Background vrml_browse vrml_cyl vrml_demo_tutorial_1 vrml_demo_tutorial_2 vrml_demo_tutorial_3 vrml_demo_tutorial_4 vrml_ellipsoid vrml_faces vrml_flatten vrml_frame vrml_group vrml_kill vrml_lines vrml_material vrml_parallelogram vrml_PointLight vrml_points vrml_select_points vrml_surf vrml_text vrml_thick_surf vrml_transfo wavread wavwrite weekday wgn white wilkinson winter wpolyfit wpolyfitdemo write_pdb wsolve xcorr xcorr2 xcov xlsread xmlwrite y2res zero_count zoom zp2tf zplane zscore"++regex_'5cb'28for'29'5cb = compileRegex "\\b(for)\\b"+regex_'5cb'28endfor'29'5cb = compileRegex "\\b(endfor)\\b"+regex_'5cb'28if'29'5cb = compileRegex "\\b(if)\\b"+regex_'5cb'28endif'29'5cb = compileRegex "\\b(endif)\\b"+regex_'5cb'28do'29'5cb = compileRegex "\\b(do)\\b"+regex_'5cb'28until'29'5cb = compileRegex "\\b(until)\\b"+regex_'5cb'28while'29'5cb = compileRegex "\\b(while)\\b"+regex_'5cb'28endwhile'29'5cb = compileRegex "\\b(endwhile)\\b"+regex_'5cb'28function'29'5cb = compileRegex "\\b(function)\\b"+regex_'5cb'28endfunction'29'5cb = compileRegex "\\b(endfunction)\\b"+regex_'5cb'28switch'29'5cb = compileRegex "\\b(switch)\\b"+regex_'5cb'28endswitch'29'5cb = compileRegex "\\b(endswitch)\\b"+regex_'5cb'28try'29'5cb = compileRegex "\\b(try)\\b"+regex_'5cb'28end'5ftry'5fcatch'29'5cb = compileRegex "\\b(end_try_catch)\\b"+regex_'5cb'28end'29'5cb = compileRegex "\\b(end)\\b"+regex_'5ba'2dzA'2dZ'5d'5cw'2a'28'3f'3d'27'29 = compileRegex "[a-zA-Z]\\w*(?=')"+regex_'28'5cd'2b'28'5c'2e'5cd'2b'29'3f'7c'5c'2e'5cd'2b'29'28'5beE'5d'5b'2b'2d'5d'3f'5cd'2b'29'3f'5bij'5d'3f'28'3f'3d'27'29 = compileRegex "(\\d+(\\.\\d+)?|\\.\\d+)([eE][+-]?\\d+)?[ij]?(?=')"+regex_'5b'5c'29'5c'5d'7d'5d'28'3f'3d'27'29 = compileRegex "[\\)\\]}](?=')"+regex_'5c'2e'27'28'3f'3d'27'29 = compileRegex "\\.'(?=')"+regex_'27'28'5b'5e'27'5c'5c'5d'7c'27'27'7c'5c'5c'27'7c'5c'5c'5b'5e'27'5d'29'2a'27'28'3f'3d'5b'5e'27'5d'7c'24'29 = compileRegex "'([^'\\\\]|''|\\\\'|\\\\[^'])*'(?=[^']|$)"+regex_'27'28'5b'5e'27'5d'7c'27'27'7c'5c'5c'27'29'2a = compileRegex "'([^']|''|\\\\')*"+regex_'22'28'5b'5e'22'5c'5c'5d'7c'22'22'7c'5c'5c'22'7c'5c'5c'5b'5e'22'5d'29'2a'22'28'3f'3d'5b'5e'22'5d'7c'24'29 = compileRegex "\"([^\"\\\\]|\"\"|\\\\\"|\\\\[^\"])*\"(?=[^\"]|$)"+regex_'22'28'5b'5e'22'5d'7c'22'22'7c'5c'5c'22'29'2a = compileRegex "\"([^\"]|\"\"|\\\\\")*"+regex_'5b'25'23'5d'2e'2a'24 = compileRegex "[%#].*$"+regex_'5ba'2dzA'2dZ'5d'5cw'2a = compileRegex "[a-zA-Z]\\w*"+regex_'28'5cd'2b'28'5c'2e'5cd'2b'29'3f'7c'5c'2e'5cd'2b'29'28'5beE'5d'5b'2b'2d'5d'3f'5cd'2b'29'3f'5bij'5d'3f = compileRegex "(\\d+(\\.\\d+)?|\\.\\d+)([eE][+-]?\\d+)?[ij]?"+regex_'27'2b = compileRegex "'+"++defaultAttributes = [("_normal","Normal Text"),("_adjoint","Operator")]++parseRules "_normal" = +  do (attr, result) <- (((pRegExpr regex_'5cb'28for'29'5cb >>= withAttribute "Keyword"))+                        <|>+                        ((pRegExpr regex_'5cb'28endfor'29'5cb >>= withAttribute "Keyword"))+                        <|>+                        ((pRegExpr regex_'5cb'28if'29'5cb >>= withAttribute "Keyword"))+                        <|>+                        ((pRegExpr regex_'5cb'28endif'29'5cb >>= withAttribute "Keyword"))+                        <|>+                        ((pRegExpr regex_'5cb'28do'29'5cb >>= withAttribute "Keyword"))+                        <|>+                        ((pRegExpr regex_'5cb'28until'29'5cb >>= withAttribute "Keyword"))+                        <|>+                        ((pRegExpr regex_'5cb'28while'29'5cb >>= withAttribute "Keyword"))+                        <|>+                        ((pRegExpr regex_'5cb'28endwhile'29'5cb >>= withAttribute "Keyword"))+                        <|>+                        ((pRegExpr regex_'5cb'28function'29'5cb >>= withAttribute "Keyword"))+                        <|>+                        ((pRegExpr regex_'5cb'28endfunction'29'5cb >>= withAttribute "Keyword"))+                        <|>+                        ((pRegExpr regex_'5cb'28switch'29'5cb >>= withAttribute "Keyword"))+                        <|>+                        ((pRegExpr regex_'5cb'28endswitch'29'5cb >>= withAttribute "Keyword"))+                        <|>+                        ((pRegExpr regex_'5cb'28try'29'5cb >>= withAttribute "Keyword"))+                        <|>+                        ((pRegExpr regex_'5cb'28end'5ftry'5fcatch'29'5cb >>= withAttribute "Keyword"))+                        <|>+                        ((pRegExpr regex_'5cb'28end'29'5cb >>= withAttribute "Keyword"))+                        <|>+                        ((pRegExpr regex_'5ba'2dzA'2dZ'5d'5cw'2a'28'3f'3d'27'29 >>= withAttribute "Variable") >>~ pushContext "_adjoint")+                        <|>+                        ((pRegExpr regex_'28'5cd'2b'28'5c'2e'5cd'2b'29'3f'7c'5c'2e'5cd'2b'29'28'5beE'5d'5b'2b'2d'5d'3f'5cd'2b'29'3f'5bij'5d'3f'28'3f'3d'27'29 >>= withAttribute "Number") >>~ pushContext "_adjoint")+                        <|>+                        ((pRegExpr regex_'5b'5c'29'5c'5d'7d'5d'28'3f'3d'27'29 >>= withAttribute "Delimiter") >>~ pushContext "_adjoint")+                        <|>+                        ((pRegExpr regex_'5c'2e'27'28'3f'3d'27'29 >>= withAttribute "Operator") >>~ pushContext "_adjoint")+                        <|>+                        ((pRegExpr regex_'27'28'5b'5e'27'5c'5c'5d'7c'27'27'7c'5c'5c'27'7c'5c'5c'5b'5e'27'5d'29'2a'27'28'3f'3d'5b'5e'27'5d'7c'24'29 >>= withAttribute "String"))+                        <|>+                        ((pRegExpr regex_'27'28'5b'5e'27'5d'7c'27'27'7c'5c'5c'27'29'2a >>= withAttribute "Incomplete String"))+                        <|>+                        ((pRegExpr regex_'22'28'5b'5e'22'5c'5c'5d'7c'22'22'7c'5c'5c'22'7c'5c'5c'5b'5e'22'5d'29'2a'22'28'3f'3d'5b'5e'22'5d'7c'24'29 >>= withAttribute "String"))+                        <|>+                        ((pRegExpr regex_'22'28'5b'5e'22'5d'7c'22'22'7c'5c'5c'22'29'2a >>= withAttribute "Incomplete String"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_keywords >>= withAttribute "Keyword"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_commands >>= withAttribute "Commands"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_functions >>= withAttribute "Functions"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_builtin >>= withAttribute "Builtin"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_forge >>= withAttribute "Forge"))+                        <|>+                        ((pRegExpr regex_'5b'25'23'5d'2e'2a'24 >>= withAttribute "Comment"))+                        <|>+                        ((pRegExpr regex_'5ba'2dzA'2dZ'5d'5cw'2a >>= withAttribute "Variable"))+                        <|>+                        ((pRegExpr regex_'28'5cd'2b'28'5c'2e'5cd'2b'29'3f'7c'5c'2e'5cd'2b'29'28'5beE'5d'5b'2b'2d'5d'3f'5cd'2b'29'3f'5bij'5d'3f >>= withAttribute "Number"))+                        <|>+                        ((pAnyChar "()[]{}" >>= withAttribute "Delimiter"))+                        <|>+                        ((pString False "..." >>= withAttribute "Operator"))+                        <|>+                        ((pString False "==" >>= withAttribute "Operator"))+                        <|>+                        ((pString False "~=" >>= withAttribute "Operator"))+                        <|>+                        ((pString False "!=" >>= withAttribute "Operator"))+                        <|>+                        ((pString False "<=" >>= withAttribute "Operator"))+                        <|>+                        ((pString False ">=" >>= withAttribute "Operator"))+                        <|>+                        ((pString False "<>" >>= withAttribute "Operator"))+                        <|>+                        ((pString False "&&" >>= withAttribute "Operator"))+                        <|>+                        ((pString False "||" >>= withAttribute "Operator"))+                        <|>+                        ((pString False "++" >>= withAttribute "Operator"))+                        <|>+                        ((pString False "--" >>= withAttribute "Operator"))+                        <|>+                        ((pString False "**" >>= withAttribute "Operator"))+                        <|>+                        ((pString False ".*" >>= withAttribute "Operator"))+                        <|>+                        ((pString False ".**" >>= withAttribute "Operator"))+                        <|>+                        ((pString False ".^" >>= withAttribute "Operator"))+                        <|>+                        ((pString False "./" >>= withAttribute "Operator"))+                        <|>+                        ((pString False ".'" >>= withAttribute "Operator"))+                        <|>+                        ((pAnyChar "!\"%(*+,/;=>[]|~#&)-:<>\\^" >>= withAttribute "Operator")))+     return (attr, result)++parseRules "_adjoint" = +  do (attr, result) <- ((pRegExpr regex_'27'2b >>= withAttribute "Operator") >>~ (popContext >> return ()))+     return (attr, result)++parseRules x = fail $ "Unknown context" ++ x
Text/Highlighting/Kate/Syntax/Pascal.hs view
@@ -5,11 +5,11 @@ import Text.Highlighting.Kate.Definitions import Text.Highlighting.Kate.Common import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "Pascal"@@ -62,17 +62,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Keyword","Keyword"),("ISO/Delphi Extended","Keyword"),("Type","DataType"),("Number","DecVal"),("String","String"),("Directive","Others"),("Comment","Comment"),("Alert","Alert")]+styles = [("Keyword","kw"),("ISO/Delphi Extended","kw"),("Type","dt"),("Number","dv"),("String","st"),("Directive","ot"),("Comment","co"),("Alert","al")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Perl.hs view
@@ -6,11 +6,11 @@ import Text.Highlighting.Kate.Common import qualified Text.Highlighting.Kate.Syntax.Alert import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "Perl"@@ -121,17 +121,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Keyword","Keyword"),("Pragma","Keyword"),("Function","Function"),("Operator","Keyword"),("Data Type","DataType"),("Special Variable","DataType"),("Decimal","DecVal"),("Octal","BaseN"),("Hex","BaseN"),("Float","Float"),("String","String"),("String (interpolated)","String"),("String Special Character","Char"),("Pattern","Others"),("Pattern Internal Operator","Char"),("Pattern Character Class","BaseN"),("Data","Normal"),("Comment","Comment"),("Pod","Comment"),("Nothing","Comment")]+styles = [("Keyword","kw"),("Pragma","kw"),("Function","fu"),("Operator","kw"),("Data Type","dt"),("Special Variable","dt"),("Decimal","dv"),("Octal","bn"),("Hex","bn"),("Float","fl"),("String","st"),("String (interpolated)","st"),("String Special Character","ch"),("Pattern","ot"),("Pattern Internal Operator","ch"),("Pattern Character Class","bn"),("Comment","co"),("Pod","co"),("Nothing","co")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Php.hs view
@@ -6,11 +6,11 @@ import Text.Highlighting.Kate.Common import qualified Text.Highlighting.Kate.Syntax.Doxygen import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "PHP/PHP"@@ -66,17 +66,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("PHP Text","Normal"),("Keyword","Keyword"),("Function","Function"),("Special method","Function"),("Decimal","DecVal"),("Octal","BaseN"),("Hex","BaseN"),("Float","Float"),("String","String"),("Comment","Comment"),("Variable","Keyword"),("Control Structures","Keyword"),("Backslash Code","Keyword"),("Other","Others"),("HTML Tag","Keyword"),("HTML Comment","Comment"),("Identifier","Others"),("Types","DataType")]+styles = [("Keyword","kw"),("Function","fu"),("Special method","fu"),("Decimal","dv"),("Octal","bn"),("Hex","bn"),("Float","fl"),("String","st"),("Comment","co"),("Variable","kw"),("Control Structures","kw"),("Backslash Code","kw"),("Other","ot"),("HTML Tag","kw"),("HTML Comment","co"),("Identifier","ot"),("Types","dt")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Postscript.hs view
@@ -5,11 +5,11 @@ import Text.Highlighting.Kate.Definitions import Text.Highlighting.Kate.Common import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "PostScript"@@ -59,17 +59,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Keyword","Keyword"),("Comment","Comment"),("Header","Others"),("Float","Float"),("Decimal","DecVal"),("String","String"),("Data Type","DataType")]+styles = [("Keyword","kw"),("Comment","co"),("Header","ot"),("Float","fl"),("Decimal","dv"),("String","st"),("Data Type","dt")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Prolog.hs view
@@ -5,11 +5,11 @@ import Text.Highlighting.Kate.Definitions import Text.Highlighting.Kate.Common import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "Prolog"@@ -60,17 +60,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Keyword","Keyword"),("Data Type","DataType"),("Comment","Comment"),("Integer","DecVal"),("Symbol","Normal"),("String","String"),("Identifier","Normal"),("Variable","Others"),("Arithmetic","Keyword")]+styles = [("Keyword","kw"),("Data Type","dt"),("Comment","co"),("Integer","dv"),("String","st"),("Variable","ot"),("Arithmetic","kw")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Python.hs view
@@ -5,11 +5,11 @@ import Text.Highlighting.Kate.Definitions import Text.Highlighting.Kate.Common import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "Python"@@ -69,17 +69,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Definition Keyword","Keyword"),("Operator","Normal"),("String Substitution","Normal"),("Command Keyword","Keyword"),("Flow Control Keyword","Keyword"),("Builtin Function","DataType"),("Special Variable","Others"),("Extensions","Others"),("Preprocessor","Char"),("String Char","Char"),("Long","Others"),("Float","Float"),("Int","DecVal"),("Hex","Others"),("Octal","Others"),("Complex","Others"),("Comment","Comment"),("String","String"),("Raw String","String")]+styles = [("Definition Keyword","kw"),("Command Keyword","kw"),("Flow Control Keyword","kw"),("Builtin Function","dt"),("Special Variable","ot"),("Extensions","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")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Relaxngcompact.hs view
@@ -5,11 +5,11 @@ import Text.Highlighting.Kate.Definitions import Text.Highlighting.Kate.Common import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "RelaxNG-Compact"@@ -60,17 +60,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Comments","Comment"),("String","String"),("Keywords","Keyword"),("Datatypes","DataType"),("Node Names","Others"),("Definitions","Function")]+styles = [("Comments","co"),("String","st"),("Keywords","kw"),("Datatypes","dt"),("Node Names","ot"),("Definitions","fu")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Rhtml.hs view
@@ -8,11 +8,11 @@ import qualified Text.Highlighting.Kate.Syntax.Css import qualified Text.Highlighting.Kate.Syntax.Javascript import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "Ruby/Rails/RHTML"@@ -158,17 +158,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Ruby Normal Text","Normal"),("Keyword","Keyword"),("Attribute Definition","Others"),("Access Control","Keyword"),("Definition","Keyword"),("Pseudo variable","DecVal"),("Dec","DecVal"),("Float","Float"),("Char","Char"),("Octal","BaseN"),("Hex","BaseN"),("Bin","BaseN"),("Symbol","String"),("String","String"),("Raw String","String"),("Command","String"),("Message","Normal"),("Regular Expression","Others"),("Substitution","Others"),("Data","Normal"),("GDL input","Others"),("Default globals","DataType"),("Global Variable","DataType"),("Global Constant","DataType"),("Constant","DataType"),("Constant Value","DataType"),("Kernel methods","Normal"),("Member","Normal"),("Instance Variable","Others"),("Class Variable","Others"),("Ruby Comment","Comment"),("Blockcomment","Comment"),("Region Marker","Normal"),("RDoc Value","Others"),("Error","Error"),("Alert","Alert"),("Delimiter","Char"),("Expression","Others"),("Operator","Char"),("Normal Text","Normal"),("Comment","Comment"),("CDATA","BaseN"),("Processing Instruction","Keyword"),("Doctype","DataType"),("Element","Keyword"),("Attribute","Others"),("Value","String"),("EntityRef","DecVal"),("PEntityRef","DecVal"),("Error","Error")]+styles = [("Keyword","kw"),("Attribute Definition","ot"),("Access Control","kw"),("Definition","kw"),("Pseudo variable","dv"),("Dec","dv"),("Float","fl"),("Char","ch"),("Octal","bn"),("Hex","bn"),("Bin","bn"),("Symbol","st"),("String","st"),("Raw String","st"),("Command","st"),("Regular Expression","ot"),("Substitution","ot"),("GDL input","ot"),("Default globals","dt"),("Global Variable","dt"),("Global Constant","dt"),("Constant","dt"),("Constant Value","dt"),("Instance Variable","ot"),("Class Variable","ot"),("Ruby Comment","co"),("Blockcomment","co"),("RDoc Value","ot"),("Error","er"),("Alert","al"),("Delimiter","ch"),("Expression","ot"),("Operator","ch"),("Comment","co"),("CDATA","bn"),("Processing Instruction","kw"),("Doctype","dt"),("Element","kw"),("Attribute","ot"),("Value","st"),("EntityRef","dv"),("PEntityRef","dv"),("Error","er")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Ruby.hs view
@@ -5,11 +5,11 @@ import Text.Highlighting.Kate.Definitions import Text.Highlighting.Kate.Common import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "Ruby"@@ -128,17 +128,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Keyword","Keyword"),("Attribute Definition","Others"),("Access Control","Keyword"),("Definition","Keyword"),("Pseudo variable","DecVal"),("Dec","DecVal"),("Float","Float"),("Char","Char"),("Octal","BaseN"),("Hex","BaseN"),("Bin","BaseN"),("Symbol","String"),("String","String"),("Raw String","String"),("Command","String"),("Message","Normal"),("Regular Expression","Others"),("Substitution","Others"),("Data","Normal"),("GDL input","Others"),("Default globals","DataType"),("Global Variable","DataType"),("Global Constant","DataType"),("Constant","DataType"),("Constant Value","DataType"),("Kernel methods","Normal"),("Member","Normal"),("Instance Variable","Others"),("Class Variable","Others"),("Comment","Comment"),("Blockcomment","Comment"),("Region Marker","Normal"),("RDoc Value","Others"),("Error","Error"),("Alert","Alert"),("Delimiter","Char"),("Expression","Others"),("Operator","Char")]+styles = [("Keyword","kw"),("Attribute Definition","ot"),("Access Control","kw"),("Definition","kw"),("Pseudo variable","dv"),("Dec","dv"),("Float","fl"),("Char","ch"),("Octal","bn"),("Hex","bn"),("Bin","bn"),("Symbol","st"),("String","st"),("Raw String","st"),("Command","st"),("Regular Expression","ot"),("Substitution","ot"),("GDL input","ot"),("Default globals","dt"),("Global Variable","dt"),("Global Constant","dt"),("Constant","dt"),("Constant Value","dt"),("Instance Variable","ot"),("Class Variable","ot"),("Comment","co"),("Blockcomment","co"),("RDoc Value","ot"),("Error","er"),("Alert","al"),("Delimiter","ch"),("Expression","ot"),("Operator","ch")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Scala.hs view
@@ -6,11 +6,11 @@ import Text.Highlighting.Kate.Common import qualified Text.Highlighting.Kate.Syntax.Javadoc import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "Scala"@@ -63,17 +63,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Keyword","Keyword"),("Function","Function"),("StaticImports","Keyword"),("Imports","Keyword"),("Data Type","DataType"),("Decimal","DecVal"),("Octal","BaseN"),("Hex","BaseN"),("Float","Float"),("Char","Char"),("String","String"),("String Char","Char"),("PrintfString","String"),("Comment","Comment"),("Symbol","Normal"),("Scala2","Normal"),("Java15","Normal")]+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"),("PrintfString","st"),("Comment","co")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Scheme.hs view
@@ -5,11 +5,11 @@ import Text.Highlighting.Kate.Definitions import Text.Highlighting.Kate.Common import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "Scheme"@@ -67,17 +67,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal","Normal"),("Keyword","Keyword"),("Definition","Keyword"),("Operator","Keyword"),("Function","Function"),("Data","DataType"),("Decimal","DecVal"),("BaseN","BaseN"),("Float","Float"),("Char","Char"),("String","String"),("Comment","Comment"),("Region Marker","RegionMarker"),("Brackets1","Normal"),("Brackets2","Normal"),("Brackets3","Normal"),("Brackets4","Normal"),("Brackets5","Normal"),("Brackets6","Normal")]+styles = [("Keyword","kw"),("Definition","kw"),("Operator","kw"),("Function","fu"),("Data","dt"),("Decimal","dv"),("BaseN","bn"),("Float","fl"),("Char","ch"),("String","st"),("Comment","co"),("Region Marker","re")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Sgml.hs view
@@ -5,10 +5,9 @@ import Text.Highlighting.Kate.Definitions import Text.Highlighting.Kate.Common import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList)  -- | Full name of language. syntaxName :: String@@ -60,17 +59,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Tag","Keyword"),("Attribute Name","Others"),("Attribute Value","DataType"),("Comment","Comment")]+styles = [("Tag","kw"),("Attribute Name","ot"),("Attribute Value","dt"),("Comment","co")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Sql.hs view
@@ -5,11 +5,11 @@ import Text.Highlighting.Kate.Definitions import Text.Highlighting.Kate.Common import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "SQL"@@ -62,17 +62,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Keyword","Keyword"),("Operator","Normal"),("Function","Function"),("Data Type","DataType"),("Decimal","DecVal"),("Float","Float"),("String","String"),("String Char","Char"),("Comment","Comment"),("Identifier","Others"),("External Variable","Char"),("Symbol","Char"),("Preprocessor","Others")]+styles = [("Keyword","kw"),("Function","fu"),("Data Type","dt"),("Decimal","dv"),("Float","fl"),("String","st"),("String Char","ch"),("Comment","co"),("Identifier","ot"),("External Variable","ch"),("Symbol","ch"),("Preprocessor","ot")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/SqlMysql.hs view
@@ -5,11 +5,11 @@ import Text.Highlighting.Kate.Definitions import Text.Highlighting.Kate.Common import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "SQL (MySQL)"@@ -62,17 +62,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Keyword","Keyword"),("Operator","Normal"),("Function","Function"),("Data Type","DataType"),("Decimal","DecVal"),("Float","Float"),("String","String"),("Name","String"),("String Char","Char"),("Comment","Comment"),("Symbol","Char"),("Preprocessor","Others")]+styles = [("Keyword","kw"),("Function","fu"),("Data Type","dt"),("Decimal","dv"),("Float","fl"),("String","st"),("Name","st"),("String Char","ch"),("Comment","co"),("Symbol","ch"),("Preprocessor","ot")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/SqlPostgresql.hs view
@@ -5,11 +5,11 @@ import Text.Highlighting.Kate.Definitions import Text.Highlighting.Kate.Common import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "SQL (PostgreSQL)"@@ -61,17 +61,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Keyword","Keyword"),("Operator","Normal"),("Function","Function"),("Data Type","DataType"),("Decimal","DecVal"),("Float","Float"),("String","String"),("String Char","Char"),("Comment","Comment"),("Identifier","Others"),("Symbol","Char"),("Preprocessor","Others")]+styles = [("Keyword","kw"),("Function","fu"),("Data Type","dt"),("Decimal","dv"),("Float","fl"),("String","st"),("String Char","ch"),("Comment","co"),("Identifier","ot"),("Symbol","ch"),("Preprocessor","ot")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Tcl.hs view
@@ -5,11 +5,11 @@ import Text.Highlighting.Kate.Definitions import Text.Highlighting.Kate.Common import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "Tcl/Tk"@@ -59,17 +59,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Keyword","Keyword"),("Decimal","DecVal"),("Float","Float"),("String","String"),("Comment","Comment"),("Parameter","Others"),("Variable","DataType"),("Char","Char"),("Region Marker","RegionMarker")]+styles = [("Keyword","kw"),("Decimal","dv"),("Float","fl"),("String","st"),("Comment","co"),("Parameter","ot"),("Variable","dt"),("Char","ch"),("Region Marker","re")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Texinfo.hs view
@@ -6,10 +6,9 @@ import Text.Highlighting.Kate.Common import qualified Text.Highlighting.Kate.Syntax.Alert import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList)  -- | Full name of language. syntaxName :: String@@ -61,17 +60,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Comment","Comment"),("Command","Function")]+styles = [("Comment","co"),("Command","fu")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Xml.hs view
@@ -6,10 +6,9 @@ import Text.Highlighting.Kate.Common import qualified Text.Highlighting.Kate.Syntax.Alert import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList)  -- | Full name of language. syntaxName :: String@@ -75,17 +74,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Comment","Comment"),("CDATA","BaseN"),("Processing Instruction","Keyword"),("Doctype","DataType"),("Element","Keyword"),("Attribute","Others"),("Value","String"),("EntityRef","DecVal"),("PEntityRef","DecVal"),("Error","Error")]+styles = [("Comment","co"),("CDATA","bn"),("Processing Instruction","kw"),("Doctype","dt"),("Element","kw"),("Attribute","ot"),("Value","st"),("EntityRef","dv"),("PEntityRef","dv"),("Error","er")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Xslt.hs view
@@ -5,11 +5,11 @@ import Text.Highlighting.Kate.Definitions import Text.Highlighting.Kate.Common import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList) +import qualified Data.Set as Set -- | Full name of language. syntaxName :: String syntaxName = "xslt"@@ -69,17 +69,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Tag","Keyword"),("Attribute","Others"),("Invalid","Error"),("Alert","Alert"),("Attribute Value","String"),("XPath","Others"),("XPath String","String"),("XPath Axis","Keyword"),("XPath/ XSLT Function","Keyword"),("XPath 2.0/ XSLT 2.0 Function","Keyword"),("XPath Attribute","Normal"),("Variable","Normal"),("Comment","Comment"),("XSLT Tag","Keyword"),("XSLT 2.0 Tag","Keyword"),("Entity Reference","DecVal")]+styles = [("Tag","kw"),("Attribute","ot"),("Invalid","er"),("Alert","al"),("Attribute Value","st"),("XPath","ot"),("XPath String","st"),("XPath Axis","kw"),("XPath/ XSLT Function","kw"),("XPath 2.0/ XSLT 2.0 Function","kw"),("Comment","co"),("XSLT Tag","kw"),("XSLT 2.0 Tag","kw"),("Entity Reference","dv")]  parseExpressionInternal = do   context <- currentContext
Text/Highlighting/Kate/Syntax/Yacc.hs view
@@ -6,10 +6,9 @@ import Text.Highlighting.Kate.Common import qualified Text.Highlighting.Kate.Syntax.Cpp import Text.ParserCombinators.Parsec-import Data.List (nub)-import qualified Data.Set as Set+import Control.Monad (when) import Data.Map (fromList)-import Data.Maybe (fromMaybe)+import Data.Maybe (fromMaybe, maybeToList)  -- | Full name of language. syntaxName :: String@@ -77,17 +76,15 @@   updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }  withAttribute attr txt = do-  if null txt-     then fail "Parser matched no text"-     else return ()-  let style = fromMaybe "" $ lookup attr styles+  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 (nub [style, attr], txt)+  return (labs, txt) -styles = [("Normal Text","Normal"),("Definition","Normal"),("Comment","Comment"),("Content-Type Delimiter","BaseN"),("Directive","Keyword"),("Rule","String"),("Backslash Code","String"),("Alert","Alert"),("String","String"),("String Char","Char"),("Data Type","DataType")]+styles = [("Comment","co"),("Content-Type Delimiter","bn"),("Directive","kw"),("Rule","st"),("Backslash Code","st"),("Alert","al"),("String","st"),("String Char","ch"),("Data Type","dt")]  parseExpressionInternal = do   context <- currentContext
changelog view
@@ -1,3 +1,40 @@+highlighting-kate 0.2.7 (15 July 2010)++  * New, compressed format for classes. Two-letter class names are now+    used for default styles, and detailed lexical information is omitted+    unless the new OptDetailed option is specified. Also, the "Normal"+    style is no longer used, and spans are not used for "normal" markup.+    The result is significant compression of the highlighted source (in+    one test, 191K -> 72K).++  * Updated the css files in css/ to use the new two-letter class names.+    Users should update their css files, or highlighting will no longer+    work.++  * New OptDetailed option (see above).++  * Added languagesByFilename function.  Unlike the old+    languagesByExtension, this properly handles things like+    "Makefile" and "CMake.txt."++  * A new -d/--detailed option has been provided in the Highlight+    executable. This selects OptDetailed.++  * Improvements to haskell.xml and literate-haskell.xml,+    due to Nicolas Wu.++  * Added octave syntax definition.++  * Changed ParseSyntaxFiles to work with GHC 6.12.++  * ParseSyntaxFiles now uses Text/Highlighting/Kate/Syntax.hs.in+    as a template for construction of Text.Highlighting.Kate.Syntax+    module.++  * Removed parsec < 3 restriction.++  * Minor code cleanup and improvement.+ highlighting-kate 0.2.6.2 (06 March 2010)    * Use separate definitions for compiled regexes.
css/hk-espresso.css view
@@ -4,17 +4,16 @@ td.lineNumbers { border-right: 1px solid #AAAAAA; text-align: right; color: #AAAAAA; padding-right: 5px; padding-left: 5px; }  pre.sourceCode, table.sourceCode { background-color: #2A211C; color: #BDAE9D; } td.sourceCode { padding-left: 5px; }-pre.sourceCode span.Normal { }-pre.sourceCode span.Keyword { color: #43A8ED; font-weight: bold; } -pre.sourceCode span.DataType { text-decoration: underline; }-pre.sourceCode span.DecVal { color: #44AA43; }-pre.sourceCode span.BaseN { color: #44AA43; }-pre.sourceCode span.Float { color: #44AA43; }-pre.sourceCode span.Char { color: #049B0A; }-pre.sourceCode span.String { color: #049B0A; }-pre.sourceCode span.Comment { color: #0066FF; font-style: italic; }-pre.sourceCode span.Others { }-pre.sourceCode span.Alert { color: yellow; font-weight: bold; }-pre.sourceCode span.Function { color: #FF9358; font-weight: bold; }-pre.sourceCode span.RegionMarker { }-pre.sourceCode span.Error { color: yellow; font-weight: bold; }+pre.sourceCode span.kw { color: #43A8ED; font-weight: bold; } +pre.sourceCode span.dt { text-decoration: underline; }+pre.sourceCode span.dv { color: #44AA43; }+pre.sourceCode span.bn { color: #44AA43; }+pre.sourceCode span.fl { color: #44AA43; }+pre.sourceCode span.ch { color: #049B0A; }+pre.sourceCode span.st { color: #049B0A; }+pre.sourceCode span.co { color: #0066FF; font-style: italic; }+pre.sourceCode span.ot { }+pre.sourceCode span.al { color: yellow; font-weight: bold; }+pre.sourceCode span.fu { color: #FF9358; font-weight: bold; }+pre.sourceCode span.re { }+pre.sourceCode span.er { color: yellow; font-weight: bold; }
css/hk-kate.css view
@@ -4,17 +4,16 @@ td.lineNumbers { text-align: right; background-color: #EBEBEB; color: black; padding-right: 5px; padding-left: 5px; }  td.sourceCode { padding-left: 5px; } pre.sourceCode { }-pre.sourceCode span.Normal { }-pre.sourceCode span.Keyword { font-weight: bold; } -pre.sourceCode span.DataType { color: #800000; }-pre.sourceCode span.DecVal { color: #0000FF; }-pre.sourceCode span.BaseN { color: #0000FF; }-pre.sourceCode span.Float { color: #800080; }-pre.sourceCode span.Char { color: #FF00FF; }-pre.sourceCode span.String { color: #DD0000; }-pre.sourceCode span.Comment { color: #808080; font-style: italic; }-pre.sourceCode span.Others { }-pre.sourceCode span.Alert { color: green; font-weight: bold; }-pre.sourceCode span.Function { color: #000080; }-pre.sourceCode span.RegionMarker { }-pre.sourceCode span.Error { color: red; font-weight: bold; }+pre.sourceCode span.kw { font-weight: bold; } +pre.sourceCode span.dt { color: #800000; }+pre.sourceCode span.dv { color: #0000FF; }+pre.sourceCode span.bn { color: #0000FF; }+pre.sourceCode span.fl { color: #800080; }+pre.sourceCode span.ch { color: #FF00FF; }+pre.sourceCode span.st { color: #DD0000; }+pre.sourceCode span.co { color: #808080; font-style: italic; }+pre.sourceCode span.ot { }+pre.sourceCode span.al { color: green; font-weight: bold; }+pre.sourceCode span.fu { color: #000080; }+pre.sourceCode span.re { }+pre.sourceCode span.er { color: red; font-weight: bold; }
css/hk-pyg.css view
@@ -4,17 +4,16 @@ td.lineNumbers { border-right: 1px solid #AAAAAA; text-align: right; color: #AAAAAA; padding-right: 5px; padding-left: 5px; }  td.sourceCode { padding-left: 5px; } pre.sourceCode { }-pre.sourceCode span.Normal { }-pre.sourceCode span.Keyword { color: #007020; font-weight: bold; } -pre.sourceCode span.DataType { color: #902000; }-pre.sourceCode span.DecVal { color: #40a070; }-pre.sourceCode span.BaseN { color: #40a070; }-pre.sourceCode span.Float { color: #40a070; }-pre.sourceCode span.Char { color: #4070a0; }-pre.sourceCode span.String { color: #4070a0; }-pre.sourceCode span.Comment { color: #60a0b0; font-style: italic; }-pre.sourceCode span.Others { color: #007020; }-pre.sourceCode span.Alert { color: red; font-weight: bold; }-pre.sourceCode span.Function { color: #06287e; }-pre.sourceCode span.RegionMarker { }-pre.sourceCode span.Error { color: red; font-weight: bold; }+pre.sourceCode span.kw { color: #007020; font-weight: bold; } +pre.sourceCode span.dt { color: #902000; }+pre.sourceCode span.dv { color: #40a070; }+pre.sourceCode span.bn { color: #40a070; }+pre.sourceCode span.fl { color: #40a070; }+pre.sourceCode span.ch { color: #4070a0; }+pre.sourceCode span.st { color: #4070a0; }+pre.sourceCode span.co { color: #60a0b0; font-style: italic; }+pre.sourceCode span.ot { color: #007020; }+pre.sourceCode span.al { color: red; font-weight: bold; }+pre.sourceCode span.fu { color: #06287e; }+pre.sourceCode span.re { }+pre.sourceCode span.er { color: red; font-weight: bold; }
highlighting-kate.cabal view
@@ -1,5 +1,5 @@ Name:                highlighting-kate-Version:             0.2.6.2+Version:             0.2.7 Cabal-Version:       >= 1.2 Build-Type:          Simple Category:            Text@@ -23,6 +23,7 @@                      changelog                      Highlight.hs                      ParseSyntaxFiles.hs+                     Text/Highlighting/Kate/Syntax.hs.in                      css/hk-espresso.css                      css/hk-kate.css                      css/hk-pyg.css@@ -67,6 +68,7 @@                      xml/nasm.xml                      xml/objectivec.xml                      xml/ocaml.xml+                     xml/octave.xml                      xml/pascal.xml                      xml/perl.xml                      xml/perl.xml.bkp@@ -108,7 +110,7 @@     cpp-options:     -D_PCRE_LIGHT   else     Build-depends:   regex-pcre-builtin-  Build-Depends:     parsec < 3, xhtml+  Build-Depends:     parsec, xhtml   Exposed-Modules:   Text.Highlighting.Kate                      Text.Highlighting.Kate.Syntax                      Text.Highlighting.Kate.Definitions@@ -149,6 +151,7 @@                      Text.Highlighting.Kate.Syntax.Nasm                      Text.Highlighting.Kate.Syntax.Objectivec                      Text.Highlighting.Kate.Syntax.Ocaml+                     Text.Highlighting.Kate.Syntax.Octave                      Text.Highlighting.Kate.Syntax.Pascal                      Text.Highlighting.Kate.Syntax.Perl                      Text.Highlighting.Kate.Syntax.Php
xml/haskell.xml view
@@ -1,397 +1,379 @@ <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE language SYSTEM "language.dtd">-<!-- Haskell syntax highlighting by Marcel Martin <mmar@freenet.de> -->-<language name="Haskell" version="1.04" kateversion="2.3" section="Sources" extensions="*.hs" author="Marcel Martin (mmar@freenet.de)" license="">-	<highlighting>-	<list name="keywords">-		<item> as </item>-		<item> case </item>-		<item> class </item>-		<item> data </item>-		<item> deriving </item>-		<item> do </item>-		<item> else </item>-		<item> if </item>-        <item> import </item>-        <item> in </item>-		<item> infixl </item>-		<item> infixr </item>-		<item> instance </item>-		<item> let </item>-		<item> module </item>-		<item> of </item>-		<item> primitive </item>-		<item> qualified </item>-		<item> then </item>-		<item> type </item>-		<item> where </item>-	</list>-        <list name="infix operators">-		<item> quot </item>-		<item> rem </item>-		<item> div </item>-		<item> mod </item>-		<item> elem </item>-		<item> notElem </item>-		<item> seq </item>-	</list>-	<list name="functions">-		<!---                These operators are not handled yet.-		<item> !! </item>-		<item> % </item>-		<item> && </item>-		<item> $! </item>-		<item> $ </item>-		<item> * </item>-		<item> ** </item>-		<item> - </item>-		<item> . </item>-		<item> /= </item>-		<item> < </item>-		<item> <= </item>-		<item> =<< </item>-		<item> == </item>-		<item> > </item>-		<item> >= </item>-		<item> >> </item>-		<item> >>= </item>-		<item> ^ </item>-		<item> ^^ </item>-		<item> ++ </item>-		<item> || </item>-		//-->+<language name="Haskell" version="2.0.3" kateversion="2.3" section="Sources" extensions="*.hs" mimetype="text/x-haskell" author="Nicolas Wu (zenzike@gmail.com)" license="LGPL" indenter="haskell">+  <highlighting>+  <list name="keywords">+    <item> as </item>+    <item> case </item>+    <item> class </item>+    <item> data </item>+    <item> deriving </item>+    <item> do </item>+    <item> else </item>+    <item> hiding </item>+    <item> if </item>+    <item> import </item>+    <item> in </item>+    <item> infixl </item>+    <item> infixr </item>+    <item> instance </item>+    <item> let </item>+    <item> module </item>+    <item> newtype </item>+    <item> of </item>+    <item> primitive </item>+    <item> qualified </item>+    <item> then </item>+    <item> type </item>+    <item> where </item>+  </list>+  <list name="prelude function">+    <item> FilePath </item>+    <item> IOError </item>+    <item> abs </item>+    <item> acos </item>+    <item> acosh </item>+    <item> all </item>+    <item> and </item>+    <item> any </item>+    <item> appendFile </item>+    <item> approxRational </item>+    <item> asTypeOf </item>+    <item> asin </item>+    <item> asinh </item>+    <item> atan </item>+    <item> atan2 </item>+    <item> atanh </item>+    <item> basicIORun </item>+    <item> break </item>+    <item> catch </item>+    <item> ceiling </item>+    <item> chr </item>+    <item> compare </item>+    <item> concat </item>+    <item> concatMap </item>+    <item> const </item>+    <item> cos </item>+    <item> cosh </item>+    <item> curry </item>+    <item> cycle </item>+    <item> decodeFloat </item>+    <item> denominator </item>+    <item> digitToInt </item>+    <item> div </item>+    <item> divMod </item>+    <item> drop </item>+    <item> dropWhile </item>+    <item> either </item>+    <item> elem </item>+    <item> encodeFloat </item>+    <item> enumFrom </item>+    <item> enumFromThen </item>+    <item> enumFromThenTo </item>+    <item> enumFromTo </item>+    <item> error </item>+    <item> even </item>+    <item> exp </item>+    <item> exponent </item>+    <item> fail </item>+    <item> filter </item>+    <item> flip </item>+    <item> floatDigits </item>+    <item> floatRadix </item>+    <item> floatRange </item>+    <item> floor </item>+    <item> fmap </item>+    <item> foldl </item>+    <item> foldl1 </item>+    <item> foldr </item>+    <item> foldr1 </item>+    <item> fromDouble </item>+    <item> fromEnum </item>+    <item> fromInt </item>+    <item> fromInteger </item>+    <item> fromIntegral </item>+    <item> fromRational </item>+    <item> fst </item>+    <item> gcd </item>+    <item> getChar </item>+    <item> getContents </item>+    <item> getLine </item>+    <item> group </item>+    <item> head </item>+    <item> id </item>+    <item> inRange </item>+    <item> index </item>+    <item> init </item>+    <item> intToDigit </item>+    <item> interact </item>+    <item> ioError </item>+    <item> isAlpha </item>+    <item> isAlphaNum </item>+    <item> isAscii </item>+    <item> isControl </item>+    <item> isDenormalized </item>+    <item> isDigit </item>+    <item> isHexDigit </item>+    <item> isIEEE </item>+    <item> isInfinite </item>+    <item> isLower </item>+    <item> isNaN </item>+    <item> isNegativeZero </item>+    <item> isOctDigit </item>+    <item> isPrint </item>+    <item> isSpace </item>+    <item> isUpper </item>+    <item> iterate </item>+    <item> last </item>+    <item> lcm </item>+    <item> length </item>+    <item> lex </item>+    <item> lexDigits </item>+    <item> lexLitChar </item>+    <item> lines </item>+    <item> log </item>+    <item> logBase </item>+    <item> lookup </item>+    <item> map </item>+    <item> mapM </item>+    <item> mapM_ </item>+    <item> max </item>+    <item> maxBound </item>+    <item> maximum </item>+    <item> maybe </item>+    <item> min </item>+    <item> minBound </item>+    <item> minimum </item>+    <item> mod </item>+    <item> negate </item>+    <item> not </item>+    <item> notElem </item>+    <item> null </item>+    <item> numerator </item>+    <item> odd </item>+    <item> or </item>+    <item> ord </item>+    <item> otherwise </item>+    <item> pack </item>+    <item> pi </item>+    <item> pred </item>+    <item> primExitWith </item>+    <item> print </item>+    <item> product </item>+    <item> properFraction </item>+    <item> putChar </item>+    <item> putStr </item>+    <item> putStrLn </item>+    <item> quot </item>+    <item> quotRem </item>+    <item> range </item>+    <item> rangeSize </item>+    <item> read </item>+    <item> readDec </item>+    <item> readFile </item>+    <item> readFloat </item>+    <item> readHex </item>+    <item> readIO </item>+    <item> readInt </item>+    <item> readList </item>+    <item> readLitChar </item>+    <item> readLn </item>+    <item> readOct </item>+    <item> readParen </item>+    <item> readSigned </item>+    <item> reads </item>+    <item> readsPrec </item>+    <item> realToFrac </item>+    <item> recip </item>+    <item> rem </item>+    <item> repeat </item>+    <item> replicate </item>+    <item> return </item>+    <item> reverse </item>+    <item> round </item>+    <item> scaleFloat </item>+    <item> scanl </item>+    <item> scanl1 </item>+    <item> scanr </item>+    <item> scanr1 </item>+    <item> seq </item>+    <item> sequence </item>+    <item> sequence_ </item>+    <item> show </item>+    <item> showChar </item>+    <item> showInt </item>+    <item> showList </item>+    <item> showLitChar </item>+    <item> showParen </item>+    <item> showSigned </item>+    <item> showString </item>+    <item> shows </item>+    <item> showsPrec </item>+    <item> significand </item>+    <item> signum </item>+    <item> sin </item>+    <item> sinh </item>+    <item> snd </item>+    <item> sort </item>+    <item> span </item>+    <item> splitAt </item>+    <item> sqrt </item>+    <item> subtract </item>+    <item> succ </item>+    <item> sum </item>+    <item> tail </item>+    <item> take </item>+    <item> takeWhile </item>+    <item> tan </item>+    <item> tanh </item>+    <item> threadToIOResult </item>+    <item> toEnum </item>+    <item> toInt </item>+    <item> toInteger </item>+    <item> toLower </item>+    <item> toRational </item>+    <item> toUpper </item>+    <item> truncate </item>+    <item> uncurry </item>+    <item> undefined </item>+    <item> unlines </item>+    <item> until </item>+    <item> unwords </item>+    <item> unzip </item>+    <item> unzip3 </item>+    <item> userError </item>+    <item> words </item>+    <item> writeFile </item>+    <item> zip </item>+    <item> zip3 </item>+    <item> zipWith </item>+    <item> zipWith3 </item>+  </list>+  <list name="prelude class">+    <item> Bounded </item>+    <item> Enum </item>+    <item> Eq </item>+    <item> Floating </item>+    <item> Fractional </item>+    <item> Functor </item>+    <item> Integral </item>+    <item> Ix </item>+    <item> Monad </item>+    <item> Num </item>+    <item> Ord </item>+    <item> Read </item>+    <item> Real </item>+    <item> RealFloat </item>+    <item> RealFrac </item>+    <item> Show </item>+  </list>+  <list name="prelude type">+    <item> Bool </item>+    <item> Char </item>+    <item> Double </item>+    <item> Either </item>+    <item> FilePath </item>+    <item> Float </item>+    <item> Int </item>+    <item> Integer </item>+    <item> IO </item>+    <item> IOError </item>+    <item> Maybe </item>+    <item> Ordering </item>+    <item> Ratio </item>+    <item> Rational </item>+    <item> ReadS </item>+    <item> ShowS </item>+    <item> String </item>+    <item> ByteString </item>+  </list>+  <list name="prelude data">+    <item> False </item>+    <item> True </item>+    <item> Left </item>+    <item> Right </item>+    <item> Just </item>+    <item> Nothing </item>+    <item> EQ </item>+    <item> LT </item>+    <item> GT </item>+  </list>+  <contexts>+    <context attribute="Normal" lineEndContext="#stay" name="code">+      <RegExpr attribute="Pragma"  context="#stay" String="\{-#.*#-\}"/>+      <RegExpr attribute="Comment" context="comments" String="\{-[^#]?" />+      <RegExpr attribute="Comment" context="comment"  String="--[^\-!#\$%&amp;\*\+/&lt;=&gt;\?&#92;@\^\|~\.:].*$" /> -		<item> FilePath </item>-		<item> IOError </item>-		<item> abs </item>-		<item> acos </item>-		<item> acosh </item>-		<item> all </item>-		<item> and </item>-		<item> any </item>-		<item> appendFile </item>-		<item> approxRational </item>-		<item> asTypeOf </item>-		<item> asin </item>-		<item> asinh </item>-		<item> atan </item>-		<item> atan2 </item>-		<item> atanh </item>-		<item> basicIORun </item>-		<item> break </item>-		<item> catch </item>-		<item> ceiling </item>-		<item> chr </item>-		<item> compare </item>-		<item> concat </item>-		<item> concatMap </item>-		<item> const </item>-		<item> cos </item>-		<item> cosh </item>-		<item> curry </item>-		<item> cycle </item>-		<item> decodeFloat </item>-		<item> denominator </item>-		<item> digitToInt </item>-		<item> div </item>-		<item> divMod </item>-		<item> drop </item>-		<item> dropWhile </item>-		<item> either </item>-		<item> elem </item>-		<item> encodeFloat </item>-		<item> enumFrom </item>-		<item> enumFromThen </item>-		<item> enumFromThenTo </item>-		<item> enumFromTo </item>-		<item> error </item>-		<item> even </item>-		<item> exp </item>-		<item> exponent </item>-		<item> fail </item>-		<item> filter </item>-		<item> flip </item>-		<item> floatDigits </item>-		<item> floatRadix </item>-		<item> floatRange </item>-		<item> floor </item>-		<item> fmap </item>-		<item> foldl </item>-		<item> foldl1 </item>-		<item> foldr </item>-		<item> foldr1 </item>-		<item> fromDouble </item>-		<item> fromEnum </item>-		<item> fromInt </item>-		<item> fromInteger </item>-		<item> fromIntegral </item>-		<item> fromRational </item>-		<item> fst </item>-		<item> gcd </item>-		<item> getChar </item>-		<item> getContents </item>-		<item> getLine </item>-		<item> head </item>-		<item> id </item>-		<item> inRange </item>-		<item> index </item>-		<item> init </item>-		<item> intToDigit </item>-		<item> interact </item>-		<item> ioError </item>-		<item> isAlpha </item>-		<item> isAlphaNum </item>-		<item> isAscii </item>-		<item> isControl </item>-		<item> isDenormalized </item>-		<item> isDigit </item>-		<item> isHexDigit </item>-		<item> isIEEE </item>-		<item> isInfinite </item>-		<item> isLower </item>-		<item> isNaN </item>-		<item> isNegativeZero </item>-		<item> isOctDigit </item>-		<item> isPrint </item>-		<item> isSpace </item>-		<item> isUpper </item>-		<item> iterate </item>-		<item> last </item>-		<item> lcm </item>-		<item> length </item>-		<item> lex </item>-		<item> lexDigits </item>-		<item> lexLitChar </item>-		<item> lines </item>-		<item> log </item>-		<item> logBase </item>-		<item> lookup </item>-		<item> map </item>-		<item> mapM </item>-		<item> mapM_ </item>-		<item> max </item>-		<item> maxBound </item>-		<item> maximum </item>-		<item> maybe </item>-		<item> min </item>-		<item> minBound </item>-		<item> minimum </item>-		<item> mod </item>-		<item> negate </item>-		<item> not </item>-		<item> notElem </item>-		<item> null </item>-		<item> numerator </item>-		<item> odd </item>-		<item> or </item>-		<item> ord </item>-		<item> otherwise </item>-		<item> pi </item>-		<item> pred </item>-		<item> primExitWith </item>-		<item> print </item>-		<item> product </item>-		<item> properFraction </item>-		<item> putChar </item>-		<item> putStr </item>-		<item> putStrLn </item>-		<item> quot </item>-		<item> quotRem </item>-		<item> range </item>-		<item> rangeSize </item>-		<item> read </item>-		<item> readDec </item>-		<item> readFile </item>-		<item> readFloat </item>-		<item> readHex </item>-		<item> readIO </item>-		<item> readInt </item>-		<item> readList </item>-		<item> readLitChar </item>-		<item> readLn </item>-		<item> readOct </item>-		<item> readParen </item>-		<item> readSigned </item>-		<item> reads </item>-		<item> readsPrec </item>-		<item> realToFrac </item>-		<item> recip </item>-		<item> rem </item>-		<item> repeat </item>-		<item> replicate </item>-		<item> return </item>-		<item> reverse </item>-		<item> round </item>-		<item> scaleFloat </item>-		<item> scanl </item>-		<item> scanl1 </item>-		<item> scanr </item>-		<item> scanr1 </item>-		<item> seq </item>-		<item> sequence </item>-		<item> sequence_ </item>-		<item> show </item>-		<item> showChar </item>-		<item> showInt </item>-		<item> showList </item>-		<item> showLitChar </item>-		<item> showParen </item>-		<item> showSigned </item>-		<item> showString </item>-		<item> shows </item>-		<item> showsPrec </item>-		<item> significand </item>-		<item> signum </item>-		<item> sin </item>-		<item> sinh </item>-		<item> snd </item>-		<item> span </item>-		<item> splitAt </item>-		<item> sqrt </item>-		<item> subtract </item>-		<item> succ </item>-		<item> sum </item>-		<item> tail </item>-		<item> take </item>-		<item> takeWhile </item>-		<item> tan </item>-		<item> tanh </item>-		<item> threadToIOResult </item>-		<item> toEnum </item>-		<item> toInt </item>-		<item> toInteger </item>-		<item> toLower </item>-		<item> toRational </item>-		<item> toUpper </item>-		<item> truncate </item>-		<item> uncurry </item>-		<item> undefined </item>-		<item> unlines </item>-		<item> until </item>-		<item> unwords </item>-		<item> unzip </item>-		<item> unzip3 </item>-		<item> userError </item>-		<item> words </item>-		<item> writeFile </item>-		<item> zip </item>-		<item> zip3 </item>-		<item> zipWith </item>-		<item> zipWith3 </item>-	</list>-	<list name="type constructors">-		<item> Bool </item>-		<item> Char </item>-                <item> Double </item>-		<item> Either </item>-		<item> Float </item>-		<item> IO </item>-		<item> Integer </item>-		<item> Int </item>-		<item> Maybe </item>-		<item> Ordering </item>-		<item> Rational </item>-		<item> Ratio </item>-		<item> ReadS </item>-		<item> ShowS </item>-		<item> String </item>+      <keyword attribute="Keyword"          context="#stay" String="keywords" />+      <keyword attribute="Function Prelude" context="#stay" String="prelude function" />+      <keyword attribute="Type Prelude"     context="#stay" String="prelude type" />+      <keyword attribute="Data Prelude"     context="#stay" String="prelude data" />+      <keyword attribute="Class Prelude"    context="#stay" String="prelude class" /> -	</list>-	<list name="classes">-		<item> Bounded </item>-		<item> Enum </item>-		<item> Eq </item>-		<item> Floating </item>-		<item> Fractional </item>-		<item> Functor </item>-		<item> Integral </item>-		<item> Ix </item>-		<item> Monad </item>-		<item> Num </item>-		<item> Ord </item>-		<item> Read </item>-		<item> RealFloat </item>-		<item> RealFrac </item>-		<item> Real </item>-		<item> Show </item>-	</list>-	<list name="data constructors">-		<item> EQ </item>-		<item> False </item>-		<item> GT </item>-		<item> Just </item>-		<item> LT </item>-		<item> Left </item>-		<item> Nothing </item>-		<item> Right </item>-		<item> True </item>-	</list>-	<contexts>-		<context attribute="Normal Text" lineEndContext="#stay" name="normal">-			<Detect2Chars attribute="Comment" context="comment_multi_line" char="{" char1="-" />-			<!--			-			<Detect2Chars attribute="Comment" context="comment_single_line" char="-" char1="-" />-			-->-			<RegExpr attribute="Comment" context="comment_single_line" String="--$" />-			<RegExpr attribute="Comment" context="comment_single_line" -				String="--[ A-Za-z0-9\-,;`].*$" />-			<RegExpr attribute="Module Name" context="#stay" String="([A-Z][A-Za-z0-9]*\.)+[A-Z][A-Za-z0-9]*"/> -            <keyword attribute="Keyword" context="#stay" String="keywords" />-			<keyword attribute="Class" context="#stay" String="classes" />-			<keyword attribute="Type Constructor" context="#stay" String="type constructors" />-			<keyword attribute="Function" context="#stay" String="functions" />-			<keyword attribute="Data Constructor" context="#stay" String="data constructors" />-			<DetectChar attribute="String" context="string" char="&quot;" />-			<DetectChar attribute="Infix Operator" context="infix" char="`"/>-			<RegExpr attribute="Normal Text" context="#stay" String="\w[']+" />-			<DetectChar attribute="Char" context="single_char" char="'" />-			<RegExpr attribute="Function Definition" context="#stay" String="[a-z_]+\w*'*\s*::" />-			<Float attribute="Float" context="#stay" />-			<Int attribute="Decimal" context="#stay" />-		</context>-		<context attribute="Comment" lineEndContext="#pop" name="comment_single_line" />-		<context attribute="Comment" lineEndContext="#stay" name="comment_multi_line">-			<Detect2Chars attribute="Comment" context="#pop" char="-" char1="}" />-		</context>-		<context attribute="String" lineEndContext="#stay" name="string">-			<RegExpr attribute="String" context="#stay" String="\\." />-			<DetectChar attribute="String" context="#pop" char="&quot;" />-		</context>-		<context attribute="Infix Operator" lineEndContext="#stay" name="infix">-			<DetectChar attribute="Infix Operator" context="#pop" char="`"/>-		</context>-		<context attribute="Char" lineEndContext="#pop" name="single_char">-			<RegExpr attribute="Char" context="#stay" String="\\." />-			<DetectChar attribute="Char" context="#pop" char="'" />-		</context>-		<context attribute="Function Definition" lineEndContext="#pop" name="function_definition">-			<DetectChar attribute="Function Definition" context="#pop" char=";" />-		</context>-	</contexts>-	<itemDatas>-		<itemData name="Normal Text"		defStyleNum="dsNormal"/>-		<itemData name="Module Name" 		defStyleNum="dsNormal"/>-		<itemData name="Keyword" 		defStyleNum="dsKeyword"/>-		<itemData name="Function"		defStyleNum="dsFunction"/>-		<itemData name="Function Definition"	defStyleNum="dsFunction"/>-		<itemData name="Class"			defStyleNum="dsKeyword"/>-		<itemData name="Decimal"		defStyleNum="dsDecVal"/>-		<itemData name="Float"			defStyleNum="dsFloat"/>-		<itemData name="Char"			defStyleNum="dsChar"/>-		<itemData name="String"			defStyleNum="dsString"/>-		<itemData name="Constructor"		defStyleNum="dsOthers"/>-		<itemData name="Comment"		defStyleNum="dsComment"/>-		<itemData name="Data Constructor"	defStyleNum="dsKeyword"/>-		<itemData name="Type Constructor"	defStyleNum="dsDataType"/>-		<itemData name="Infix Operator"		defStyleNum="dsOthers"/>-	</itemDatas>-	</highlighting>-	<general>-		<comments>-			<!---	<comment name="singleLine" start="-" /> -->-			<comment name="multiLine" start="{-" end="-}" />-		</comments>-		<keywords casesensitive="1" />-	</general>+      <RegExpr attribute="Special"          context="#stay" String="(::|=&gt;|\-&gt;|&lt;\-)" />+      <AnyChar attribute="Special"          context="#stay" String="→←⇒∀∃" />+      <RegExpr attribute="Signature"        context="#stay" String="\s*[a-z][a-zA-Z0-9_']*\s*(?=::[^\-!#\$%&amp;\*\+/&lt;=&gt;\?&#92;@\^\|~\.:])" />+      <RegExpr attribute="Signature"        context="#stay" String="\s*(\([\-!#\$%&amp;\*\+/&lt;=&gt;\?&#92;@\^\|~\.:]*\))*\s*(?=::[^\-!#\$%&amp;\*\+/&lt;=&gt;\?&#92;@\^\|~\.:])" />+      <RegExpr attribute="Function"         context="#stay" String="([A-Z][a-zA-Z0-9_']*\.)*[a-z][a-zA-Z0-9_']*" />+      <RegExpr attribute="Operator"         context="#stay" String="([A-Z][a-zA-Z0-0_']*\.)*[\-!#\$%&amp;\*\+/&lt;=&gt;\?&#92;@\^\|~\.:]+" />+      <RegExpr attribute="Type"             context="#stay" String="([A-Z][a-zA-Z0-9_']*\.)*[A-Z][a-zA-Z0-9_']*" />++      <Int        attribute="Decimal" context="#stay" />+      <RegExpr    attribute="Float"   context="#stay" String="\d+\.\d+" />+      <DetectChar attribute="Char"    context="char" char="'" />+      <DetectChar attribute="String"  context="string" char="&quot;" />++      <DetectChar attribute="Function Infix" context="infix" char="`"/>+      <Detect2Chars attribute="EnumFromTo" context="#stay" char ="." char1="." />+    </context>+    <context attribute="Comment" lineEndContext="#pop" name="comment" />+    <context attribute="Comment" lineEndContext="#stay" name="comments">+      <Detect2Chars attribute="Comment" context="#pop" char="-" char1="}" />+    </context>+    <context attribute="Char" lineEndContext="#pop" name="char">+      <RegExpr attribute="Char" context="#stay" String="\\." />+      <DetectChar attribute="Char" context="#pop" char="'" />+    </context>+    <context attribute="String" lineEndContext="#stay" name="string">+      <RegExpr attribute="String" context="#stay" String="\\." />+      <DetectChar attribute="String" context="#pop" char="&quot;" />+    </context>+    <context attribute="Function Infix" lineEndContext="#stay" name="infix">+      <DetectChar attribute="Function Infix" context="#pop" char="`"/>+    </context>+  </contexts>+  <itemDatas>+    <itemData name="Normal"           defStyleNum="dsNormal"   spellChecking="false" />+    <itemData name="Comment"          defStyleNum="dsComment" />+    <itemData name="Pragma"           defStyleNum="dsOthers"   spellChecking="false" />++    <itemData name="Keyword"          defStyleNum="dsKeyword"  spellChecking="false" />+    <itemData name="Type Prelude"     defStyleNum="dsDataType" spellChecking="false" />+    <itemData name="Function Prelude" defStyleNum="dsFunction" spellChecking="false" />+    <itemData name="Data Prelude"     defStyleNum="dsKeyword"  spellChecking="false" />+    <itemData name="Class Prelude"    defStyleNum="dsKeyword"  spellChecking="false" />++    <itemDate name="Signature"        defStyleNum="dsSpecial"  spellChecking="false" />+    <itemData name="Function"         defStyleNum="dsNormal"   spellChecking="false" />+    <itemData name="Operator"         defStyleNum="dsFunction" spellChecking="false" />+    <itemData name="Type"             defStyleNum="dsDataType" spellChecking="false" />+    <itemData name="Special"          defStyleNum="dsSpecial"  spellChecking="false" />++    <itemData name="Decimal"          defStyleNum="dsDecVal"   spellChecking="false" />+    <itemData name="Float"            defStyleNum="dsFloat"    spellChecking="false" />+    <itemData name="Char"             defStyleNum="dsChar"     spellChecking="false" />+    <itemData name="String"           defStyleNum="dsString" />++    <itemData name="Function Infix"   defStyleNum="dsOthers"   spellChecking="false" />+    <itemData name="EnumFromTo"       defStyleNum="dsOthers"   spellChecking="false" />+  </itemDatas>+  </highlighting>+  <general>+    <folding indentationsensitive="1"/>+    <comments>+      <comment name="singleLine" start="--" />+      <comment name="multiLine" start="{-" end="-}" />+    </comments>+    <keywords casesensitive="1" />+</general> </language>
xml/literate-haskell.xml view
@@ -1,386 +1,38 @@ <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE language SYSTEM "language.dtd">-<language name="Literate Haskell" version="1.04" kateversion="2.4" section="Sources" extensions="*.lhs" author="Marcel Martin (mmar@freenet.de)" license="">-	<highlighting>-	<list name="keywords">-		<item> case </item>-		<item> class </item>-		<item> data </item>-		<item> deriving </item>-		<item> do </item>-		<item> else </item>-		<item> if </item>-		<item> in </item>-		<item> infixl </item>-		<item> infixr </item>-		<item> instance </item>-		<item> let </item>-		<item> module </item>-		<item> of </item>-		<item> primitive </item>-		<item> then </item>-		<item> type </item>-		<item> where </item>-	</list>-        <list name="infix operators">-		<item> quot </item>-		<item> rem </item>-		<item> div </item>-		<item> mod </item>-		<item> elem </item>-		<item> notElem </item>-		<item> seq </item>-	</list>-	<list name="functions">-		<!---                These operators are not handled yet.-		<item> !! </item>-		<item> % </item>-		<item> && </item>-		<item> $! </item>-		<item> $ </item>-		<item> * </item>-		<item> ** </item>-		<item> - </item>-		<item> . </item>-		<item> /= </item>-		<item> < </item>-		<item> <= </item>-		<item> =<< </item>-		<item> == </item>-		<item> > </item>-		<item> >= </item>-		<item> >> </item>-		<item> >>= </item>-		<item> ^ </item>-		<item> ^^ </item>-		<item> ++ </item>-		<item> || </item>-		//-->--		<item> FilePath </item>-		<item> IOError </item>-		<item> abs </item>-		<item> acos </item>-		<item> acosh </item>-		<item> all </item>-		<item> and </item>-		<item> any </item>-		<item> appendFile </item>-		<item> approxRational </item>-		<item> asTypeOf </item>-		<item> asin </item>-		<item> asinh </item>-		<item> atan </item>-		<item> atan2 </item>-		<item> atanh </item>-		<item> basicIORun </item>-		<item> break </item>-		<item> catch </item>-		<item> ceiling </item>-		<item> chr </item>-		<item> compare </item>-		<item> concat </item>-		<item> concatMap </item>-		<item> const </item>-		<item> cos </item>-		<item> cosh </item>-		<item> curry </item>-		<item> cycle </item>-		<item> decodeFloat </item>-		<item> denominator </item>-		<item> digitToInt </item>-		<item> div </item>-		<item> divMod </item>-		<item> drop </item>-		<item> dropWhile </item>-		<item> either </item>-		<item> elem </item>-		<item> encodeFloat </item>-		<item> enumFrom </item>-		<item> enumFromThen </item>-		<item> enumFromThenTo </item>-		<item> enumFromTo </item>-		<item> error </item>-		<item> even </item>-		<item> exp </item>-		<item> exponent </item>-		<item> fail </item>-		<item> filter </item>-		<item> flip </item>-		<item> floatDigits </item>-		<item> floatRadix </item>-		<item> floatRange </item>-		<item> floor </item>-		<item> fmap </item>-		<item> foldl </item>-		<item> foldl1 </item>-		<item> foldr </item>-		<item> foldr1 </item>-		<item> fromDouble </item>-		<item> fromEnum </item>-		<item> fromInt </item>-		<item> fromInteger </item>-		<item> fromIntegral </item>-		<item> fromRational </item>-		<item> fst </item>-		<item> gcd </item>-		<item> getChar </item>-		<item> getContents </item>-		<item> getLine </item>-		<item> head </item>-		<item> id </item>-		<item> inRange </item>-		<item> index </item>-		<item> init </item>-		<item> intToDigit </item>-		<item> interact </item>-		<item> ioError </item>-		<item> isAlpha </item>-		<item> isAlphaNum </item>-		<item> isAscii </item>-		<item> isControl </item>-		<item> isDenormalized </item>-		<item> isDigit </item>-		<item> isHexDigit </item>-		<item> isIEEE </item>-		<item> isInfinite </item>-		<item> isLower </item>-		<item> isNaN </item>-		<item> isNegativeZero </item>-		<item> isOctDigit </item>-		<item> isPrint </item>-		<item> isSpace </item>-		<item> isUpper </item>-		<item> iterate </item>-		<item> last </item>-		<item> lcm </item>-		<item> length </item>-		<item> lex </item>-		<item> lexDigits </item>-		<item> lexLitChar </item>-		<item> lines </item>-		<item> log </item>-		<item> logBase </item>-		<item> lookup </item>-		<item> map </item>-		<item> mapM </item>-		<item> mapM_ </item>-		<item> max </item>-		<item> maxBound </item>-		<item> maximum </item>-		<item> maybe </item>-		<item> min </item>-		<item> minBound </item>-		<item> minimum </item>-		<item> mod </item>-		<item> negate </item>-		<item> not </item>-		<item> notElem </item>-		<item> null </item>-		<item> numerator </item>-		<item> odd </item>-		<item> or </item>-		<item> ord </item>-		<item> otherwise </item>-		<item> pi </item>-		<item> pred </item>-		<item> primExitWith </item>-		<item> print </item>-		<item> product </item>-		<item> properFraction </item>-		<item> putChar </item>-		<item> putStr </item>-		<item> putStrLn </item>-		<item> quot </item>-		<item> quotRem </item>-		<item> range </item>-		<item> rangeSize </item>-		<item> read </item>-		<item> readDec </item>-		<item> readFile </item>-		<item> readFloat </item>-		<item> readHex </item>-		<item> readIO </item>-		<item> readInt </item>-		<item> readList </item>-		<item> readLitChar </item>-		<item> readLn </item>-		<item> readOct </item>-		<item> readParen </item>-		<item> readSigned </item>-		<item> reads </item>-		<item> readsPrec </item>-		<item> realToFrac </item>-		<item> recip </item>-		<item> rem </item>-		<item> repeat </item>-		<item> replicate </item>-		<item> return </item>-		<item> reverse </item>-		<item> round </item>-		<item> scaleFloat </item>-		<item> scanl </item>-		<item> scanl1 </item>-		<item> scanr </item>-		<item> scanr1 </item>-		<item> seq </item>-		<item> sequence </item>-		<item> sequence_ </item>-		<item> show </item>-		<item> showChar </item>-		<item> showInt </item>-		<item> showList </item>-		<item> showLitChar </item>-		<item> showParen </item>-		<item> showSigned </item>-		<item> showString </item>-		<item> shows </item>-		<item> showsPrec </item>-		<item> significand </item>-		<item> signum </item>-		<item> sin </item>-		<item> sinh </item>-		<item> snd </item>-		<item> span </item>-		<item> splitAt </item>-		<item> sqrt </item>-		<item> subtract </item>-		<item> succ </item>-		<item> sum </item>-		<item> tail </item>-		<item> take </item>-		<item> takeWhile </item>-		<item> tan </item>-		<item> tanh </item>-		<item> threadToIOResult </item>-		<item> toEnum </item>-		<item> toInt </item>-		<item> toInteger </item>-		<item> toLower </item>-		<item> toRational </item>-		<item> toUpper </item>-		<item> truncate </item>-		<item> uncurry </item>-		<item> undefined </item>-		<item> unlines </item>-		<item> until </item>-		<item> unwords </item>-		<item> unzip </item>-		<item> unzip3 </item>-		<item> userError </item>-		<item> words </item>-		<item> writeFile </item>-		<item> zip </item>-		<item> zip3 </item>-		<item> zipWith </item>-		<item> zipWith3 </item>-	</list>-	<list name="type constructors">-		<item> Bool </item>-		<item> Char </item>-                <item> Double </item>-		<item> Either </item>-		<item> Float </item>-		<item> IO </item>-		<item> Integer </item>-		<item> Int </item>-		<item> Maybe </item>-		<item> Ordering </item>-		<item> Rational </item>-		<item> Ratio </item>-		<item> ReadS </item>-		<item> ShowS </item>-		<item> String </item>--	</list>-	<list name="classes">-		<item> Bounded </item>-		<item> Enum </item>-		<item> Eq </item>-		<item> Floating </item>-		<item> Fractional </item>-		<item> Functor </item>-		<item> Integral </item>-		<item> Ix </item>-		<item> Monad </item>-		<item> Num </item>-		<item> Ord </item>-		<item> Read </item>-		<item> RealFloat </item>-		<item> RealFrac </item>-		<item> Real </item>-		<item> Show </item>-	</list>-	<list name="data constructors">-		<item> EQ </item>-		<item> False </item>-		<item> GT </item>-		<item> Just </item>-		<item> LT </item>-		<item> Left </item>-		<item> Nothing </item>-		<item> Right </item>-		<item> True </item>-	</list>-	<contexts>-		<context attribute="Comment" lineEndContext="#stay" name="literate-normal">-			<DetectChar attribute="Special" context="normal" char="&gt;" column="0"/>-		</context>-		<context attribute="Normal Text" lineEndContext="#pop" name="normal">-			<Detect2Chars attribute="Comment" context="comment_multi_line" char="{" char1="-" />-			<Detect2Chars attribute="Comment" context="comment_single_line" char="-" char1="-" />-			<keyword attribute="Keyword" context="#stay" String="keywords" />-			<keyword attribute="Class" context="#stay" String="classes" />-			<keyword attribute="Type Constructor" context="#stay" String="type constructors" />-			<keyword attribute="Function" context="#stay" String="functions" />-			<keyword attribute="Data Constructor" context="#stay" String="data constructors" />-			<DetectChar attribute="String" context="string" char="&quot;" />-			<DetectChar attribute="Infix Operator" context="infix" char="`"/>-			<RegExpr attribute="Normal Text" context="#stay" String="\w[']+" />-			<DetectChar attribute="Char" context="single_char" char="'" />-			<RegExpr attribute="Function Definition" context="#stay" String="\s*[a-z_]+\w*'*\s*::" />-			<Float attribute="Float" context="#stay" />-			<Int attribute="Decimal" context="#stay" />-		</context>-		<context attribute="Comment" lineEndContext="#pop#pop" name="comment_single_line" />-		<context attribute="Comment" lineEndContext="#stay" name="comment_multi_line">-			<Detect2Chars attribute="Comment" context="#pop" char="-" char1="}" />-		</context>-		<context attribute="String" lineEndContext="#stay" name="string">-			<RegExpr attribute="String" context="#stay" String="\\." />-			<DetectChar attribute="String" context="#pop" char="&quot;" />-		</context>-		<context attribute="Infix Operator" lineEndContext="#stay" name="infix">-			<DetectChar attribute="Infix Operator" context="#pop" char="`"/>-		</context>-		<context attribute="Char" lineEndContext="#pop" name="single_char">-			<RegExpr attribute="Char" context="#stay" String="\\." />-			<DetectChar attribute="Char" context="#pop" char="'" />-		</context>-		<context attribute="Function Definition" lineEndContext="#pop" name="function_definition">-			<DetectChar attribute="Function Definition" context="#pop" char=";" />-		</context>-	</contexts>-	<itemDatas>-		<itemData name="Normal Text"		defStyleNum="dsNormal"/>-		<itemData name="Keyword" 		defStyleNum="dsKeyword"/>-		<itemData name="Function"		defStyleNum="dsFunction"/>-		<itemData name="Function Definition"	defStyleNum="dsFunction"/>-		<itemData name="Class"			defStyleNum="dsKeyword"/>-		<itemData name="Decimal"		defStyleNum="dsDecVal"/>-		<itemData name="Float"			defStyleNum="dsFloat"/>-		<itemData name="Char"			defStyleNum="dsChar"/>-		<itemData name="String"			defStyleNum="dsString"/>-		<itemData name="Constructor"		defStyleNum="dsOthers"/>-		<itemData name="Comment"		defStyleNum="dsComment"/>-		<itemData name="Data Constructor"	defStyleNum="dsKeyword"/>-		<itemData name="Type Constructor"	defStyleNum="dsDataType"/>-		<itemData name="Infix Operator"		defStyleNum="dsOthers"/>-		<itemData name="Special"		defStyleNum="dsChar"/>-	</itemDatas>-	</highlighting>-	<general>-		<keywords casesensitive="1" />-	</general>+<language name="Literate Haskell" version="2.0.1" kateversion="2.3" section="Sources" extensions="*.lhs" mimetype="text/x-haskell" author="Nicolas Wu (zenzike@gmail.com)" license="" indenter="haskell">+  <highlighting>+  <contexts>+    <context attribute="Text" lineEndContext="#stay" name="text">+      <DetectChar attribute="BirdTrack" context="normal" char="&gt;" column="0"/>+      <DetectChar attribute="BirdTrack" context="normal" char="&lt;" column="0"/>+      <StringDetect attribute="Text" context="normals" String="&#92;begin&#123;code&#125;"/>+      <StringDetect attribute="Text" context="normals" String="&#92;begin&#123;spec&#125;"/>+    </context>+    <context attribute="Normal" lineEndContext="#pop" name="normal">+      <RegExpr attribute="Comment" context="comments'" String="\{-[^#]" />+      <IncludeRules context="##Haskell" />+    </context>+    <context attribute="Normal" lineEndContext="#stay" name="normals">+      <StringDetect attribute="Normal" context="#pop" String="&#92;end&#123;code&#125;"/>+      <StringDetect attribute="Normal" context="#pop" String="&#92;end&#123;spec&#125;"/>+      <IncludeRules context="##Haskell" />+    </context>+    <context attribute="Comment" lineEndContext="uncomments" name="comments'" >+      <Detect2Chars attribute="Comment" context="#pop" char="-" char1="}" />+    </context>+    <context attribute="Text" lineEndContext="#stay" name="uncomments">+      <DetectChar attribute="BirdTrack" context="recomments" char="&gt;" column="0"/>+      <DetectChar attribute="BirdTrack" context="recomments" char="&lt;" column="0"/>+    </context>+    <context attribute="Comment" lineEndContext="#pop" name="recomments">+      <Detect2Chars attribute="Comment" context="#pop#pop#pop" char="-" char1="}" />+    </context>+  </contexts>+  <itemDatas>+    <itemData name="Text"             defStyleNum="dsNormal" spellChecking="true" />+    <itemData name="BirdTrack"        defStyleNum="dsSpecial"  spellChecking="false" />+    <itemData name="Comment"          defStyleNum="dsComment" />+  </itemDatas>+  </highlighting> </language>
+ xml/octave.xml view
@@ -0,0 +1,2219 @@+<?xml version="1.0" encoding="UTF-8"?>+<!DOCTYPE language SYSTEM "language.dtd">+<!--+  ====================================================================+  Octave syntax highlighting file for the KDE editors Kate and Kwrite+  ====================================================================+      based on Octave 2.1.64+      function and variable list obtained by dispatch_help()'s output++  Change log:+  16-Dec-04  Created from Matlab and Scilab files.++  Author: Federico Zenith, Norwegian University of Science and Technology+  Thanks to Luis Silvestre for previous version and suggestions+-->+++<language name="Octave" version="1.01" kateversion="2.3" section="Scientific" extensions="*.octave;*.m;*.M" mimetype="text/octave" casesensitive="1" license="GPL" author="Luis Silvestre and Federico Zenith">++  <highlighting>++    <!-- Reserved keywords in Octave -->+    <list name="keywords">+      <item> all_va_args </item>+      <item> break </item>+      <item> case </item>+      <item> continue </item>+      <item> else </item>+      <item> elseif </item>+      <item> end_unwind_protect </item>+      <item> global </item>+      <item> gplot </item>+      <item> gsplot </item>+      <item> otherwise </item>+      <item> persistent </item>+      <item> replot </item>+      <item> return </item>+      <item> static </item>+      <item> until </item>+      <item> unwind_protect </item>+      <item> unwind_protect_cleanup </item>+      <item> varargin </item>+      <item> varargout </item>+    </list>++    <list name="builtin">+      <item> argv </item>+      <item> e </item>+      <item> eps </item>+      <item> false </item>+      <item> F_DUPFD </item>+      <item> F_GETFD </item>+      <item> F_GETFL </item>+      <item> filesep </item>+      <item> F_SETFD </item>+      <item> F_SETFL </item>+      <item> i </item>+      <item> I </item>+      <item> inf </item>+      <item> Inf </item>+      <item> j </item>+      <item> J </item>+      <item> NA </item>+      <item> nan </item>+      <item> NaN </item>+      <item> O_APPEND </item>+      <item> O_ASYNC </item>+      <item> O_CREAT </item>+      <item> OCTAVE_HOME </item>+      <item> OCTAVE_VERSION </item>+      <item> O_EXCL </item>+      <item> O_NONBLOCK </item>+      <item> O_RDONLY </item>+      <item> O_RDWR </item>+      <item> O_SYNC </item>+      <item> O_TRUNC </item>+      <item> O_WRONLY </item>+      <item> pi </item>+      <item> program_invocation_name </item>+      <item> program_name </item>+      <item> P_tmpdir </item>+      <item> realmax </item>+      <item> realmin </item>+      <item> SEEK_CUR </item>+      <item> SEEK_END </item>+      <item> SEEK_SET </item>+      <item> SIG </item>+      <item> stderr </item>+      <item> stdin </item>+      <item> stdout </item>+      <item> true </item>+      <item> ans </item>+      <item> automatic_replot </item>+      <item> beep_on_error </item>+      <item> completion_append_char </item>+      <item> crash_dumps_octave_core </item>+      <item> current_script_file_name </item>+      <item> debug_on_error </item>+      <item> debug_on_interrupt </item>+      <item> debug_on_warning </item>+      <item> debug_symtab_lookups </item>+      <item> DEFAULT_EXEC_PATH </item>+      <item> DEFAULT_LOADPATH </item>+      <item> default_save_format </item>+      <item> echo_executing_commands </item>+      <item> EDITOR </item>+      <item> EXEC_PATH </item>+      <item> FFTW_WISDOM_PROGRAM </item>+      <item> fixed_point_format </item>+      <item> gnuplot_binary </item>+      <item> gnuplot_command_axes </item>+      <item> gnuplot_command_end </item>+      <item> gnuplot_command_plot </item>+      <item> gnuplot_command_replot </item>+      <item> gnuplot_command_splot </item>+      <item> gnuplot_command_title </item>+      <item> gnuplot_command_using </item>+      <item> gnuplot_command_with </item>+      <item> gnuplot_has_frames </item>+      <item> history_file </item>+      <item> history_size </item>+      <item> ignore_function_time_stamp </item>+      <item> IMAGEPATH </item>+      <item> INFO_FILE </item>+      <item> INFO_PROGRAM </item>+      <item> __kluge_procbuf_delay__ </item>+      <item> LOADPATH </item>+      <item> MAKEINFO_PROGRAM </item>+      <item> max_recursion_depth </item>+      <item> octave_core_file_format </item>+      <item> octave_core_file_limit </item>+      <item> octave_core_file_name </item>+      <item> output_max_field_width </item>+      <item> output_precision </item>+      <item> page_output_immediately </item>+      <item> PAGER </item>+      <item> page_screen_output </item>+      <item> print_answer_id_name </item>+      <item> print_empty_dimensions </item>+      <item> print_rhs_assign_val </item>+      <item> PS1 </item>+      <item> PS2 </item>+      <item> PS4 </item>+      <item> save_header_format_string </item>+      <item> save_precision </item>+      <item> saving_history </item>+      <item> sighup_dumps_octave_core </item>+      <item> sigterm_dumps_octave_core </item>+      <item> silent_functions </item>+      <item> split_long_rows </item>+      <item> string_fill_char </item>+      <item> struct_levels_to_print </item>+      <item> suppress_verbose_help_message </item>+      <item> variables_can_hide_functions </item>+      <item> warn_assign_as_truth_value </item>+      <item> warn_divide_by_zero </item>+      <item> warn_empty_list_elements </item>+      <item> warn_fortran_indexing </item>+      <item> warn_function_name_clash </item>+      <item> warn_future_time_stamp </item>+      <item> warn_imag_to_real </item>+      <item> warn_matlab_incompatible </item>+      <item> warn_missing_semicolon </item>+      <item> warn_neg_dim_as_zero </item>+      <item> warn_num_to_str </item>+      <item> warn_precedence_change </item>+      <item> warn_reload_forces_clear </item>+      <item> warn_resize_on_range_error </item>+      <item> warn_separator_insert </item>+      <item> warn_single_quote_string </item>+      <item> warn_str_to_num </item>+      <item> warn_undefined_return_values </item>+      <item> warn_variable_switch_label </item>+      <item> whos_line_format </item>+    </list>+    +    <list name="commands">+      <item> casesen </item>+      <item> cd </item>+      <item> chdir </item>+      <item> clear </item>+      <item> dbclear </item>+      <item> dbstatus </item>+      <item> dbstop </item>+      <item> dbtype </item>+      <item> dbwhere </item>+      <item> diary </item>+      <item> echo </item>+      <item> edit_history </item>+      <item> __end__ </item>+      <item> format </item>+      <item> gset </item>+      <item> gshow </item>+      <item> help </item>+      <item> history </item>+      <item> hold </item>+      <item> iskeyword </item>+      <item> isvarname </item>+      <item> load </item>+      <item> ls </item>+      <item> mark_as_command </item>+      <item> mislocked </item>+      <item> mlock </item>+      <item> more </item>+      <item> munlock </item>+      <item> run_history </item>+      <item> save </item>+      <item> set </item>+      <item> show </item>+      <item> type </item>+      <item> unmark_command </item>+      <item> which </item>+      <item> who </item>+      <item> whos </item>+    </list>+    +    <list name="functions">+      <item> abs </item>+      <item> acos </item>+      <item> acosh </item>+      <item> all </item>+      <item> angle </item>+      <item> any </item>+      <item> append </item>+      <item> arg </item>+      <item> argnames </item>+      <item> asin </item>+      <item> asinh </item>+      <item> assignin </item>+      <item> atan </item>+      <item> atan2 </item>+      <item> atanh </item>+      <item> atexit </item>+      <item> bitand </item>+      <item> bitmax </item>+      <item> bitor </item>+      <item> bitshift </item>+      <item> bitxor </item>+      <item> casesen </item>+      <item> cat </item>+      <item> cd </item>+      <item> ceil </item>+      <item> cell </item>+      <item> cell2struct </item>+      <item> cellstr </item>+      <item> char </item>+      <item> chdir </item>+      <item> class </item>+      <item> clc </item>+      <item> clear </item>+      <item> clearplot </item>+      <item> clg </item>+      <item> closeplot </item>+      <item> completion_matches </item>+      <item> conj </item>+      <item> conv </item>+      <item> convmtx </item>+      <item> cos </item>+      <item> cosh </item>+      <item> cumprod </item>+      <item> cumsum </item>+      <item> dbclear </item>+      <item> dbstatus </item>+      <item> dbstop </item>+      <item> dbtype </item>+      <item> dbwhere </item>+      <item> deconv </item>+      <item> det </item>+      <item> dftmtx </item>+      <item> diag </item>+      <item> diary </item>+      <item> disp </item>+      <item> document </item>+      <item> do_string_escapes </item>+      <item> double </item>+      <item> dup2 </item>+      <item> echo </item>+      <item> edit_history </item>+      <item> __end__ </item>+      <item> erf </item>+      <item> erfc </item>+      <item> ERRNO </item>+      <item> error </item>+      <item> __error_text__ </item>+      <item> error_text </item>+      <item> eval </item>+      <item> evalin </item>+      <item> exec </item>+      <item> exist </item>+      <item> exit </item>+      <item> exp </item>+      <item> eye </item>+      <item> fclose </item>+      <item> fcntl </item>+      <item> fdisp </item>+      <item> feof </item>+      <item> ferror </item>+      <item> feval </item>+      <item> fflush </item>+      <item> fft </item>+      <item> fgetl </item>+      <item> fgets </item>+      <item> fieldnames </item>+      <item> file_in_loadpath </item>+      <item> file_in_path </item>+      <item> filter </item>+      <item> find </item>+      <item> find_first_of_in_loadpath </item>+      <item> finite </item>+      <item> fix </item>+      <item> floor </item>+      <item> fmod </item>+      <item> fnmatch </item>+      <item> fopen </item>+      <item> fork </item>+      <item> format </item>+      <item> formula </item>+      <item> fprintf </item>+      <item> fputs </item>+      <item> fread </item>+      <item> freport </item>+      <item> frewind </item>+      <item> fscanf </item>+      <item> fseek </item>+      <item> ftell </item>+      <item> func2str </item>+      <item> functions </item>+      <item> fwrite </item>+      <item> gamma </item>+      <item> gammaln </item>+      <item> getegid </item>+      <item> getenv </item>+      <item> geteuid </item>+      <item> getgid </item>+      <item> getpgrp </item>+      <item> getpid </item>+      <item> getppid </item>+      <item> getuid </item>+      <item> glob </item>+      <item> graw </item>+      <item> gset </item>+      <item> gshow </item>+      <item> help </item>+      <item> history </item>+      <item> hold </item>+      <item> home </item>+      <item> horzcat </item>+      <item> ifft </item>+      <item> imag </item>+      <item> inline </item>+      <item> input </item>+      <item> input_event_hook </item>+      <item> int16 </item>+      <item> int32 </item>+      <item> int64 </item>+      <item> int8 </item>+      <item> intmax </item>+      <item> intmin </item>+      <item> inv </item>+      <item> inverse </item>+      <item> ipermute </item>+      <item> isalnum </item>+      <item> isalpha </item>+      <item> isascii </item>+      <item> isbool </item>+      <item> iscell </item>+      <item> iscellstr </item>+      <item> ischar </item>+      <item> iscntrl </item>+      <item> iscomplex </item>+      <item> isdigit </item>+      <item> isempty </item>+      <item> isfield </item>+      <item> isfinite </item>+      <item> isglobal </item>+      <item> isgraph </item>+      <item> ishold </item>+      <item> isieee </item>+      <item> isinf </item>+      <item> iskeyword </item>+      <item> islist </item>+      <item> islogical </item>+      <item> islower </item>+      <item> ismatrix </item>+      <item> isna </item>+      <item> isnan </item>+      <item> is_nan_or_na </item>+      <item> isnumeric </item>+      <item> isprint </item>+      <item> ispunct </item>+      <item> isreal </item>+      <item> isspace </item>+      <item> isstream </item>+      <item> isstreamoff </item>+      <item> isstruct </item>+      <item> isupper </item>+      <item> isvarname </item>+      <item> isxdigit </item>+      <item> kbhit </item>+      <item> keyboard </item>+      <item> kill </item>+      <item> lasterr </item>+      <item> lastwarn </item>+      <item> length </item>+      <item> lgamma </item>+      <item> link </item>+      <item> linspace </item>+      <item> list </item>+      <item> load </item>+      <item> log </item>+      <item> log10 </item>+      <item> ls </item>+      <item> lstat </item>+      <item> lu </item>+      <item> mark_as_command </item>+      <item> mislocked </item>+      <item> mkdir </item>+      <item> mkfifo </item>+      <item> mkstemp </item>+      <item> mlock </item>+      <item> more </item>+      <item> munlock </item>+      <item> nargin </item>+      <item> nargout </item>+      <item> native_float_format </item>+      <item> ndims </item>+      <item> nth </item>+      <item> numel </item>+      <item> octave_config_info </item>+      <item> octave_tmp_file_name </item>+      <item> ones </item>+      <item> pause </item>+      <item> pclose </item>+      <item> permute </item>+      <item> pipe </item>+      <item> popen </item>+      <item> printf </item>+      <item> __print_symbol_info__ </item>+      <item> __print_symtab_info__ </item>+      <item> prod </item>+      <item> purge_tmp_files </item>+      <item> putenv </item>+      <item> puts </item>+      <item> pwd </item>+      <item> quit </item>+      <item> rank </item>+      <item> readdir </item>+      <item> readlink </item>+      <item> read_readline_init_file </item>+      <item> real </item>+      <item> rehash </item>+      <item> rename </item>+      <item> reshape </item>+      <item> reverse </item>+      <item> rmdir </item>+      <item> rmfield </item>+      <item> roots </item>+      <item> round </item>+      <item> run_history </item>+      <item> save </item>+      <item> scanf </item>+      <item> set </item>+      <item> shell_cmd </item>+      <item> show </item>+      <item> sign </item>+      <item> sin </item>+      <item> sinh </item>+      <item> size </item>+      <item> sizeof </item>+      <item> sleep </item>+      <item> sort </item>+      <item> source </item>+      <item> splice </item>+      <item> sprintf </item>+      <item> sqrt </item>+      <item> squeeze </item>+      <item> sscanf </item>+      <item> stat </item>+      <item> str2func </item>+      <item> streamoff </item>+      <item> struct </item>+      <item> struct2cell </item>+      <item> sum </item>+      <item> sumsq </item>+      <item> symlink </item>+      <item> system </item>+      <item> tan </item>+      <item> tanh </item>+      <item> tilde_expand </item>+      <item> tmpfile </item>+      <item> tmpnam </item>+      <item> toascii </item>+      <item> __token_count__ </item>+      <item> tolower </item>+      <item> toupper </item>+      <item> type </item>+      <item> typeinfo </item>+      <item> uint16 </item>+      <item> uint32 </item>+      <item> uint64 </item>+      <item> uint8 </item>+      <item> umask </item>+      <item> undo_string_escapes </item>+      <item> unlink </item>+      <item> unmark_command </item>+      <item> usage </item>+      <item> usleep </item>+      <item> va_arg </item>+      <item> va_start </item>+      <item> vectorize </item>+      <item> vertcat </item>+      <item> vr_val </item>+      <item> waitpid </item>+      <item> warning </item>+      <item> warranty </item>+      <item> which </item>+      <item> who </item>+      <item> whos </item>+      <item> zeros </item>+      <item> airy </item>+      <item> balance </item>+      <item> besselh </item>+      <item> besseli </item>+      <item> besselj </item>+      <item> besselk </item>+      <item> bessely </item>+      <item> betainc </item>+      <item> chol </item>+      <item> colloc </item>+      <item> daspk </item>+      <item> daspk_options </item>+      <item> dasrt </item>+      <item> dasrt_options </item>+      <item> dassl </item>+      <item> dassl_options </item>+      <item> det </item>+      <item> eig </item>+      <item> endgrent </item>+      <item> endpwent </item>+      <item> expm </item>+      <item> fft </item>+      <item> fft2 </item>+      <item> fftn </item>+      <item> fftw_wisdom </item>+      <item> filter </item>+      <item> find </item>+      <item> fsolve </item>+      <item> fsolve_options </item>+      <item> gammainc </item>+      <item> gcd </item>+      <item> getgrent </item>+      <item> getgrgid </item>+      <item> getgrnam </item>+      <item> getpwent </item>+      <item> getpwnam </item>+      <item> getpwuid </item>+      <item> getrusage </item>+      <item> givens </item>+      <item> gmtime </item>+      <item> hess </item>+      <item> ifft </item>+      <item> ifft2 </item>+      <item> ifftn </item>+      <item> inv </item>+      <item> inverse </item>+      <item> kron </item>+      <item> localtime </item>+      <item> lpsolve </item>+      <item> lpsolve_options </item>+      <item> lsode </item>+      <item> lsode_options </item>+      <item> lu </item>+      <item> max </item>+      <item> min </item>+      <item> minmax </item>+      <item> mktime </item>+      <item> odessa </item>+      <item> odessa_options </item>+      <item> pinv </item>+      <item> qr </item>+      <item> quad </item>+      <item> quad_options </item>+      <item> qz </item>+      <item> rand </item>+      <item> randn </item>+      <item> schur </item>+      <item> setgrent </item>+      <item> setpwent </item>+      <item> sort </item>+      <item> sqrtm </item>+      <item> strftime </item>+      <item> strptime </item>+      <item> svd </item>+      <item> syl </item>+      <item> time </item>+      <item> abcddim </item>+      <item> __abcddims__ </item>+      <item> acot </item>+      <item> acoth </item>+      <item> acsc </item>+      <item> acsch </item>+      <item> analdemo </item>+      <item> anova </item>+      <item> arch_fit </item>+      <item> arch_rnd </item>+      <item> arch_test </item>+      <item> are </item>+      <item> arma_rnd </item>+      <item> asctime </item>+      <item> asec </item>+      <item> asech </item>+      <item> autocor </item>+      <item> autocov </item>+      <item> autoreg_matrix </item>+      <item> axis </item>+      <item> axis2dlim </item>+      <item> __axis_label__ </item>+      <item> bar </item>+      <item> bartlett </item>+      <item> bartlett_test </item>+      <item> base2dec </item>+      <item> bddemo </item>+      <item> beep </item>+      <item> bessel </item>+      <item> beta </item>+      <item> beta_cdf </item>+      <item> betai </item>+      <item> beta_inv </item>+      <item> beta_pdf </item>+      <item> beta_rnd </item>+      <item> bin2dec </item>+      <item> bincoeff </item>+      <item> binomial_cdf </item>+      <item> binomial_inv </item>+      <item> binomial_pdf </item>+      <item> binomial_rnd </item>+      <item> bitcmp </item>+      <item> bitget </item>+      <item> bitset </item>+      <item> blackman </item>+      <item> blanks </item>+      <item> bode </item>+      <item> bode_bounds </item>+      <item> __bodquist__ </item>+      <item> bottom_title </item>+      <item> bug_report </item>+      <item> buildssic </item>+      <item> c2d </item>+      <item> cart2pol </item>+      <item> cart2sph </item>+      <item> cauchy_cdf </item>+      <item> cauchy_inv </item>+      <item> cauchy_pdf </item>+      <item> cauchy_rnd </item>+      <item> cellidx </item>+      <item> center </item>+      <item> chisquare_cdf </item>+      <item> chisquare_inv </item>+      <item> chisquare_pdf </item>+      <item> chisquare_rnd </item>+      <item> chisquare_test_homogeneity </item>+      <item> chisquare_test_independence </item>+      <item> circshift </item>+      <item> clock </item>+      <item> cloglog </item>+      <item> close </item>+      <item> colormap </item>+      <item> columns </item>+      <item> com2str </item>+      <item> comma </item>+      <item> common_size </item>+      <item> commutation_matrix </item>+      <item> compan </item>+      <item> complement </item>+      <item> computer </item>+      <item> cond </item>+      <item> contour </item>+      <item> controldemo </item>+      <item> conv </item>+      <item> cor </item>+      <item> corrcoef </item>+      <item> cor_test </item>+      <item> cot </item>+      <item> coth </item>+      <item> cov </item>+      <item> cputime </item>+      <item> create_set </item>+      <item> cross </item>+      <item> csc </item>+      <item> csch </item>+      <item> ctime </item>+      <item> ctrb </item>+      <item> cut </item>+      <item> d2c </item>+      <item> damp </item>+      <item> dare </item>+      <item> date </item>+      <item> dcgain </item>+      <item> deal </item>+      <item> deblank </item>+      <item> dec2base </item>+      <item> dec2bin </item>+      <item> dec2hex </item>+      <item> deconv </item>+      <item> delete </item>+      <item> DEMOcontrol </item>+      <item> demoquat </item>+      <item> detrend </item>+      <item> dezero </item>+      <item> dgkfdemo </item>+      <item> dgram </item>+      <item> dhinfdemo </item>+      <item> diff </item>+      <item> diffpara </item>+      <item> dir </item>+      <item> discrete_cdf </item>+      <item> discrete_inv </item>+      <item> discrete_pdf </item>+      <item> discrete_rnd </item>+      <item> dkalman </item>+      <item> dlqe </item>+      <item> dlqg </item>+      <item> dlqr </item>+      <item> dlyap </item>+      <item> dmr2d </item>+      <item> dmult </item>+      <item> dot </item>+      <item> dre </item>+      <item> dump_prefs </item>+      <item> duplication_matrix </item>+      <item> durbinlevinson </item>+      <item> empirical_cdf </item>+      <item> empirical_inv </item>+      <item> empirical_pdf </item>+      <item> empirical_rnd </item>+      <item> erfinv </item>+      <item> __errcomm__ </item>+      <item> errorbar </item>+      <item> __errplot__ </item>+      <item> etime </item>+      <item> exponential_cdf </item>+      <item> exponential_inv </item>+      <item> exponential_pdf </item>+      <item> exponential_rnd </item>+      <item> f_cdf </item>+      <item> fftconv </item>+      <item> fftfilt </item>+      <item> fftshift </item>+      <item> figure </item>+      <item> fileparts </item>+      <item> findstr </item>+      <item> f_inv </item>+      <item> fir2sys </item>+      <item> flipdim </item>+      <item> fliplr </item>+      <item> flipud </item>+      <item> flops </item>+      <item> f_pdf </item>+      <item> fractdiff </item>+      <item> frdemo </item>+      <item> freqchkw </item>+      <item> __freqresp__ </item>+      <item> freqz </item>+      <item> freqz_plot </item>+      <item> f_rnd </item>+      <item> f_test_regression </item>+      <item> fullfile </item>+      <item> fv </item>+      <item> fvl </item>+      <item> gamma_cdf </item>+      <item> gammai </item>+      <item> gamma_inv </item>+      <item> gamma_pdf </item>+      <item> gamma_rnd </item>+      <item> geometric_cdf </item>+      <item> geometric_inv </item>+      <item> geometric_pdf </item>+      <item> geometric_rnd </item>+      <item> gls </item>+      <item> gram </item>+      <item> gray </item>+      <item> gray2ind </item>+      <item> grid </item>+      <item> h2norm </item>+      <item> h2syn </item>+      <item> hamming </item>+      <item> hankel </item>+      <item> hanning </item>+      <item> hex2dec </item>+      <item> hilb </item>+      <item> hinf_ctr </item>+      <item> hinfdemo </item>+      <item> hinfnorm </item>+      <item> hinfsyn </item>+      <item> hinfsyn_chk </item>+      <item> hinfsyn_ric </item>+      <item> hist </item>+      <item> hotelling_test </item>+      <item> hotelling_test_2 </item>+      <item> housh </item>+      <item> hsv2rgb </item>+      <item> hurst </item>+      <item> hypergeometric_cdf </item>+      <item> hypergeometric_inv </item>+      <item> hypergeometric_pdf </item>+      <item> hypergeometric_rnd </item>+      <item> image </item>+      <item> imagesc </item>+      <item> impulse </item>+      <item> imshow </item>+      <item> ind2gray </item>+      <item> ind2rgb </item>+      <item> ind2sub </item>+      <item> index </item>+      <item> int2str </item>+      <item> intersection </item>+      <item> invhilb </item>+      <item> iqr </item>+      <item> irr </item>+      <item> isa </item>+      <item> is_abcd </item>+      <item> is_bool </item>+      <item> is_complex </item>+      <item> is_controllable </item>+      <item> isdefinite </item>+      <item> is_detectable </item>+      <item> is_dgkf </item>+      <item> is_digital </item>+      <item> is_duplicate_entry </item>+      <item> is_global </item>+      <item> is_leap_year </item>+      <item> isletter </item>+      <item> is_list </item>+      <item> is_matrix </item>+      <item> is_observable </item>+      <item> ispc </item>+      <item> is_sample </item>+      <item> is_scalar </item>+      <item> isscalar </item>+      <item> is_signal_list </item>+      <item> is_siso </item>+      <item> is_square </item>+      <item> issquare </item>+      <item> is_stabilizable </item>+      <item> is_stable </item>+      <item> isstr </item>+      <item> is_stream </item>+      <item> is_struct </item>+      <item> is_symmetric </item>+      <item> issymmetric </item>+      <item> isunix </item>+      <item> is_vector </item>+      <item> isvector </item>+      <item> jet707 </item>+      <item> kendall </item>+      <item> kolmogorov_smirnov_cdf </item>+      <item> kolmogorov_smirnov_test </item>+      <item> kolmogorov_smirnov_test_2 </item>+      <item> kruskal_wallis_test </item>+      <item> krylov </item>+      <item> krylovb </item>+      <item> kurtosis </item>+      <item> laplace_cdf </item>+      <item> laplace_inv </item>+      <item> laplace_pdf </item>+      <item> laplace_rnd </item>+      <item> lcm </item>+      <item> lin2mu </item>+      <item> listidx </item>+      <item> list_primes </item>+      <item> loadaudio </item>+      <item> loadimage </item>+      <item> log2 </item>+      <item> logical </item>+      <item> logistic_cdf </item>+      <item> logistic_inv </item>+      <item> logistic_pdf </item>+      <item> logistic_regression </item>+      <item> logistic_regression_derivatives </item>+      <item> logistic_regression_likelihood </item>+      <item> logistic_rnd </item>+      <item> logit </item>+      <item> loglog </item>+      <item> loglogerr </item>+      <item> logm </item>+      <item> lognormal_cdf </item>+      <item> lognormal_inv </item>+      <item> lognormal_pdf </item>+      <item> lognormal_rnd </item>+      <item> logspace </item>+      <item> lower </item>+      <item> lqe </item>+      <item> lqg </item>+      <item> lqr </item>+      <item> lsim </item>+      <item> ltifr </item>+      <item> lyap </item>+      <item> mahalanobis </item>+      <item> manova </item>+      <item> mcnemar_test </item>+      <item> mean </item>+      <item> meansq </item>+      <item> median </item>+      <item> menu </item>+      <item> mesh </item>+      <item> meshdom </item>+      <item> meshgrid </item>+      <item> minfo </item>+      <item> mod </item>+      <item> moddemo </item>+      <item> moment </item>+      <item> mplot </item>+      <item> mu2lin </item>+      <item> multiplot </item>+      <item> nargchk </item>+      <item> nextpow2 </item>+      <item> nichols </item>+      <item> norm </item>+      <item> normal_cdf </item>+      <item> normal_inv </item>+      <item> normal_pdf </item>+      <item> normal_rnd </item>+      <item> not </item>+      <item> nper </item>+      <item> npv </item>+      <item> ntsc2rgb </item>+      <item> null </item>+      <item> num2str </item>+      <item> nyquist </item>+      <item> obsv </item>+      <item> ocean </item>+      <item> ols </item>+      <item> oneplot </item>+      <item> ord2 </item>+      <item> orth </item>+      <item> __outlist__ </item>+      <item> pack </item>+      <item> packedform </item>+      <item> packsys </item>+      <item> parallel </item>+      <item> paren </item>+      <item> pascal_cdf </item>+      <item> pascal_inv </item>+      <item> pascal_pdf </item>+      <item> pascal_rnd </item>+      <item> path </item>+      <item> periodogram </item>+      <item> perror </item>+      <item> place </item>+      <item> playaudio </item>+      <item> plot </item>+      <item> plot_border </item>+      <item> __plr__ </item>+      <item> __plr1__ </item>+      <item> __plr2__ </item>+      <item> __plt__ </item>+      <item> __plt1__ </item>+      <item> __plt2__ </item>+      <item> __plt2mm__ </item>+      <item> __plt2mv__ </item>+      <item> __plt2ss__ </item>+      <item> __plt2vm__ </item>+      <item> __plt2vv__ </item>+      <item> __pltopt__ </item>+      <item> __pltopt1__ </item>+      <item> pmt </item>+      <item> poisson_cdf </item>+      <item> poisson_inv </item>+      <item> poisson_pdf </item>+      <item> poisson_rnd </item>+      <item> pol2cart </item>+      <item> polar </item>+      <item> poly </item>+      <item> polyder </item>+      <item> polyderiv </item>+      <item> polyfit </item>+      <item> polyinteg </item>+      <item> polyout </item>+      <item> polyreduce </item>+      <item> polyval </item>+      <item> polyvalm </item>+      <item> popen2 </item>+      <item> postpad </item>+      <item> pow2 </item>+      <item> ppplot </item>+      <item> prepad </item>+      <item> probit </item>+      <item> prompt </item>+      <item> prop_test_2 </item>+      <item> pv </item>+      <item> pvl </item>+      <item> pzmap </item>+      <item> qconj </item>+      <item> qcoordinate_plot </item>+      <item> qderiv </item>+      <item> qderivmat </item>+      <item> qinv </item>+      <item> qmult </item>+      <item> qqplot </item>+      <item> qtrans </item>+      <item> qtransv </item>+      <item> qtransvmat </item>+      <item> quaternion </item>+      <item> qzhess </item>+      <item> qzval </item>+      <item> randperm </item>+      <item> range </item>+      <item> rank </item>+      <item> ranks </item>+      <item> rate </item>+      <item> record </item>+      <item> rectangle_lw </item>+      <item> rectangle_sw </item>+      <item> rem </item>+      <item> repmat </item>+      <item> residue </item>+      <item> rgb2hsv </item>+      <item> rgb2ind </item>+      <item> rgb2ntsc </item>+      <item> rindex </item>+      <item> rldemo </item>+      <item> rlocus </item>+      <item> roots </item>+      <item> rot90 </item>+      <item> rotdim </item>+      <item> rotg </item>+      <item> rows </item>+      <item> run_cmd </item>+      <item> run_count </item>+      <item> run_test </item>+      <item> saveaudio </item>+      <item> saveimage </item>+      <item> sec </item>+      <item> sech </item>+      <item> semicolon </item>+      <item> semilogx </item>+      <item> semilogxerr </item>+      <item> semilogy </item>+      <item> semilogyerr </item>+      <item> series </item>+      <item> setaudio </item>+      <item> setstr </item>+      <item> shg </item>+      <item> shift </item>+      <item> shiftdim </item>+      <item> sign_test </item>+      <item> sinc </item>+      <item> sinetone </item>+      <item> sinewave </item>+      <item> skewness </item>+      <item> sombrero </item>+      <item> sortcom </item>+      <item> spearman </item>+      <item> spectral_adf </item>+      <item> spectral_xdf </item>+      <item> spencer </item>+      <item> sph2cart </item>+      <item> split </item>+      <item> ss </item>+      <item> ss2sys </item>+      <item> ss2tf </item>+      <item> ss2zp </item>+      <item> stairs </item>+      <item> starp </item>+      <item> statistics </item>+      <item> std </item>+      <item> stdnormal_cdf </item>+      <item> stdnormal_inv </item>+      <item> stdnormal_pdf </item>+      <item> stdnormal_rnd </item>+      <item> step </item>+      <item> __stepimp__ </item>+      <item> stft </item>+      <item> str2mat </item>+      <item> str2num </item>+      <item> strappend </item>+      <item> strcat </item>+      <item> strcmp </item>+      <item> strerror </item>+      <item> strjust </item>+      <item> strrep </item>+      <item> struct_contains </item>+      <item> struct_elements </item>+      <item> studentize </item>+      <item> sub2ind </item>+      <item> subplot </item>+      <item> substr </item>+      <item> subwindow </item>+      <item> swap </item>+      <item> swapcols </item>+      <item> swaprows </item>+      <item> sylvester_matrix </item>+      <item> synthesis </item>+      <item> sys2fir </item>+      <item> sys2ss </item>+      <item> sys2tf </item>+      <item> sys2zp </item>+      <item> sysadd </item>+      <item> sysappend </item>+      <item> syschnames </item>+      <item> __syschnamesl__ </item>+      <item> syschtsam </item>+      <item> __sysconcat__ </item>+      <item> sysconnect </item>+      <item> syscont </item>+      <item> __syscont_disc__ </item>+      <item> __sysdefioname__ </item>+      <item> __sysdefstname__ </item>+      <item> sysdimensions </item>+      <item> sysdisc </item>+      <item> sysdup </item>+      <item> sysgetsignals </item>+      <item> sysgettsam </item>+      <item> sysgettype </item>+      <item> sysgroup </item>+      <item> __sysgroupn__ </item>+      <item> sysidx </item>+      <item> sysmin </item>+      <item> sysmult </item>+      <item> sysout </item>+      <item> sysprune </item>+      <item> sysreorder </item>+      <item> sysrepdemo </item>+      <item> sysscale </item>+      <item> syssetsignals </item>+      <item> syssub </item>+      <item> sysupdate </item>+      <item> table </item>+      <item> t_cdf </item>+      <item> tempdir </item>+      <item> tempname </item>+      <item> texas_lotto </item>+      <item> tf </item>+      <item> tf2ss </item>+      <item> tf2sys </item>+      <item> __tf2sysl__ </item>+      <item> tf2zp </item>+      <item> __tfl__ </item>+      <item> tfout </item>+      <item> tic </item>+      <item> t_inv </item>+      <item> title </item>+      <item> toc </item>+      <item> toeplitz </item>+      <item> top_title </item>+      <item> t_pdf </item>+      <item> trace </item>+      <item> triangle_lw </item>+      <item> triangle_sw </item>+      <item> tril </item>+      <item> triu </item>+      <item> t_rnd </item>+      <item> t_test </item>+      <item> t_test_2 </item>+      <item> t_test_regression </item>+      <item> tzero </item>+      <item> tzero2 </item>+      <item> ugain </item>+      <item> uniform_cdf </item>+      <item> uniform_inv </item>+      <item> uniform_pdf </item>+      <item> uniform_rnd </item>+      <item> union </item>+      <item> unix </item>+      <item> unpacksys </item>+      <item> unwrap </item>+      <item> upper </item>+      <item> u_test </item>+      <item> values </item>+      <item> vander </item>+      <item> var </item>+      <item> var_test </item>+      <item> vec </item>+      <item> vech </item>+      <item> version </item>+      <item> vol </item>+      <item> weibull_cdf </item>+      <item> weibull_inv </item>+      <item> weibull_pdf </item>+      <item> weibull_rnd </item>+      <item> welch_test </item>+      <item> wgt1o </item>+      <item> wiener_rnd </item>+      <item> wilcoxon_test </item>+      <item> xlabel </item>+      <item> xor </item>+      <item> ylabel </item>+      <item> yulewalker </item>+      <item> zgfmul </item>+      <item> zgfslv </item>+      <item> zginit </item>+      <item> __zgpbal__ </item>+      <item> zgreduce </item>+      <item> zgrownorm </item>+      <item> zgscal </item>+      <item> zgsgiv </item>+      <item> zgshsr </item>+      <item> zlabel </item>+      <item> zp </item>+      <item> zp2ss </item>+      <item> __zp2ssg2__ </item>+      <item> zp2sys </item>+      <item> zp2tf </item>+      <item> zpout </item>+      <item> z_test </item>+      <item> z_test_2 </item>+    </list>+    +    <list name="forge">+      <item> airy_Ai </item>+      <item> airy_Ai_deriv </item>+      <item> airy_Ai_deriv_scaled </item>+      <item> airy_Ai_scaled </item>+      <item> airy_Bi </item>+      <item> airy_Bi_deriv </item>+      <item> airy_Bi_deriv_scaled </item>+      <item> airy_Bi_scaled </item>+      <item> airy_zero_Ai </item>+      <item> airy_zero_Ai_deriv </item>+      <item> airy_zero_Bi </item>+      <item> airy_zero_Bi_deriv </item>+      <item> atanint </item>+      <item> bchdeco </item>+      <item> bchenco </item>+      <item> bessel_il_scaled </item>+      <item> bessel_In </item>+      <item> bessel_In_scaled </item>+      <item> bessel_Inu </item>+      <item> bessel_Inu_scaled </item>+      <item> bessel_jl </item>+      <item> bessel_Jn </item>+      <item> bessel_Jnu </item>+      <item> bessel_kl_scaled </item>+      <item> bessel_Kn </item>+      <item> bessel_Kn_scaled </item>+      <item> bessel_Knu </item>+      <item> bessel_Knu_scaled </item>+      <item> bessel_lnKnu </item>+      <item> bessel_yl </item>+      <item> bessel_Yn </item>+      <item> bessel_Ynu </item>+      <item> bessel_zero_J0 </item>+      <item> bessel_zero_J1 </item>+      <item> beta_gsl </item>+      <item> bfgsmin </item>+      <item> bisectionstep </item>+      <item> builtin </item>+      <item> bwfill </item>+      <item> bwlabel </item>+      <item> cell2csv </item>+      <item> celleval </item>+      <item> Chi </item>+      <item> chol </item>+      <item> Ci </item>+      <item> clausen </item>+      <item> conicalP_0 </item>+      <item> conicalP_1 </item>+      <item> conicalP_half </item>+      <item> conicalP_mhalf </item>+      <item> conv2 </item>+      <item> cordflt2 </item>+      <item> coupling_3j </item>+      <item> coupling_6j </item>+      <item> coupling_9j </item>+      <item> csv2cell </item>+      <item> csvconcat </item>+      <item> csvexplode </item>+      <item> cyclgen </item>+      <item> cyclpoly </item>+      <item> dawson </item>+      <item> debye_1 </item>+      <item> debye_2 </item>+      <item> debye_3 </item>+      <item> debye_4 </item>+      <item> deref </item>+      <item> dispatch </item>+      <item> dispatch_help </item>+      <item> display_fixed_operations </item>+      <item> dlmread </item>+      <item> ellint_Ecomp </item>+      <item> ellint_Kcomp </item>+      <item> ellipj </item>+      <item> erfc_gsl </item>+      <item> erf_gsl </item>+      <item> erf_Q </item>+      <item> erf_Z </item>+      <item> _errcore </item>+      <item> eta </item>+      <item> eta_int </item>+      <item> expint_3 </item>+      <item> expint_E1 </item>+      <item> expint_E2 </item>+      <item> expint_Ei </item>+      <item> expm1 </item>+      <item> exp_mult </item>+      <item> exprel </item>+      <item> exprel_2 </item>+      <item> exprel_n </item>+      <item> fabs </item>+      <item> fangle </item>+      <item> farg </item>+      <item> fatan2 </item>+      <item> fceil </item>+      <item> fconj </item>+      <item> fcos </item>+      <item> fcosh </item>+      <item> fcumprod </item>+      <item> fcumsum </item>+      <item> fdiag </item>+      <item> fermi_dirac_3half </item>+      <item> fermi_dirac_half </item>+      <item> fermi_dirac_inc_0 </item>+      <item> fermi_dirac_int </item>+      <item> fermi_dirac_mhalf </item>+      <item> fexp </item>+      <item> ffloor </item>+      <item> fimag </item>+      <item> finitedifference </item>+      <item> fixed </item>+      <item> flog </item>+      <item> flog10 </item>+      <item> fprod </item>+      <item> freal </item>+      <item> freshape </item>+      <item> fround </item>+      <item> fsin </item>+      <item> fsinh </item>+      <item> fsqrt </item>+      <item> fsum </item>+      <item> fsumsq </item>+      <item> ftan </item>+      <item> ftanh </item>+      <item> full </item>+      <item> gamma_gsl </item>+      <item> gamma_inc </item>+      <item> gamma_inc_P </item>+      <item> gamma_inc_Q </item>+      <item> gammainv_gsl </item>+      <item> gammastar </item>+      <item> gdet </item>+      <item> gdiag </item>+      <item> gexp </item>+      <item> gf </item>+      <item> gfilter </item>+      <item> _gfweight </item>+      <item> ginv </item>+      <item> ginverse </item>+      <item> glog </item>+      <item> glu </item>+      <item> gpick </item>+      <item> gprod </item>+      <item> grab </item>+      <item> grank </item>+      <item> graycomatrix </item>+      <item> __grcla__ </item>+      <item> __grclf__ </item>+      <item> __grcmd__ </item>+      <item> greshape </item>+      <item> __grexit__ </item>+      <item> __grfigure__ </item>+      <item> __grgetstat__ </item>+      <item> __grhold__ </item>+      <item> __grinit__ </item>+      <item> __grishold__ </item>+      <item> __grnewset__ </item>+      <item> __grsetgraph__ </item>+      <item> gsl_sf </item>+      <item> gsqrt </item>+      <item> gsum </item>+      <item> gsumsq </item>+      <item> gtext </item>+      <item> gzoom </item>+      <item> hazard </item>+      <item> houghtf </item>+      <item> hyperg_0F1 </item>+      <item> hzeta </item>+      <item> is_complex_sparse </item>+      <item> isfixed </item>+      <item> isgalois </item>+      <item> isprimitive </item>+      <item> is_real_sparse </item>+      <item> is_sparse </item>+      <item> jpgread </item>+      <item> jpgwrite </item>+      <item> lambert_W0 </item>+      <item> lambert_Wm1 </item>+      <item> legendre_Pl </item>+      <item> legendre_Plm </item>+      <item> legendre_Ql </item>+      <item> legendre_sphPlm </item>+      <item> legendre_sphPlm_array </item>+      <item> leval </item>+      <item> listen </item>+      <item> lnbeta </item>+      <item> lncosh </item>+      <item> lngamma_gsl </item>+      <item> lnpoch </item>+      <item> lnsinh </item>+      <item> log_1plusx </item>+      <item> log_1plusx_mx </item>+      <item> log_erfc </item>+      <item> lp </item>+      <item> make_sparse </item>+      <item> mark_for_deletion </item>+      <item> medfilt1 </item>+      <item> newtonstep </item>+      <item> nnz </item>+      <item> numgradient </item>+      <item> numhessian </item>+      <item> pchip_deriv </item>+      <item> pngread </item>+      <item> pngwrite </item>+      <item> poch </item>+      <item> pochrel </item>+      <item> pretty </item>+      <item> primpoly </item>+      <item> psi </item>+      <item> psi_1_int </item>+      <item> psi_1piy </item>+      <item> psi_n </item>+      <item> rand </item>+      <item> rande </item>+      <item> randn </item>+      <item> randp </item>+      <item> regexp </item>+      <item> remez </item>+      <item> reset_fixed_operations </item>+      <item> rotate_scale </item>+      <item> rsdec </item>+      <item> rsenc </item>+      <item> samin </item>+      <item> SBBacksub </item>+      <item> SBEig </item>+      <item> SBFactor </item>+      <item> SBProd </item>+      <item> SBSolve </item>+      <item> Shi </item>+      <item> Si </item>+      <item> sinc_gsl </item>+      <item> spabs </item>+      <item> sparse </item>+      <item> spfind </item>+      <item> spimag </item>+      <item> spinv </item>+      <item> splu </item>+      <item> spreal </item>+      <item> SymBand </item>+      <item> synchrotron_1 </item>+      <item> synchrotron_2 </item>+      <item> syndtable </item>+      <item> taylorcoeff </item>+      <item> transport_2 </item>+      <item> transport_3 </item>+      <item> transport_4 </item>+      <item> transport_5 </item>+      <item> trisolve </item>+      <item> waitbar </item>+      <item> xmlread </item>+      <item> zeta </item>+      <item> zeta_int </item>+      <item> aar </item>+      <item> aarmam </item>+      <item> ac2poly </item>+      <item> ac2rc </item>+      <item> acorf </item>+      <item> acovf </item>+      <item> addpath </item>+      <item> ademodce </item>+      <item> adim </item>+      <item> adsmax </item>+      <item> amodce </item>+      <item> anderson_darling_cdf </item>+      <item> anderson_darling_test </item>+      <item> anovan </item>+      <item> apkconst </item>+      <item> append_save </item>+      <item> applylut </item>+      <item> ar2poly </item>+      <item> ar2rc </item>+      <item> arburg </item>+      <item> arcext </item>+      <item> arfit2 </item>+      <item> ar_spa </item>+      <item> aryule </item>+      <item> assert </item>+      <item> au </item>+      <item> aucapture </item>+      <item> auload </item>+      <item> auplot </item>+      <item> aurecord </item>+      <item> ausave </item>+      <item> autumn </item>+      <item> average_moments </item>+      <item> awgn </item>+      <item> azimuth </item>+      <item> BandToFull </item>+      <item> BandToSparse </item>+      <item> base64encode </item>+      <item> battery </item>+      <item> bchpoly </item>+      <item> bestblk </item>+      <item> best_dir </item>+      <item> best_dir_cov </item>+      <item> betaln </item>+      <item> bfgs </item>+      <item> bfgsmin_example </item>+      <item> bi2de </item>+      <item> biacovf </item>+      <item> bilinear </item>+      <item> bisdemo </item>+      <item> bispec </item>+      <item> biterr </item>+      <item> blkdiag </item>+      <item> blkproc </item>+      <item> bmpwrite </item>+      <item> bone </item>+      <item> bound_convex </item>+      <item> boxcar </item>+      <item> boxplot </item>+      <item> brighten </item>+      <item> bs_gradient </item>+      <item> butter </item>+      <item> buttord </item>+      <item> bwborder </item>+      <item> bweuler </item>+      <item> bwlabel </item>+      <item> bwmorph </item>+      <item> bwselect </item>+      <item> calendar </item>+      <item> cceps </item>+      <item> cdiff </item>+      <item> cellstr </item>+      <item> char </item>+      <item> cheb </item>+      <item> cheb1ord </item>+      <item> cheb2ord </item>+      <item> chebwin </item>+      <item> cheby1 </item>+      <item> cheby2 </item>+      <item> chirp </item>+      <item> clf </item>+      <item> clip </item>+      <item> cmpermute </item>+      <item> cmunique </item>+      <item> cohere </item>+      <item> col2im </item>+      <item> colfilt </item>+      <item> colorgradient </item>+      <item> comms </item>+      <item> compand </item>+      <item> complex </item>+      <item> concat </item>+      <item> conndef </item>+      <item> content </item>+      <item> contents </item>+      <item> Contents </item>+      <item> contourf </item>+      <item> convhull </item>+      <item> convmtx </item>+      <item> cool </item>+      <item> copper </item>+      <item> corr2 </item>+      <item> cosets </item>+      <item> count </item>+      <item> covm </item>+      <item> cplxpair </item>+      <item> cquadnd </item>+      <item> create_lookup_table </item>+      <item> crule </item>+      <item> crule2d </item>+      <item> crule2dgen </item>+      <item> csape </item>+      <item> csapi </item>+      <item> csd </item>+      <item> csvread </item>+      <item> csvwrite </item>+      <item> ctranspose </item>+      <item> cumtrapz </item>+      <item> czt </item>+      <item> d2_min </item>+      <item> datenum </item>+      <item> datestr </item>+      <item> datevec </item>+      <item> dct </item>+      <item> dct2 </item>+      <item> dctmtx </item>+      <item> de2bi </item>+      <item> deal </item>+      <item> decimate </item>+      <item> decode </item>+      <item> deg2rad </item>+      <item> del2 </item>+      <item> delaunay </item>+      <item> delaunay3 </item>+      <item> delta_method </item>+      <item> demo </item>+      <item> demodmap </item>+      <item> deriv </item>+      <item> detrend </item>+      <item> dfdp </item>+      <item> dftmtx </item>+      <item> dhbar </item>+      <item> dilate </item>+      <item> dispatch </item>+      <item> distance </item>+      <item> dlmread </item>+      <item> dlmwrite </item>+      <item> dos </item>+      <item> double </item>+      <item> drawnow </item>+      <item> durlev </item>+      <item> dxfwrite </item>+      <item> edge </item>+      <item> edit </item>+      <item> ellip </item>+      <item> ellipdemo </item>+      <item> ellipj </item>+      <item> ellipke </item>+      <item> ellipord </item>+      <item> __ellip_ws </item>+      <item> __ellip_ws_min </item>+      <item> encode </item>+      <item> eomday </item>+      <item> erode </item>+      <item> example </item>+      <item> ExampleEigenValues </item>+      <item> ExampleGenEigenValues </item>+      <item> expdemo </item>+      <item> expfit </item>+      <item> eyediagram </item>+      <item> factor </item>+      <item> factorial </item>+      <item> fail </item>+      <item> fcnchk </item>+      <item> feedback </item>+      <item> fem_test </item>+      <item> ff2n </item>+      <item> fftconv2 </item>+      <item> fieldnames </item>+      <item> fill </item>+      <item> fill3 </item>+      <item> filter2 </item>+      <item> filtfilt </item>+      <item> filtic </item>+      <item> findsym </item>+      <item> fir1 </item>+      <item> fir2 </item>+      <item> fixedpoint </item>+      <item> flag </item>+      <item> flag_implicit_samplerate </item>+      <item> flattopwin </item>+      <item> flix </item>+      <item> float </item>+      <item> fmin </item>+      <item> fminbnd </item>+      <item> fmins </item>+      <item> fminunc </item>+      <item> fnder </item>+      <item> fnplt </item>+      <item> fnval </item>+      <item> fplot </item>+      <item> freqs </item>+      <item> freqs_plot </item>+      <item> fsort </item>+      <item> fullfact </item>+      <item> FullToBand </item>+      <item> funm </item>+      <item> fzero </item>+      <item> gammaln </item>+      <item> gapTest </item>+      <item> gaussian </item>+      <item> gausswin </item>+      <item> gconv </item>+      <item> gconvmtx </item>+      <item> gdeconv </item>+      <item> gdftmtx </item>+      <item> gen2par </item>+      <item> geomean </item>+      <item> getfield </item>+      <item> getfields </item>+      <item> gfft </item>+      <item> gftable </item>+      <item> gfweight </item>+      <item> gget </item>+      <item> gifft </item>+      <item> ginput </item>+      <item> gmm_estimate </item>+      <item> gmm_example </item>+      <item> gmm_obj </item>+      <item> gmm_results </item>+      <item> gmm_variance </item>+      <item> gmm_variance_inefficient </item>+      <item> gquad </item>+      <item> gquad2d </item>+      <item> gquad2d6 </item>+      <item> gquad2dgen </item>+      <item> gquad6 </item>+      <item> gquadnd </item>+      <item> grace_octave_path </item>+      <item> gradient </item>+      <item> grayslice </item>+      <item> grep </item>+      <item> grid </item>+      <item> griddata </item>+      <item> groots </item>+      <item> grpdelay </item>+      <item> grule </item>+      <item> grule2d </item>+      <item> grule2dgen </item>+      <item> hadamard </item>+      <item> hammgen </item>+      <item> hankel </item>+      <item> hann </item>+      <item> harmmean </item>+      <item> hilbert </item>+      <item> histeq </item>+      <item> histfit </item>+      <item> histo </item>+      <item> histo2 </item>+      <item> histo3 </item>+      <item> histo4 </item>+      <item> hot </item>+      <item> hsv </item>+      <item> hup </item>+      <item> idct </item>+      <item> idct2 </item>+      <item> idplot </item>+      <item> idsim </item>+      <item> ifftshift </item>+      <item> im2bw </item>+      <item> im2col </item>+      <item> imadjust </item>+      <item> imginfo </item>+      <item> imhist </item>+      <item> imnoise </item>+      <item> impad </item>+      <item> impz </item>+      <item> imread </item>+      <item> imrotate </item>+      <item> imshear </item>+      <item> imtranslate </item>+      <item> imwrite </item>+      <item> innerfun </item>+      <item> inputname </item>+      <item> interp </item>+      <item> interp1 </item>+      <item> interp2 </item>+      <item> interpft </item>+      <item> intersect </item>+      <item> invest0 </item>+      <item> invest1 </item>+      <item> invfdemo </item>+      <item> invfreq </item>+      <item> invfreqs </item>+      <item> invfreqz </item>+      <item> inz </item>+      <item> irsa_act </item>+      <item> irsa_actcore </item>+      <item> irsa_check </item>+      <item> irsa_dft </item>+      <item> irsa_dftfp </item>+      <item> irsa_genreal </item>+      <item> irsa_idft </item>+      <item> irsa_isregular </item>+      <item> irsa_jitsp </item>+      <item> irsa_mdsp </item>+      <item> irsa_normalize </item>+      <item> irsa_plotdft </item>+      <item> irsa_resample </item>+      <item> irsa_rgenreal </item>+      <item> isa </item>+      <item> isbw </item>+      <item> isdir </item>+      <item> isequal </item>+      <item> isfield </item>+      <item> isgray </item>+      <item> isind </item>+      <item> ismember </item>+      <item> isprime </item>+      <item> isrgb </item>+      <item> issparse </item>+      <item> isunix </item>+      <item> jet </item>+      <item> kaiser </item>+      <item> kaiserord </item>+      <item> lambertw </item>+      <item> lattice </item>+      <item> lauchli </item>+      <item> leasqr </item>+      <item> leasqrdemo </item>+      <item> legend </item>+      <item> legendre </item>+      <item> levinson </item>+      <item> lin2mu </item>+      <item> line_min </item>+      <item> lloyds </item>+      <item> lookup </item>+      <item> lookup_table </item>+      <item> lpc </item>+      <item> lp_test </item>+      <item> mad </item>+      <item> magic </item>+      <item> makelut </item>+      <item> MakeShears </item>+      <item> map </item>+      <item> mat2gray </item>+      <item> mat2str </item>+      <item> mdsmax </item>+      <item> mean2 </item>+      <item> medfilt2 </item>+      <item> meshc </item>+      <item> minimize </item>+      <item> minpol </item>+      <item> mkpp </item>+      <item> mktheta </item>+      <item> mle_estimate </item>+      <item> mle_example </item>+      <item> mle_obj </item>+      <item> mle_results </item>+      <item> mle_variance </item>+      <item> modmap </item>+      <item> mu2lin </item>+      <item> mvaar </item>+      <item> mvar </item>+      <item> mvfilter </item>+      <item> mvfreqz </item>+      <item> myfeval </item>+      <item> nanmax </item>+      <item> nanmean </item>+      <item> nanmedian </item>+      <item> nanmin </item>+      <item> nanstd </item>+      <item> nansum </item>+      <item> ncauer </item>+      <item> nchoosek </item>+      <item> ncrule </item>+      <item> ndims </item>+      <item> nelder_mead_min </item>+      <item> newmark </item>+      <item> nlfilter </item>+      <item> nlnewmark </item>+      <item> __nlnewmark_fcn__ </item>+      <item> nmsmax </item>+      <item> nonzeros </item>+      <item> normplot </item>+      <item> now </item>+      <item> nrm </item>+      <item> nthroot </item>+      <item> nze </item>+      <item> OCTAVE_FORGE_VERSION </item>+      <item> ode23 </item>+      <item> ode45 </item>+      <item> ode78 </item>+      <item> optimset </item>+      <item> ordfilt2 </item>+      <item> orient </item>+      <item> pacf </item>+      <item> padarray </item>+      <item> parameterize </item>+      <item> parcor </item>+      <item> pareto </item>+      <item> pascal </item>+      <item> patch </item>+      <item> pburg </item>+      <item> pcg </item>+      <item> pchip </item>+      <item> pcolor </item>+      <item> pcr </item>+      <item> peaks </item>+      <item> penddot </item>+      <item> pendulum </item>+      <item> perms </item>+      <item> pie </item>+      <item> pink </item>+      <item> plot3 </item>+      <item> __plt3__ </item>+      <item> poly2ac </item>+      <item> poly2ar </item>+      <item> poly_2_ex </item>+      <item> poly2mask </item>+      <item> poly2rc </item>+      <item> poly2sym </item>+      <item> poly2th </item>+      <item> polyarea </item>+      <item> polyconf </item>+      <item> polyder </item>+      <item> polyderiv </item>+      <item> polygcd </item>+      <item> polystab </item>+      <item> __power </item>+      <item> ppval </item>+      <item> prctile </item>+      <item> prettyprint </item>+      <item> prettyprint_c </item>+      <item> primes </item>+      <item> princomp </item>+      <item> print </item>+      <item> prism </item>+      <item> proplan </item>+      <item> pulstran </item>+      <item> pwelch </item>+      <item> pyulear </item>+      <item> qaskdeco </item>+      <item> qaskenco </item>+      <item> qtdecomp </item>+      <item> qtgetblk </item>+      <item> qtsetblk </item>+      <item> quad2dc </item>+      <item> quad2dcgen </item>+      <item> quad2dg </item>+      <item> quad2dggen </item>+      <item> quadc </item>+      <item> quadg </item>+      <item> quadl </item>+      <item> quadndg </item>+      <item> quantiz </item>+      <item> quiver </item>+      <item> rad2deg </item>+      <item> rainbow </item>+      <item> randerr </item>+      <item> randint </item>+      <item> randsrc </item>+      <item> rat </item>+      <item> rats </item>+      <item> rc2ac </item>+      <item> rc2ar </item>+      <item> rc2poly </item>+      <item> rceps </item>+      <item> read_options </item>+      <item> read_pdb </item>+      <item> rectpuls </item>+      <item> resample </item>+      <item> rgb2gray </item>+      <item> rk2fixed </item>+      <item> rk4fixed </item>+      <item> rk8fixed </item>+      <item> rmfield </item>+      <item> rmle </item>+      <item> rmpath </item>+      <item> roicolor </item>+      <item> rosser </item>+      <item> rotparams </item>+      <item> rotv </item>+      <item> rref </item>+      <item> rsdecof </item>+      <item> rsencof </item>+      <item> rsgenpoly </item>+      <item> samin_example </item>+      <item> save_vrml </item>+      <item> sbispec </item>+      <item> scale_data </item>+      <item> scatter </item>+      <item> scatterplot </item>+      <item> select_3D_points </item>+      <item> selmo </item>+      <item> setdiff </item>+      <item> setfield </item>+      <item> setfields </item>+      <item> setxor </item>+      <item> sftrans </item>+      <item> sgolay </item>+      <item> sgolayfilt </item>+      <item> sinvest1 </item>+      <item> slurp_file </item>+      <item> sortrows </item>+      <item> sound </item>+      <item> soundsc </item>+      <item> spdiags </item>+      <item> specgram </item>+      <item> speed </item>+      <item> speye </item>+      <item> spfun </item>+      <item> sphcat </item>+      <item> spline </item>+      <item> splot </item>+      <item> spones </item>+      <item> sprand </item>+      <item> sprandn </item>+      <item> spring </item>+      <item> spstats </item>+      <item> spsum </item>+      <item> sp_test </item>+      <item> sptest </item>+      <item> spvcat </item>+      <item> spy </item>+      <item> std2 </item>+      <item> stem </item>+      <item> str2double </item>+      <item> strcmpi </item>+      <item> stretchlim </item>+      <item> strfind </item>+      <item> strmatch </item>+      <item> strncmp </item>+      <item> strncmpi </item>+      <item> strsort </item>+      <item> strtok </item>+      <item> strtoz </item>+      <item> struct </item>+      <item> strvcat </item>+      <item> summer </item>+      <item> sumskipnan </item>+      <item> surf </item>+      <item> surfc </item>+      <item> sym2poly </item>+      <item> symerr </item>+      <item> symfsolve </item>+      <item> tabulate </item>+      <item> tar </item>+      <item> temp_name </item>+      <item> test </item>+      <item> test_d2_min_1 </item>+      <item> test_d2_min_2 </item>+      <item> test_d2_min_3 </item>+      <item> test_ellipj </item>+      <item> test_fminunc_1 </item>+      <item> testimio </item>+      <item> test_inline_1 </item>+      <item> test_min_1 </item>+      <item> test_min_2 </item>+      <item> test_min_3 </item>+      <item> test_min_4 </item>+      <item> test_minimize_1 </item>+      <item> test_nelder_mead_min_1 </item>+      <item> test_nelder_mead_min_2 </item>+      <item> test_sncndn </item>+      <item> test_struct </item>+      <item> test_vmesh </item>+      <item> test_vrml_faces </item>+      <item> test_wpolyfit </item>+      <item> text </item>+      <item> textread </item>+      <item> tf2zp </item>+      <item> tfe </item>+      <item> thfm </item>+      <item> tics </item>+      <item> toeplitz </item>+      <item> toggle_grace_use </item>+      <item> transpose </item>+      <item> trapz </item>+      <item> triang </item>+      <item> tril </item>+      <item> trimmean </item>+      <item> tripuls </item>+      <item> trisolve </item>+      <item> triu </item>+      <item> tsademo </item>+      <item> tsearchdemo </item>+      <item> ucp </item>+      <item> uintlut </item>+      <item> unique </item>+      <item> unix </item>+      <item> unmkpp </item>+      <item> unscale_parameters </item>+      <item> vec2mat </item>+      <item> view </item>+      <item> vmesh </item>+      <item> voronoi </item>+      <item> voronoin </item>+      <item> vrml_arrow </item>+      <item> vrml_Background </item>+      <item> vrml_browse </item>+      <item> vrml_cyl </item>+      <item> vrml_demo_tutorial_1 </item>+      <item> vrml_demo_tutorial_2 </item>+      <item> vrml_demo_tutorial_3 </item>+      <item> vrml_demo_tutorial_4 </item>+      <item> vrml_ellipsoid </item>+      <item> vrml_faces </item>+      <item> vrml_flatten </item>+      <item> vrml_frame </item>+      <item> vrml_group </item>+      <item> vrml_kill </item>+      <item> vrml_lines </item>+      <item> vrml_material </item>+      <item> vrml_parallelogram </item>+      <item> vrml_PointLight </item>+      <item> vrml_points </item>+      <item> vrml_select_points </item>+      <item> vrml_surf </item>+      <item> vrml_text </item>+      <item> vrml_thick_surf </item>+      <item> vrml_transfo </item>+      <item> wavread </item>+      <item> wavwrite </item>+      <item> weekday </item>+      <item> wgn </item>+      <item> white </item>+      <item> wilkinson </item>+      <item> winter </item>+      <item> wpolyfit </item>+      <item> wpolyfitdemo </item>+      <item> write_pdb </item>+      <item> wsolve </item>+      <item> xcorr </item>+      <item> xcorr2 </item>+      <item> xcov </item>+      <item> xlsread </item>+      <item> xmlwrite </item>+      <item> y2res </item>+      <item> zero_count </item>+      <item> zoom </item>+      <item> zp2tf </item>+      <item> zplane </item>+      <item> zscore </item>+    </list>+    +    <contexts>++      <context name="_normal" attribute="Normal Text" lineEndContext="#stay">++        <!-- Code folding -->+        <!--TODO: with this implementation, code folding will close a block also with a wrong+        end*: for istance, for can be closed by endif. This is done because the catchall end +        keyword is widely used to close a number of blocks (including if and for).+        If you have an improvement, please contribute it!-->+        <RegExpr context="#stay" attribute="Keyword" String="\b(for)\b" beginRegion="block" />+        <RegExpr context="#stay" attribute="Keyword" String="\b(endfor)\b" endRegion="block" />+        <RegExpr context="#stay" attribute="Keyword" String="\b(if)\b" beginRegion="block" />+        <RegExpr context="#stay" attribute="Keyword" String="\b(endif)\b" endRegion="block" />+        <RegExpr context="#stay" attribute="Keyword" String="\b(do)\b" beginRegion="block" />+        <RegExpr context="#stay" attribute="Keyword" String="\b(until)\b" endRegion="block" />+        <RegExpr context="#stay" attribute="Keyword" String="\b(while)\b" beginRegion="block" />+        <RegExpr context="#stay" attribute="Keyword" String="\b(endwhile)\b" endRegion="block" />+        <RegExpr context="#stay" attribute="Keyword" String="\b(function)\b" beginRegion="block" />+        <RegExpr context="#stay" attribute="Keyword" String="\b(endfunction)\b" endRegion="block" />+        <RegExpr context="#stay" attribute="Keyword" String="\b(switch)\b" beginRegion="Switch" />+        <RegExpr context="#stay" attribute="Keyword" String="\b(endswitch)\b" endRegion="Switch" />+        <RegExpr context="#stay" attribute="Keyword" String="\b(try)\b" beginRegion="Try" />+        <RegExpr context="#stay" attribute="Keyword" String="\b(end_try_catch)\b" endRegion="Try" />+        <!-- Catchall end keyword -->+        <RegExpr context="#stay" attribute="Keyword" String="\b(end)\b" endRegion="block" />+        +        <!-- Look-ahead for adjoint ' after variable, number literal, closing braces and .' -->+        <RegExpr context="_adjoint" attribute="Variable" String="[a-zA-Z]\w*(?=')" />+        <RegExpr context="_adjoint" attribute="Number" String="(\d+(\.\d+)?|\.\d+)([eE][+-]?\d+)?[ij]?(?=')" />+        <RegExpr context="_adjoint" attribute="Delimiter" String="[\)\]}](?=')" />+        <RegExpr context="_adjoint" attribute="Operator" String="\.'(?=')" />++        <!-- If ' is not the adjoint operator, it starts a string or an unterminated string;+        strings can be also with ", and accept the respective delimiter in them either+        by doubling it ('', "") or by escaping it (\', \") -->+        <RegExpr context="#stay" attribute="String" String="'([^'\\]|''|\\'|\\[^'])*'(?=[^']|$)" />+        <RegExpr context="#stay" attribute="Incomplete String" String="'([^']|''|\\')*" />+        <RegExpr context="#stay" attribute="String" String="&quot;([^&quot;\\]|&quot;&quot;|\\&quot;|\\[^&quot;])*&quot;(?=[^&quot;]|$)" />+        <RegExpr context="#stay" attribute="Incomplete String" String="&quot;([^&quot;]|&quot;&quot;|\\&quot;)*" />+        +        <!-- Handling of keywords, comments, functions, identifiers, numbers and braces -->+        <keyword context="#stay" attribute="Keyword" String="keywords" />+        <keyword context="#stay" attribute="Commands" String="commands" />+        <keyword context="#stay" attribute="Functions" String="functions" />+        <keyword context="#stay" attribute="Builtin" String="builtin"/>+        <keyword context="#stay" attribute="Forge" String="forge" />+        <RegExpr context="#stay" attribute="Comment" String="[%#].*$" />+        <RegExpr context="#stay" attribute="Variable" String="[a-zA-Z]\w*" />+        <RegExpr context="#stay" attribute="Number" String="(\d+(\.\d+)?|\.\d+)([eE][+-]?\d+)?[ij]?" />+        <AnyChar context="#stay" attribute="Delimiter" String="()[]{}"/>+              +        <!-- Three- and two-character operators -->+        <StringDetect context="#stay" attribute="Operator" String="..."/>+        <StringDetect context="#stay" attribute="Operator" String="=="/>+        <StringDetect context="#stay" attribute="Operator" String="~="/>+        <StringDetect context="#stay" attribute="Operator" String="!="/>+        <StringDetect context="#stay" attribute="Operator" String="&lt;="/>+        <StringDetect context="#stay" attribute="Operator" String="&gt;="/>+        <StringDetect context="#stay" attribute="Operator" String="&lt;&gt;"/>+        <StringDetect context="#stay" attribute="Operator" String="&amp;&amp;"/>+        <StringDetect context="#stay" attribute="Operator" String="||"/>+        <StringDetect context="#stay" attribute="Operator" String="++"/>+        <StringDetect context="#stay" attribute="Operator" String="--"/>+        <StringDetect context="#stay" attribute="Operator" String="**"/>+        <StringDetect context="#stay" attribute="Operator" String=".*"/>+        <StringDetect context="#stay" attribute="Operator" String=".**"/>+        <StringDetect context="#stay" attribute="Operator" String=".^"/>+        <StringDetect context="#stay" attribute="Operator" String="./"/>+        <StringDetect context="#stay" attribute="Operator" String=".'"/>++        <!-- Single-character operators -->+        <AnyChar context="#stay" attribute="Operator" String="!&quot;%(*+,/;=>[]|~#&amp;)-:&lt;&gt;\^"/>+        +      </context>+++      <!--Context entered after encountering an ' adjoint operator -->+      <context name="_adjoint" attribute="Operator" lineEndContext="#pop">+        <RegExpr context="#pop" attribute="Operator" String="'+" />+      </context>+++    </contexts>++    <itemDatas>+      <itemData name="Normal Text" defStyleNum="dsNormal" />+      <itemData name="Variable" defStyleNum="dsNormal" />+      <itemData name="Operator" defStyleNum="dsNormal"/>+      <itemData name="Number" defStyleNum="dsFloat" />+      <itemData name="Delimiter" defStyleNum="dsNormal" />+      <itemData name="String" defStyleNum="dsString" color="#b20000"/>+      <itemData name="String Char"  defStyleNum="dsChar"/>+      <itemData name="Incomplete String" defStyleNum="dsChar" color="#a020f0"/>+      <itemData name="Keyword"  defStyleNum="dsNormal" color="#0000ff"/>+      <itemData name="Comment" defStyleNum="dsComment" color="#009900"/>+      <itemData name="Functions" defStyleNum="dsFunction" color="#0000ff" selColor="#00ff00" bold="1" italic="1" />+      <itemData name="Forge" defStyleNum="dsFunction" color="#000099" selColor="#009900" bold="1" italic="1" />+      <itemData name="Builtin" defStyleNum="dsBaseN" color="#b28c00" />+      <itemData name="Commands" defStyleNum="dsFunction" color="#b28c00" />+    </itemDatas>++  </highlighting>++  <general>+    <comments>+      <comment name="singleLine" start="%" />+      <comment name="singleLine" start="#" />+    </comments>+    <keywords casesensitive="1"/>+  </general>++</language>+<!-- kate: space-indent on; indent-width 2; replace-tabs on; -->