highlighting-kate 0.2.7.1 → 0.2.8.1

raw patch · 198 files changed

+47981/−11222 lines, 198 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• ParseSyntaxFiles.hs +14/−11
• README +34/−20
• Text/Highlighting/Kate/Common.hs +10/−3
• Text/Highlighting/Kate/Syntax.hs +96/−2
• Text/Highlighting/Kate/Syntax/Actionscript.hs +192/−0
• Text/Highlighting/Kate/Syntax/Ada.hs +7/−9
• Text/Highlighting/Kate/Syntax/Alert.hs +5/−7
• Text/Highlighting/Kate/Syntax/Alert_indent.hs +80/−0
• Text/Highlighting/Kate/Syntax/Ansys.hs +197/−0
• Text/Highlighting/Kate/Syntax/Apache.hs +157/−0
• Text/Highlighting/Kate/Syntax/Asn1.hs +89/−0
• Text/Highlighting/Kate/Syntax/Asp.hs +29/−31
• Text/Highlighting/Kate/Syntax/Awk.hs +6/−8
• Text/Highlighting/Kate/Syntax/Bash.hs +96/−95
• Text/Highlighting/Kate/Syntax/Bibtex.hs +80/−30
• Text/Highlighting/Kate/Syntax/Boo.hs +299/−0
• Text/Highlighting/Kate/Syntax/C.hs +25/−27
• Text/Highlighting/Kate/Syntax/Changelog.hs +96/−0
• Text/Highlighting/Kate/Syntax/Cisco.hs +167/−0
• Text/Highlighting/Kate/Syntax/Cmake.hs +59/−21
• Text/Highlighting/Kate/Syntax/Coldfusion.hs +39/−41
• Text/Highlighting/Kate/Syntax/Commonlisp.hs +18/−18
• Text/Highlighting/Kate/Syntax/Cpp.hs +27/−29
• Text/Highlighting/Kate/Syntax/Cs.hs +175/−0
• Text/Highlighting/Kate/Syntax/Css.hs +38/−40
• Text/Highlighting/Kate/Syntax/Cue.hs +106/−0
• Text/Highlighting/Kate/Syntax/D.hs +440/−143
• Text/Highlighting/Kate/Syntax/Desktop.hs +94/−0
• Text/Highlighting/Kate/Syntax/Diff.hs +220/−0
• Text/Highlighting/Kate/Syntax/Djangotemplate.hs +69/−71
• Text/Highlighting/Kate/Syntax/Doxygen.hs +139/−68
• Text/Highlighting/Kate/Syntax/Doxygenlua.hs +367/−0
• Text/Highlighting/Kate/Syntax/Dtd.hs +14/−16
• Text/Highlighting/Kate/Syntax/Eiffel.hs +6/−8
• Text/Highlighting/Kate/Syntax/Email.hs +248/−0
• Text/Highlighting/Kate/Syntax/Erlang.hs +17/−19
• Text/Highlighting/Kate/Syntax/Fortran.hs +67/−43
• Text/Highlighting/Kate/Syntax/Fstab.hs +143/−0
• Text/Highlighting/Kate/Syntax/Gap.hs +176/−0
• Text/Highlighting/Kate/Syntax/Gdb.hs +122/−0
• Text/Highlighting/Kate/Syntax/Gettext.hs +277/−0
• Text/Highlighting/Kate/Syntax/Gnuassembler.hs +154/−0
• Text/Highlighting/Kate/Syntax/Go.hs +139/−0
• Text/Highlighting/Kate/Syntax/Haskell.hs +17/−17
• Text/Highlighting/Kate/Syntax/Haxe.hs +160/−0
• Text/Highlighting/Kate/Syntax/Html.hs +51/−53
• Text/Highlighting/Kate/Syntax/Idl.hs +159/−0
• Text/Highlighting/Kate/Syntax/Ilerpg.hs +563/−0
• Text/Highlighting/Kate/Syntax/Ini.hs +111/−0
• Text/Highlighting/Kate/Syntax/Java.hs +22/−24
• Text/Highlighting/Kate/Syntax/Javadoc.hs +23/−23
• Text/Highlighting/Kate/Syntax/Javascript.hs +54/−35
• Text/Highlighting/Kate/Syntax/Json.hs +23/−19
• Text/Highlighting/Kate/Syntax/Jsp.hs +453/−0
• Text/Highlighting/Kate/Syntax/Latex.hs +307/−111
• Text/Highlighting/Kate/Syntax/Lex.hs +32/−34
• Text/Highlighting/Kate/Syntax/LiterateHaskell.hs +13/−15
• Text/Highlighting/Kate/Syntax/Lua.hs +18/−20
• Text/Highlighting/Kate/Syntax/M3u.hs +92/−0
• Text/Highlighting/Kate/Syntax/Makefile.hs +30/−22
• Text/Highlighting/Kate/Syntax/Mandoc.hs +105/−0
• Text/Highlighting/Kate/Syntax/Matlab.hs +7/−9
• Text/Highlighting/Kate/Syntax/Maxima.hs +122/−0
• Text/Highlighting/Kate/Syntax/Mediawiki.hs +23/−25
• Text/Highlighting/Kate/Syntax/Metafont.hs +290/−0
• Text/Highlighting/Kate/Syntax/Mips.hs +128/−0
• Text/Highlighting/Kate/Syntax/Modula2.hs +122/−0
• Text/Highlighting/Kate/Syntax/Modula3.hs +9/−11
• Text/Highlighting/Kate/Syntax/Monobasic.hs +223/−0
• Text/Highlighting/Kate/Syntax/Nasm.hs +7/−9
• Text/Highlighting/Kate/Syntax/Noweb.hs +123/−0
• Text/Highlighting/Kate/Syntax/Objectivec.hs +11/−13
• Text/Highlighting/Kate/Syntax/Objectivecpp.hs +289/−0
• Text/Highlighting/Kate/Syntax/Ocaml.hs +111/−17
• Text/Highlighting/Kate/Syntax/Octave.hs +5/−7
• Text/Highlighting/Kate/Syntax/Pango.hs +231/−0
• Text/Highlighting/Kate/Syntax/Pascal.hs +43/−22
• Text/Highlighting/Kate/Syntax/Perl.hs +132/−138
• Text/Highlighting/Kate/Syntax/Php.hs +150/−45
• Text/Highlighting/Kate/Syntax/Pike.hs +180/−0
• Text/Highlighting/Kate/Syntax/Postscript.hs +7/−9
• Text/Highlighting/Kate/Syntax/Prolog.hs +10/−12
• Text/Highlighting/Kate/Syntax/Python.hs +114/−114
• Text/Highlighting/Kate/Syntax/R.hs +206/−0
• Text/Highlighting/Kate/Syntax/Relaxngcompact.hs +10/−12
• Text/Highlighting/Kate/Syntax/Rhtml.hs +188/−190
• Text/Highlighting/Kate/Syntax/Ruby.hs +242/−187
• Text/Highlighting/Kate/Syntax/Scala.hs +15/−17
• Text/Highlighting/Kate/Syntax/Scheme.hs +24/−26
• Text/Highlighting/Kate/Syntax/Sci.hs +104/−0
• Text/Highlighting/Kate/Syntax/Sed.hs +444/−0
• Text/Highlighting/Kate/Syntax/Sgml.hs +13/−15
• Text/Highlighting/Kate/Syntax/Sql.hs +22/−39
• Text/Highlighting/Kate/Syntax/SqlMysql.hs +26/−43
• Text/Highlighting/Kate/Syntax/SqlPostgresql.hs +40/−19
• Text/Highlighting/Kate/Syntax/Tcl.hs +8/−10
• Text/Highlighting/Kate/Syntax/Texinfo.hs +10/−12
• Text/Highlighting/Kate/Syntax/Verilog.hs +207/−0
• Text/Highlighting/Kate/Syntax/Vhdl.hs +389/−0
• Text/Highlighting/Kate/Syntax/Winehq.hs +104/−0
• Text/Highlighting/Kate/Syntax/Wml.hs +219/−0
• Text/Highlighting/Kate/Syntax/Xharbour.hs +172/−0
• Text/Highlighting/Kate/Syntax/Xml.hs +51/−53
• Text/Highlighting/Kate/Syntax/Xorg.hs +131/−0
• Text/Highlighting/Kate/Syntax/Xslt.hs +114/−38
• Text/Highlighting/Kate/Syntax/Xul.hs +406/−0
• Text/Highlighting/Kate/Syntax/Yacc.hs +37/−39
• Text/Highlighting/Kate/Syntax/Yaml.hs +326/−0
• changelog +6/−0
• highlighting-kate.cabal +102/−10
• xml/actionscript.xml +334/−0
• xml/alert.xml +9/−3
• xml/alert_indent.xml +62/−0
• xml/ansys.xml +2064/−0
• xml/apache.xml +634/−0
• xml/asn1.xml +69/−0
• xml/bash.xml +18/−2
• xml/bash.xml.bkp +18/−2
• xml/bibtex.xml +86/−43
• xml/boo.xml +314/−0
• xml/c.xml +31/−17
• xml/changelog.xml +29/−0
• xml/cisco.xml +312/−0
• xml/cmake.xml +442/−127
• xml/commonlisp.xml +30/−3
• xml/cpp.xml +68/−50
• xml/cs.xml +166/−0
• xml/css.xml +71/−22
• xml/cue.xml +74/−0
• xml/d.xml +553/−219
• xml/desktop.xml +28/−0
• xml/diff.xml +119/−0
• xml/doxygen.xml +229/−42
• xml/doxygenlua.xml +481/−0
• xml/dtd.xml +12/−11
• xml/email.xml +106/−0
• xml/fortran.xml +22/−11
• xml/fstab.xml +96/−0
• xml/gap.xml +7835/−0
• xml/gdb.xml +59/−0
• xml/gettext.xml +193/−0
• xml/gnuassembler.xml +300/−0
• xml/go.xml +150/−0
• xml/haskell.xml +4/−3
• xml/haskell.xml.bkp +0/−387
• xml/haxe.xml +181/−0
• xml/html.xml +29/−28
• xml/idl.xml +116/−0
• xml/ilerpg.xml +725/−0
• xml/ini.xml +80/−0
• xml/javadoc.xml +4/−3
• xml/javascript.xml +42/−290
• xml/javascript.xml.bkp +42/−290
• xml/json.xml +8/−4
• xml/jsp.xml +3070/−0
• xml/language.dtd +534/−124
• xml/latex.xml +281/−41
• xml/literate-haskell.xml +4/−4
• xml/literate-haskell.xml.bkp +0/−386
• xml/lua.xml +19/−9
• xml/m3u.xml +51/−0
• xml/makefile.xml +52/−7
• xml/mandoc.xml +89/−0
• xml/matlab.xml +9/−1
• xml/maxima.xml +1889/−0
• xml/metafont.xml +1009/−0
• xml/mips.xml +359/−0
• xml/modula-2.xml +188/−0
• xml/monobasic.xml +215/−0
• xml/noweb.xml +52/−0
• xml/objectivecpp.xml +318/−0
• xml/ocaml.xml +102/−11
• xml/pango.xml +159/−0
• xml/pascal.xml +21/−4
• xml/perl.xml +19/−11
• xml/perl.xml.bkp +19/−11
• xml/php.xml +5584/−6566
• xml/pike.xml +121/−0
• xml/python.xml +270/−81
• xml/r.xml +148/−0
• xml/rhtml.xml +1/−2
• xml/ruby.xml +104/−62
• xml/sci.xml +1191/−0
• xml/sed.xml +267/−0
• xml/sql-mysql.xml +20/−22
• xml/sql-postgresql.xml +16/−2
• xml/sql.xml +11/−9
• xml/verilog.xml +240/−0
• xml/vhdl.xml +515/−0
• xml/winehq.xml +36/−0
• xml/wml.xml +196/−0
• xml/xharbour.xml +543/−0
• xml/xml.xml +27/−24
• xml/xorg.xml +65/−0
• xml/xslt.xml +62/−2
• xml/xul.xml +627/−0
• xml/yacc.xml +17/−12
• xml/yaml.xml +197/−0

@@ -20,8 +20,7 @@  module Main where -import Text.XML.HXT.Arrow-import Text.XML.HXT.Arrow.Edit+import Text.XML.HXT.Core import Control.Arrow import Control.Arrow.ArrowList import Control.Monad (liftM)@@ -126,7 +125,7 @@   [syntax] <- runX $ application src   let name = nameFromPath src   let outFile = joinPath [libraryPath, "Syntax", addExtension name "hs"]-  let includeLangs = nub $ map (drop 2 . parserContext) $+  let includeLangs = nub $ filter (/= name) $ map (drop 2 . parserContext) $         filter (\p -> (parserType p) == "IncludeRules" && "##" `isPrefixOf` (parserContext p)) $          concatMap contParsers $ synContexts syntax   let includeImports = map (("import qualified " ++) . langNameToModule) includeLangs@@ -225,15 +224,16 @@                             \    Left err     -> Left $ show err\n\                             \    Right result -> Right result"       endLineParser = text "pEndLine = do" $$-                      (nest 2 $ text "newline <|> (eof >> return '\\n')" $$+                      (nest 2 $ text "lookAhead $ newline <|> (eof >> return '\\n')" $$                                 text "context <- currentContext" $$                                 text "case context of" $$                                 (nest 2 $ (vcat $ map (\cont -> text (show $ contName cont) <> text " -> " <> -                                            switchContext (contLineEndContext cont)) $ synContexts syntax) $$-                                          (text $ "_ -> return ()")) $$+                                            switchContext (contLineEndContext cont) <>+                                            if "#pop" `isPrefixOf` (contLineEndContext cont)+                                               then text " >> pEndLine"+                                               else text " >> pHandleEndLine") $ synContexts syntax) $$+                                          (text $ "_ -> pHandleEndLine")))                                 {- text "pushContext (fromMaybe \"#stay\" $ lookup context lineBeginContexts)" $$ -}-                                text "lineContents <- lookAhead wholeLine" $$-                                text "updateState $ \\st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\\n' }")       -- we use 'words "blah blah2 blah3"' to keep ghc from inlining the list, which makes compiling take a long time       listDef (n, list) = text $ listName n ++ " = Set.fromList $ words $ " ++                                show (if keywordCaseSensitive (synKeywordAttr syntax)@@ -328,20 +328,23 @@  switchContext next =   case next of-     x | "#pop" `isPrefixOf` x -> char '(' <> text (concat $ intersperse " >> " $ replicate (length (filter (=='#') x)) "popContext") <> -                                  text " >> return ())"+     x | "#pop" `isPrefixOf` x -> char '(' <>+          text (concat $ intersperse " >> " $ replicate (length (filter (=='#') x)) "popContext") <> char ')'      "#stay" -> text "return ()"      x -> text ("pushContext " ++ show x)   langNameToModule str =  "Text.Highlighting.Kate.Syntax." ++   case str of     "Alerts" -> "Alert"+    "Alerts_indent" -> "Alert_indent"     "C++" -> "Cpp"     "CSS" -> "Css"     "Doxygen" -> "Doxygen"     "HTML" -> "Html"     "Javadoc" -> "Javadoc"     "JavaScript" -> "Javascript"+    "SQL (MySQL)" -> "SqlMysql"+    "DoxygenLua" -> "Doxygenlua"     x -> x  listName :: String -> String@@ -367,7 +370,7 @@  application :: String -> IOSArrow b SyntaxDefinition application src-    = readDocument [(a_validate, v_0)] src+    = readDocument [withValidate no, withInputEncoding utf8] src       >>>       multi (hasName "language")       >>>

@@ -1,28 +1,41 @@ highlighting-kate is a Haskell source code highlighting library, based on Kate's syntax description files (http://kate-editor.org/). -Currently, the following languages are supported:+Currently, the following languages/formats are supported: -Ada, 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, RelaxNG compact, Rhtml, Ruby,-Scala, Scheme, Sgml, Sql, SqlMysql, SqlPostgresql, Tcl, Texinfo, Xml,-Xslt, Yacc+Actionscript, Ada, Alert, Alert_indent, Ansys, Apache, Asn1, Asp, Awk,+Bash, Bibtex, Boo, C, Changelog, Cisco, Cmake, Coldfusion, Commonlisp,+Cpp, Cs, Css, Cue, D, Desktop, Diff, Djangotemplate, Doxygen, Doxygenlua,+Dtd, Eiffel, Email, Erlang, Fortran, Fstab, Gap, Gdb, Gettext, Gnuassembler,+Go, Haskell, Haxe, Html, Idl, Ilerpg, Ini, Java, Javadoc, Javascript,+Json, Jsp, Latex, Lex, LiterateHaskell, Lua, M3u, Makefile, Mandoc,+Matlab, Maxima, Mediawiki, Metafont, Mips, Modula2, Modula3, Monobasic,+Nasm, Noweb, Objectivec, Objectivecpp, Ocaml, Octave, Pango, Pascal, Perl,+Php, Pike, Postscript, Prolog, Python, R, Relaxngcompact, Rhtml, Ruby,+Scala, Scheme, Sci, Sed, Sgml, Sql, SqlMysql, SqlPostgresql, Tcl, Texinfo,+Verilog, Vhdl, Winehq, Wml, Xharbour, Xml, Xorg, Xslt, Xul, Yacc, Yaml -To install:+To install, use the cabal tool: -    runghc Setup.lhs configure-    runghc Setup.lhs build -    runghc Setup.lhs haddock    # optional, if you want library documentation-    runghc Setup.lhs install    # as root, or specify --user +    cabal install +Note:  If you have checked out the source from the darcs repository,+you will first need to do:++    make prep++which generates some of the needed source files from xml syntax+definitions.++To generate the documentation:++    cabal haddock+ For an example of the use of the library, see Highlight.hs. To compile this program along with the library, specify the 'executable' flag in the configure step above: -    runghc Setup.lhs configure -fexecutable+    cabal install -fexecutable  To run Highlight, specify the language name using -s: @@ -47,9 +60,13 @@ the xml files in this directory, or add new ones, and then regenerate the parsers by doing: +    make prep++or+     runghc ParseSyntaxFiles.hs xml -Note that ParseSyntaxFiles.hs requires the HXT package. If you+Note that ParseSyntaxFiles.hs requires the HXT package (>= 9.0.0). If you added or removed a syntax definition, you will also need to update the Extra-Source-Files and Exposed-Modules sections of highlighting-kate.cabal before recompiling using 'cabal install'.@@ -73,11 +90,8 @@  - javascript.xml:  Fixed regex \s* (which matches empty string) by changes to DetectSpaces - perl.xml:  Fixed regexes - needed backslash-escapes before ] and ^-- haskell.xml:  Added support for module names - bash.xml: Changed "\\" to "\" in two Detect2Char rules in FindString-- literate-haskell.xml:  Fixed single line comments and growing context stack -NOTE:  This software is largely untested.  Known bugs are recorded in the file-BUGS. Please send bug reports (or better, patches) to the author (jgm at-berkeley dot edu).+NOTE: Known bugs are recorded in the file BUGS. Please send bug reports (or+better, patches) to the author (jgm at berkeley dot edu). 

@@ -70,17 +70,16 @@                                  let newContexts = Map.alter (addContext context) lang contexts                                   updateState $ \st -> st { synStContexts = newContexts } -popContext :: GenParser tok SyntaxState String+popContext :: GenParser tok SyntaxState () popContext = do st <- getState                 let contexts = synStContexts st                 let lang = synStLanguage st                 case Map.lookup lang contexts of                     Just conts -> case length conts of                                         0 -> fail $ "Stack empty for language " ++ lang-                                        1 -> return (head conts) -- don't remove last member of stack+                                        1 -> return ()  -- don't remove last member of stack                                         _ -> do let newContexts = Map.adjust tail lang contexts                                                 updateState $ \st -> st { synStContexts = newContexts }-                                                return (head conts)                     Nothing    -> fail $ "No context stack for language " ++ lang   currentContext :: GenParser tok SyntaxState String@@ -296,4 +295,12 @@   first <- letter   rest <- many alphaNum   return (first:rest)++pHandleEndLine :: GenParser Char SyntaxState ()+pHandleEndLine = do+  newline <|> (eof >> return '\n')+  lineContents <- lookAhead wholeLine+  updateState $ \st -> st { synStCurrentLine = lineContents+                          , synStCharsParsedInLine = 0+                          , synStPrevChar = '\n' } 

@@ -3,71 +3,118 @@ import Data.Char (toLower) import Text.Highlighting.Kate.Definitions import Text.Highlighting.Kate.Common (matchGlobs)+import qualified Text.Highlighting.Kate.Syntax.Actionscript as Actionscript import qualified Text.Highlighting.Kate.Syntax.Ada as Ada import qualified Text.Highlighting.Kate.Syntax.Alert as Alert+import qualified Text.Highlighting.Kate.Syntax.Alert_indent as Alert_indent+import qualified Text.Highlighting.Kate.Syntax.Ansys as Ansys+import qualified Text.Highlighting.Kate.Syntax.Apache as Apache+import qualified Text.Highlighting.Kate.Syntax.Asn1 as Asn1 import qualified Text.Highlighting.Kate.Syntax.Asp as Asp import qualified Text.Highlighting.Kate.Syntax.Awk as Awk import qualified Text.Highlighting.Kate.Syntax.Bash as Bash import qualified Text.Highlighting.Kate.Syntax.Bibtex as Bibtex+import qualified Text.Highlighting.Kate.Syntax.Boo as Boo import qualified Text.Highlighting.Kate.Syntax.C as C+import qualified Text.Highlighting.Kate.Syntax.Changelog as Changelog+import qualified Text.Highlighting.Kate.Syntax.Cisco as Cisco import qualified Text.Highlighting.Kate.Syntax.Cmake as Cmake import qualified Text.Highlighting.Kate.Syntax.Coldfusion as Coldfusion import qualified Text.Highlighting.Kate.Syntax.Commonlisp as Commonlisp import qualified Text.Highlighting.Kate.Syntax.Cpp as Cpp+import qualified Text.Highlighting.Kate.Syntax.Cs as Cs import qualified Text.Highlighting.Kate.Syntax.Css as Css+import qualified Text.Highlighting.Kate.Syntax.Cue as Cue import qualified Text.Highlighting.Kate.Syntax.D as D+import qualified Text.Highlighting.Kate.Syntax.Desktop as Desktop+import qualified Text.Highlighting.Kate.Syntax.Diff as Diff import qualified Text.Highlighting.Kate.Syntax.Djangotemplate as Djangotemplate import qualified Text.Highlighting.Kate.Syntax.Doxygen as Doxygen+import qualified Text.Highlighting.Kate.Syntax.Doxygenlua as Doxygenlua import qualified Text.Highlighting.Kate.Syntax.Dtd as Dtd import qualified Text.Highlighting.Kate.Syntax.Eiffel as Eiffel+import qualified Text.Highlighting.Kate.Syntax.Email as Email import qualified Text.Highlighting.Kate.Syntax.Erlang as Erlang import qualified Text.Highlighting.Kate.Syntax.Fortran as Fortran+import qualified Text.Highlighting.Kate.Syntax.Fstab as Fstab+import qualified Text.Highlighting.Kate.Syntax.Gap as Gap+import qualified Text.Highlighting.Kate.Syntax.Gdb as Gdb+import qualified Text.Highlighting.Kate.Syntax.Gettext as Gettext+import qualified Text.Highlighting.Kate.Syntax.Gnuassembler as Gnuassembler+import qualified Text.Highlighting.Kate.Syntax.Go as Go import qualified Text.Highlighting.Kate.Syntax.Haskell as Haskell+import qualified Text.Highlighting.Kate.Syntax.Haxe as Haxe import qualified Text.Highlighting.Kate.Syntax.Html as Html+import qualified Text.Highlighting.Kate.Syntax.Idl as Idl+import qualified Text.Highlighting.Kate.Syntax.Ilerpg as Ilerpg+import qualified Text.Highlighting.Kate.Syntax.Ini as Ini import qualified Text.Highlighting.Kate.Syntax.Java as Java import qualified Text.Highlighting.Kate.Syntax.Javadoc as Javadoc import qualified Text.Highlighting.Kate.Syntax.Javascript as Javascript import qualified Text.Highlighting.Kate.Syntax.Json as Json+import qualified Text.Highlighting.Kate.Syntax.Jsp as Jsp import qualified Text.Highlighting.Kate.Syntax.Latex as Latex import qualified Text.Highlighting.Kate.Syntax.Lex as Lex import qualified Text.Highlighting.Kate.Syntax.LiterateHaskell as LiterateHaskell import qualified Text.Highlighting.Kate.Syntax.Lua as Lua+import qualified Text.Highlighting.Kate.Syntax.M3u as M3u import qualified Text.Highlighting.Kate.Syntax.Makefile as Makefile+import qualified Text.Highlighting.Kate.Syntax.Mandoc as Mandoc import qualified Text.Highlighting.Kate.Syntax.Matlab as Matlab+import qualified Text.Highlighting.Kate.Syntax.Maxima as Maxima import qualified Text.Highlighting.Kate.Syntax.Mediawiki as Mediawiki+import qualified Text.Highlighting.Kate.Syntax.Metafont as Metafont+import qualified Text.Highlighting.Kate.Syntax.Mips as Mips+import qualified Text.Highlighting.Kate.Syntax.Modula2 as Modula2 import qualified Text.Highlighting.Kate.Syntax.Modula3 as Modula3+import qualified Text.Highlighting.Kate.Syntax.Monobasic as Monobasic import qualified Text.Highlighting.Kate.Syntax.Nasm as Nasm+import qualified Text.Highlighting.Kate.Syntax.Noweb as Noweb import qualified Text.Highlighting.Kate.Syntax.Objectivec as Objectivec+import qualified Text.Highlighting.Kate.Syntax.Objectivecpp as Objectivecpp import qualified Text.Highlighting.Kate.Syntax.Ocaml as Ocaml import qualified Text.Highlighting.Kate.Syntax.Octave as Octave+import qualified Text.Highlighting.Kate.Syntax.Pango as Pango 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+import qualified Text.Highlighting.Kate.Syntax.Pike as Pike import qualified Text.Highlighting.Kate.Syntax.Postscript as Postscript import qualified Text.Highlighting.Kate.Syntax.Prolog as Prolog import qualified Text.Highlighting.Kate.Syntax.Python as Python+import qualified Text.Highlighting.Kate.Syntax.R as R import qualified Text.Highlighting.Kate.Syntax.Relaxngcompact as Relaxngcompact import qualified Text.Highlighting.Kate.Syntax.Rhtml as Rhtml import qualified Text.Highlighting.Kate.Syntax.Ruby as Ruby import qualified Text.Highlighting.Kate.Syntax.Scala as Scala import qualified Text.Highlighting.Kate.Syntax.Scheme as Scheme+import qualified Text.Highlighting.Kate.Syntax.Sci as Sci+import qualified Text.Highlighting.Kate.Syntax.Sed as Sed import qualified Text.Highlighting.Kate.Syntax.Sgml as Sgml import qualified Text.Highlighting.Kate.Syntax.Sql as Sql import qualified Text.Highlighting.Kate.Syntax.SqlMysql as SqlMysql import qualified Text.Highlighting.Kate.Syntax.SqlPostgresql as SqlPostgresql import qualified Text.Highlighting.Kate.Syntax.Tcl as Tcl import qualified Text.Highlighting.Kate.Syntax.Texinfo as Texinfo+import qualified Text.Highlighting.Kate.Syntax.Verilog as Verilog+import qualified Text.Highlighting.Kate.Syntax.Vhdl as Vhdl+import qualified Text.Highlighting.Kate.Syntax.Winehq as Winehq+import qualified Text.Highlighting.Kate.Syntax.Wml as Wml+import qualified Text.Highlighting.Kate.Syntax.Xharbour as Xharbour import qualified Text.Highlighting.Kate.Syntax.Xml as Xml+import qualified Text.Highlighting.Kate.Syntax.Xorg as Xorg import qualified Text.Highlighting.Kate.Syntax.Xslt as Xslt+import qualified Text.Highlighting.Kate.Syntax.Xul as Xul import qualified Text.Highlighting.Kate.Syntax.Yacc as Yacc+import qualified Text.Highlighting.Kate.Syntax.Yaml as Yaml  -- | 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","Octave","Pascal","Perl","Php","Postscript","Prolog","Python","Relaxngcompact","Rhtml","Ruby","Scala","Scheme","Sgml","Sql","SqlMysql","SqlPostgresql","Tcl","Texinfo","Xml","Xslt","Yacc"]+languages = ["Actionscript","Ada","Alert","Alert_indent","Ansys","Apache","Asn1","Asp","Awk","Bash","Bibtex","Boo","C","Changelog","Cisco","Cmake","Coldfusion","Commonlisp","Cpp","Cs","Css","Cue","D","Desktop","Diff","Djangotemplate","Doxygen","Doxygenlua","Dtd","Eiffel","Email","Erlang","Fortran","Fstab","Gap","Gdb","Gettext","Gnuassembler","Go","Haskell","Haxe","Html","Idl","Ilerpg","Ini","Java","Javadoc","Javascript","Json","Jsp","Latex","Lex","LiterateHaskell","Lua","M3u","Makefile","Mandoc","Matlab","Maxima","Mediawiki","Metafont","Mips","Modula2","Modula3","Monobasic","Nasm","Noweb","Objectivec","Objectivecpp","Ocaml","Octave","Pango","Pascal","Perl","Php","Pike","Postscript","Prolog","Python","R","Relaxngcompact","Rhtml","Ruby","Scala","Scheme","Sci","Sed","Sgml","Sql","SqlMysql","SqlPostgresql","Tcl","Texinfo","Verilog","Vhdl","Winehq","Wml","Xharbour","Xml","Xorg","Xslt","Xul","Yacc","Yaml"]  -- | 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), ("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)]+languageExtensions = [("Actionscript", Actionscript.syntaxExtensions), ("Ada", Ada.syntaxExtensions), ("Alert", Alert.syntaxExtensions), ("Alert_indent", Alert_indent.syntaxExtensions), ("Ansys", Ansys.syntaxExtensions), ("Apache", Apache.syntaxExtensions), ("Asn1", Asn1.syntaxExtensions), ("Asp", Asp.syntaxExtensions), ("Awk", Awk.syntaxExtensions), ("Bash", Bash.syntaxExtensions), ("Bibtex", Bibtex.syntaxExtensions), ("Boo", Boo.syntaxExtensions), ("C", C.syntaxExtensions), ("Changelog", Changelog.syntaxExtensions), ("Cisco", Cisco.syntaxExtensions), ("Cmake", Cmake.syntaxExtensions), ("Coldfusion", Coldfusion.syntaxExtensions), ("Commonlisp", Commonlisp.syntaxExtensions), ("Cpp", Cpp.syntaxExtensions), ("Cs", Cs.syntaxExtensions), ("Css", Css.syntaxExtensions), ("Cue", Cue.syntaxExtensions), ("D", D.syntaxExtensions), ("Desktop", Desktop.syntaxExtensions), ("Diff", Diff.syntaxExtensions), ("Djangotemplate", Djangotemplate.syntaxExtensions), ("Doxygen", Doxygen.syntaxExtensions), ("Doxygenlua", Doxygenlua.syntaxExtensions), ("Dtd", Dtd.syntaxExtensions), ("Eiffel", Eiffel.syntaxExtensions), ("Email", Email.syntaxExtensions), ("Erlang", Erlang.syntaxExtensions), ("Fortran", Fortran.syntaxExtensions), ("Fstab", Fstab.syntaxExtensions), ("Gap", Gap.syntaxExtensions), ("Gdb", Gdb.syntaxExtensions), ("Gettext", Gettext.syntaxExtensions), ("Gnuassembler", Gnuassembler.syntaxExtensions), ("Go", Go.syntaxExtensions), ("Haskell", Haskell.syntaxExtensions), ("Haxe", Haxe.syntaxExtensions), ("Html", Html.syntaxExtensions), ("Idl", Idl.syntaxExtensions), ("Ilerpg", Ilerpg.syntaxExtensions), ("Ini", Ini.syntaxExtensions), ("Java", Java.syntaxExtensions), ("Javadoc", Javadoc.syntaxExtensions), ("Javascript", Javascript.syntaxExtensions), ("Json", Json.syntaxExtensions), ("Jsp", Jsp.syntaxExtensions), ("Latex", Latex.syntaxExtensions), ("Lex", Lex.syntaxExtensions), ("LiterateHaskell", LiterateHaskell.syntaxExtensions), ("Lua", Lua.syntaxExtensions), ("M3u", M3u.syntaxExtensions), ("Makefile", Makefile.syntaxExtensions), ("Mandoc", Mandoc.syntaxExtensions), ("Matlab", Matlab.syntaxExtensions), ("Maxima", Maxima.syntaxExtensions), ("Mediawiki", Mediawiki.syntaxExtensions), ("Metafont", Metafont.syntaxExtensions), ("Mips", Mips.syntaxExtensions), ("Modula2", Modula2.syntaxExtensions), ("Modula3", Modula3.syntaxExtensions), ("Monobasic", Monobasic.syntaxExtensions), ("Nasm", Nasm.syntaxExtensions), ("Noweb", Noweb.syntaxExtensions), ("Objectivec", Objectivec.syntaxExtensions), ("Objectivecpp", Objectivecpp.syntaxExtensions), ("Ocaml", Ocaml.syntaxExtensions), ("Octave", Octave.syntaxExtensions), ("Pango", Pango.syntaxExtensions), ("Pascal", Pascal.syntaxExtensions), ("Perl", Perl.syntaxExtensions), ("Php", Php.syntaxExtensions), ("Pike", Pike.syntaxExtensions), ("Postscript", Postscript.syntaxExtensions), ("Prolog", Prolog.syntaxExtensions), ("Python", Python.syntaxExtensions), ("R", R.syntaxExtensions), ("Relaxngcompact", Relaxngcompact.syntaxExtensions), ("Rhtml", Rhtml.syntaxExtensions), ("Ruby", Ruby.syntaxExtensions), ("Scala", Scala.syntaxExtensions), ("Scheme", Scheme.syntaxExtensions), ("Sci", Sci.syntaxExtensions), ("Sed", Sed.syntaxExtensions), ("Sgml", Sgml.syntaxExtensions), ("Sql", Sql.syntaxExtensions), ("SqlMysql", SqlMysql.syntaxExtensions), ("SqlPostgresql", SqlPostgresql.syntaxExtensions), ("Tcl", Tcl.syntaxExtensions), ("Texinfo", Texinfo.syntaxExtensions), ("Verilog", Verilog.syntaxExtensions), ("Vhdl", Vhdl.syntaxExtensions), ("Winehq", Winehq.syntaxExtensions), ("Wml", Wml.syntaxExtensions), ("Xharbour", Xharbour.syntaxExtensions), ("Xml", Xml.syntaxExtensions), ("Xorg", Xorg.syntaxExtensions), ("Xslt", Xslt.syntaxExtensions), ("Xul", Xul.syntaxExtensions), ("Yacc", Yacc.syntaxExtensions), ("Yaml", Yaml.syntaxExtensions)]  -- | Returns a list of languages appropriate for the given file extension. languagesByExtension :: String -> [String]@@ -90,61 +137,108 @@                             [l]  -> map toLower l  -- go by extension if unambiguous                             _    -> lang'   in  case lang'' of+        "actionscript" -> Actionscript.highlight         "ada" -> Ada.highlight         "alert" -> Alert.highlight+        "alert_indent" -> Alert_indent.highlight+        "ansys" -> Ansys.highlight+        "apache" -> Apache.highlight+        "asn1" -> Asn1.highlight         "asp" -> Asp.highlight         "awk" -> Awk.highlight         "bash" -> Bash.highlight         "bibtex" -> Bibtex.highlight+        "boo" -> Boo.highlight         "c" -> C.highlight+        "changelog" -> Changelog.highlight+        "cisco" -> Cisco.highlight         "cmake" -> Cmake.highlight         "coldfusion" -> Coldfusion.highlight         "commonlisp" -> Commonlisp.highlight         "cpp" -> Cpp.highlight+        "cs" -> Cs.highlight         "css" -> Css.highlight+        "cue" -> Cue.highlight         "d" -> D.highlight+        "desktop" -> Desktop.highlight+        "diff" -> Diff.highlight         "djangotemplate" -> Djangotemplate.highlight         "doxygen" -> Doxygen.highlight+        "doxygenlua" -> Doxygenlua.highlight         "dtd" -> Dtd.highlight         "eiffel" -> Eiffel.highlight+        "email" -> Email.highlight         "erlang" -> Erlang.highlight         "fortran" -> Fortran.highlight+        "fstab" -> Fstab.highlight+        "gap" -> Gap.highlight+        "gdb" -> Gdb.highlight+        "gettext" -> Gettext.highlight+        "gnuassembler" -> Gnuassembler.highlight+        "go" -> Go.highlight         "haskell" -> Haskell.highlight+        "haxe" -> Haxe.highlight         "html" -> Html.highlight+        "idl" -> Idl.highlight+        "ilerpg" -> Ilerpg.highlight+        "ini" -> Ini.highlight         "java" -> Java.highlight         "javadoc" -> Javadoc.highlight         "javascript" -> Javascript.highlight         "json" -> Json.highlight+        "jsp" -> Jsp.highlight         "latex" -> Latex.highlight         "lex" -> Lex.highlight         "literatehaskell" -> LiterateHaskell.highlight         "lua" -> Lua.highlight+        "m3u" -> M3u.highlight         "makefile" -> Makefile.highlight+        "mandoc" -> Mandoc.highlight         "matlab" -> Matlab.highlight+        "maxima" -> Maxima.highlight         "mediawiki" -> Mediawiki.highlight+        "metafont" -> Metafont.highlight+        "mips" -> Mips.highlight+        "modula2" -> Modula2.highlight         "modula3" -> Modula3.highlight+        "monobasic" -> Monobasic.highlight         "nasm" -> Nasm.highlight+        "noweb" -> Noweb.highlight         "objectivec" -> Objectivec.highlight+        "objectivecpp" -> Objectivecpp.highlight         "ocaml" -> Ocaml.highlight         "octave" -> Octave.highlight+        "pango" -> Pango.highlight         "pascal" -> Pascal.highlight         "perl" -> Perl.highlight         "php" -> Php.highlight+        "pike" -> Pike.highlight         "postscript" -> Postscript.highlight         "prolog" -> Prolog.highlight         "python" -> Python.highlight+        "r" -> R.highlight         "relaxngcompact" -> Relaxngcompact.highlight         "rhtml" -> Rhtml.highlight         "ruby" -> Ruby.highlight         "scala" -> Scala.highlight         "scheme" -> Scheme.highlight+        "sci" -> Sci.highlight+        "sed" -> Sed.highlight         "sgml" -> Sgml.highlight         "sql" -> Sql.highlight         "sqlmysql" -> SqlMysql.highlight         "sqlpostgresql" -> SqlPostgresql.highlight         "tcl" -> Tcl.highlight         "texinfo" -> Texinfo.highlight+        "verilog" -> Verilog.highlight+        "vhdl" -> Vhdl.highlight+        "winehq" -> Winehq.highlight+        "wml" -> Wml.highlight+        "xharbour" -> Xharbour.highlight         "xml" -> Xml.highlight+        "xorg" -> Xorg.highlight         "xslt" -> Xslt.highlight+        "xul" -> Xul.highlight         "yacc" -> Yacc.highlight+        "yaml" -> Yaml.highlight         _ -> (\_ -> Left ("Unknown language: " ++ lang))

@@ -0,0 +1,192 @@+{- This module was generated from data in the Kate syntax highlighting file actionscript.xml, version 1.0,+   by  Aaron Miller (armantic101@gmail.com) -}++module Text.Highlighting.Kate.Syntax.Actionscript ( highlight, parseExpression, syntaxName, syntaxExtensions ) where+import Text.Highlighting.Kate.Definitions+import Text.Highlighting.Kate.Common+import qualified Text.Highlighting.Kate.Syntax.Javadoc+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 = "ActionScript 2.0"++-- | Filename extensions for this language.+syntaxExtensions :: String+syntaxExtensions = "*.as"++-- | Highlight source code using this syntax definition.+highlight :: String -> Either String [SourceLine]+highlight input =+  case runParser parseSource startingState "source" input of+    Left err     -> Left $ show err+    Right result -> Right result++-- | Parse an expression using appropriate local context.+parseExpression :: GenParser Char SyntaxState LabeledSource+parseExpression = do+  st <- getState+  let oldLang = synStLanguage st+  setState $ st { synStLanguage = "ActionScript 2.0" }+  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 [("ActionScript 2.0",["Normal"])], synStLanguage = "ActionScript 2.0", synStCurrentLine = "", synStCharsParsedInLine = 0, synStPrevChar = '\n', synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}++parseSourceLine = manyTill parseExpressionInternal pEndLine++pEndLine = do+  lookAhead $ newline <|> (eof >> return '\n')+  context <- currentContext+  case context of+    "Normal" -> return () >> pHandleEndLine+    "String" -> (popContext) >> pEndLine+    "Member" -> (popContext) >> pEndLine+    "StaticImports" -> (popContext) >> pEndLine+    "Imports" -> (popContext) >> pEndLine+    "Commentar 1" -> (popContext) >> pEndLine+    "Commentar 2" -> return () >> pHandleEndLine+    _ -> pHandleEndLine++withAttribute attr txt = do+  when (null txt) $ fail "Parser matched no text"+  let labs = attr : maybeToList (lookup attr styles)+  st <- getState+  let oldCharsParsed = synStCharsParsedInLine st+  let prevchar = if null txt then '\n' else last txt+  updateState $ \st -> st { synStCharsParsedInLine = oldCharsParsed + length txt, synStPrevChar = prevchar } +  return (labs, txt)++styles = [("Keyword","kw"),("Function","fu"),("StaticImports","kw"),("Imports","kw"),("Data Type","dt"),("Decimal","dv"),("Octal","bn"),("Hex","bn"),("Float","fl"),("Char","ch"),("String","st"),("String Char","ch"),("Comment","co")]++parseExpressionInternal = do+  context <- currentContext+  parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes))++list_properties = Set.fromList $ words $ "_accProps _focusrect _global _highquality _level _parent _quality _root _soundbuftime maxscroll scroll this"+list_global'5ffunctions = Set.fromList $ words $ "asfunction call chr clearInterval duplicateMovieClip escape eval fscommand getProperty getTimer getURL getVersion gotoAndPlay gotoAndStop ifFrameLoaded int isFinite isNaN length loadMovie loadMovieNum loadVariables loadVariablesNum mbchr mblength mbord mbsubstring nextFrame nextScene on onClipEvent ord parseFloat parseInt play prevFrame prevScene print printAsBitmap printAsBitmapNum printNum random removeMovieClip setInterval setProperty showRedrawRegions startDrag stop stopAllSounds stopDrag substring targetPath tellTarget toggleHighQuality trace typeof unescape unloadMovie unloadMovieNum updateAfterEvent"+list_classes = Set.fromList $ words $ "Accessibility Accordion Alert Binding Button Camera CellRenderer CheckBox Collection Color ComboBox ComponentMixins ContextMenu ContextMenuItem CustomActions CustomFormatter CustomValidator DataGrid DataHolder DataProvider DataSet DataType Date DateChooser DateField Delta DeltaItem DeltaPacket DepthManager EndPoint Error FaultEvent FocusManager Form Function Iterator Key Label List LoadVars Loader LocalConnection Log Math Media Menu MenuBar Microphone Mouse MovieClip MovieClipLoader NetConnection NetStream Number NumericStepper PendingCall PopUpManager PrintJob ProgressBar RDBMSResolver RadioButton RelayResponder SOAPCall Screen ScrollPane Selection SharedObject Slide Sound Stage StyleManager System TextArea TextField TextFormat TextInput TextSnapshot TransferObject Tree TreeDataProvider TypedValue UIComponent UIEventDispatcher UIObject Video WebService WebServiceConnector Window XML XMLConnector XUpdateResolver"+list_keywords = Set.fromList $ words $ "add and break case catch class continue default delete do dynamic else eq extends finally for function ge get gt if implements import in instanceof interface intrinsic le lt ne new not or private public return set static switch throw try var void while with"+list_const = Set.fromList $ words $ "false Infinity -Infinity NaN newline null true undefined"+list_types = Set.fromList $ words $ "Array Boolean Number Object String Void"++regex_'2f'2f'5cs'2aBEGIN'2e'2a'24 = compileRegex "//\\s*BEGIN.*$"+regex_'2f'2f'5cs'2aEND'2e'2a'24 = compileRegex "//\\s*END.*$"+regex_'5c'2e'7b3'2c3'7d'5cs'2b = compileRegex "\\.{3,3}\\s+"+regex_'5cb'28import'5cs'2bstatic'29'5cb = compileRegex "\\b(import\\s+static)\\b"+regex_'5cb'28package'7cimport'29'5cb = compileRegex "\\b(package|import)\\b"+regex_'5cb'5b'5f'5cw'5d'5b'5f'5cw'5cd'5d'2a'28'3f'3d'5b'5cs'5d'2a'28'2f'5c'2a'5cs'2a'5cd'2b'5cs'2a'5c'2a'2f'5cs'2a'29'3f'5b'28'5d'29 = compileRegex "\\b[_\\w][_\\w\\d]*(?=[\\s]*(/\\*\\s*\\d+\\s*\\*/\\s*)?[(])"+regex_'5b'2e'5d'7b1'2c1'7d = compileRegex "[.]{1,1}"+regex_'5cb'5b'5fa'2dzA'2dZ'5d'5cw'2a'28'3f'3d'5b'5cs'5d'2a'29 = compileRegex "\\b[_a-zA-Z]\\w*(?=[\\s]*)"+regex_'5cs'2a'2e'2a'24 = compileRegex "\\s*.*$"++defaultAttributes = [("Normal","Normal Text"),("String","String"),("Member","Normal Text"),("StaticImports","Normal Text"),("Imports","Normal Text"),("Commentar 1","Comment"),("Commentar 2","Comment")]++parseRules "Normal" = +  do (attr, result) <- (((Text.Highlighting.Kate.Syntax.Javadoc.parseExpression))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_properties >>= withAttribute "Properties"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_global'5ffunctions >>= withAttribute "Global Functions"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_classes >>= withAttribute "Classes"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_keywords >>= withAttribute "Keyword"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_const >>= withAttribute "Constants"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_types >>= withAttribute "Data Type"))+                        <|>+                        (withChildren (pFloat >>= withAttribute "Float") ((pAnyChar "fF" >>= withAttribute "Float")))+                        <|>+                        ((pHlCOct >>= withAttribute "Octal"))+                        <|>+                        ((pHlCHex >>= withAttribute "Hex"))+                        <|>+                        (withChildren (pInt >>= withAttribute "Decimal") (((pString False "ULL" >>= withAttribute "Decimal"))+                                                                          <|>+                                                                          ((pString False "LUL" >>= withAttribute "Decimal"))+                                                                          <|>+                                                                          ((pString False "LLU" >>= withAttribute "Decimal"))+                                                                          <|>+                                                                          ((pString False "UL" >>= withAttribute "Decimal"))+                                                                          <|>+                                                                          ((pString False "LU" >>= withAttribute "Decimal"))+                                                                          <|>+                                                                          ((pString False "LL" >>= withAttribute "Decimal"))+                                                                          <|>+                                                                          ((pString False "U" >>= withAttribute "Decimal"))+                                                                          <|>+                                                                          ((pString False "L" >>= withAttribute "Decimal"))))+                        <|>+                        ((pHlCChar >>= withAttribute "Char"))+                        <|>+                        ((pRegExpr regex_'2f'2f'5cs'2aBEGIN'2e'2a'24 >>= withAttribute "Decimal"))+                        <|>+                        ((pRegExpr regex_'2f'2f'5cs'2aEND'2e'2a'24 >>= withAttribute "Decimal"))+                        <|>+                        ((pDetectChar False '"' >>= withAttribute "String") >>~ pushContext "String")+                        <|>+                        ((pDetect2Chars False '/' '/' >>= withAttribute "Comment") >>~ pushContext "Commentar 1")+                        <|>+                        ((pDetect2Chars False '/' '*' >>= withAttribute "Comment") >>~ pushContext "Commentar 2")+                        <|>+                        ((pDetectChar False '{' >>= withAttribute "Symbol"))+                        <|>+                        ((pDetectChar False '}' >>= withAttribute "Symbol"))+                        <|>+                        ((pRegExpr regex_'5c'2e'7b3'2c3'7d'5cs'2b >>= withAttribute "Keyword"))+                        <|>+                        ((pRegExpr regex_'5cb'28import'5cs'2bstatic'29'5cb >>= withAttribute "Keyword") >>~ pushContext "StaticImports")+                        <|>+                        ((pRegExpr regex_'5cb'28package'7cimport'29'5cb >>= withAttribute "Keyword") >>~ pushContext "Imports")+                        <|>+                        ((pRegExpr regex_'5cb'5b'5f'5cw'5d'5b'5f'5cw'5cd'5d'2a'28'3f'3d'5b'5cs'5d'2a'28'2f'5c'2a'5cs'2a'5cd'2b'5cs'2a'5c'2a'2f'5cs'2a'29'3f'5b'28'5d'29 >>= withAttribute "Function"))+                        <|>+                        ((pRegExpr regex_'5b'2e'5d'7b1'2c1'7d >>= withAttribute "Symbol") >>~ pushContext "Member")+                        <|>+                        ((pAnyChar ":!%&()+,-/.*<=>?[]|~^;" >>= withAttribute "Symbol")))+     return (attr, result)++parseRules "String" = +  do (attr, result) <- (((pLineContinue >>= withAttribute "String"))+                        <|>+                        ((pHlCStringChar >>= withAttribute "String Char"))+                        <|>+                        ((pDetectChar False '"' >>= withAttribute "String") >>~ (popContext)))+     return (attr, result)++parseRules "Member" = +  do (attr, result) <- (((pRegExpr regex_'5cb'5b'5fa'2dzA'2dZ'5d'5cw'2a'28'3f'3d'5b'5cs'5d'2a'29 >>= withAttribute "Function") >>~ (popContext))+                        <|>+                        ((popContext) >> return ([], "")))+     return (attr, result)++parseRules "StaticImports" = +  do (attr, result) <- ((pRegExpr regex_'5cs'2a'2e'2a'24 >>= withAttribute "StaticImports") >>~ (popContext))+     return (attr, result)++parseRules "Imports" = +  do (attr, result) <- ((pRegExpr regex_'5cs'2a'2e'2a'24 >>= withAttribute "Imports") >>~ (popContext))+     return (attr, result)++parseRules "Commentar 1" = +  pzero++parseRules "Commentar 2" = +  do (attr, result) <- ((pDetect2Chars False '*' '/' >>= withAttribute "Comment") >>~ (popContext))+     return (attr, result)++parseRules x = fail $ "Unknown context" ++ x

@@ -47,16 +47,14 @@ parseSourceLine = manyTill parseExpressionInternal pEndLine  pEndLine = do-  newline <|> (eof >> return '\n')+  lookAhead $ newline <|> (eof >> return '\n')   context <- currentContext   case context of-    "Default" -> return ()-    "Region Marker" -> (popContext >> return ())-    "String" -> (popContext >> return ())-    "Comment" -> (popContext >> return ())-    _ -> return ()-  lineContents <- lookAhead wholeLine-  updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }+    "Default" -> return () >> pHandleEndLine+    "Region Marker" -> (popContext) >> pEndLine+    "String" -> (popContext) >> pEndLine+    "Comment" -> (popContext) >> pEndLine+    _ -> pHandleEndLine  withAttribute attr txt = do   when (null txt) $ fail "Parser matched no text"@@ -145,7 +143,7 @@   pzero  parseRules "String" = -  do (attr, result) <- ((pDetectChar False '"' >>= withAttribute "String") >>~ (popContext >> return ()))+  do (attr, result) <- ((pDetectChar False '"' >>= withAttribute "String") >>~ (popContext))      return (attr, result)  parseRules "Comment" = 

@@ -1,4 +1,4 @@-{- This module was generated from data in the Kate syntax highlighting file alert.xml, version 1.07,+{- This module was generated from data in the Kate syntax highlighting file alert.xml, version 1.08,    by  Dominik Haumann (dhdev@gmx.de) -}  module Text.Highlighting.Kate.Syntax.Alert ( highlight, parseExpression, syntaxName, syntaxExtensions ) where@@ -47,13 +47,11 @@ parseSourceLine = manyTill parseExpressionInternal pEndLine  pEndLine = do-  newline <|> (eof >> return '\n')+  lookAhead $ newline <|> (eof >> return '\n')   context <- currentContext   case context of-    "Normal Text" -> (popContext >> return ())-    _ -> return ()-  lineContents <- lookAhead wholeLine-  updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }+    "Normal Text" -> (popContext) >> pEndLine+    _ -> pHandleEndLine  withAttribute attr txt = do   when (null txt) $ fail "Parser matched no text"@@ -70,7 +68,7 @@   context <- currentContext   parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes)) -list_alerts = Set.fromList $ words $ "FIXME HACK NOTE NOTICE TASK TODO DEPRECATED WARNING ###"+list_alerts = Set.fromList $ words $ "### ALERT BUG DANGER DEPRECATED FIXME HACK NOTE NOTICE SECURITY TASK TEST TESTING TODO WARNING"   defaultAttributes = [("Normal Text","Normal Text")]

@@ -0,0 +1,80 @@+{- This module was generated from data in the Kate syntax highlighting file alert_indent.xml, version 1.08,+   by  Dominik Haumann (dhdev@gmx.de) -}++module Text.Highlighting.Kate.Syntax.Alert_indent ( highlight, parseExpression, syntaxName, syntaxExtensions ) where+import Text.Highlighting.Kate.Definitions+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 = "Alerts_indent"++-- | Filename extensions for this language.+syntaxExtensions :: String+syntaxExtensions = ""++-- | Highlight source code using this syntax definition.+highlight :: String -> Either String [SourceLine]+highlight input =+  case runParser parseSource startingState "source" input of+    Left err     -> Left $ show err+    Right result -> Right result++-- | Parse an expression using appropriate local context.+parseExpression :: GenParser Char SyntaxState LabeledSource+parseExpression = do+  st <- getState+  let oldLang = synStLanguage st+  setState $ st { synStLanguage = "Alerts_indent" }+  context <- currentContext <|> (pushContext "Normal Text" >> 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 [("Alerts_indent",["Normal Text"])], synStLanguage = "Alerts_indent", synStCurrentLine = "", synStCharsParsedInLine = 0, synStPrevChar = '\n', synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}++parseSourceLine = manyTill parseExpressionInternal pEndLine++pEndLine = do+  lookAhead $ newline <|> (eof >> return '\n')+  context <- currentContext+  case context of+    "Normal Text" -> (popContext) >> pEndLine+    _ -> pHandleEndLine++withAttribute attr txt = do+  when (null txt) $ fail "Parser matched no text"+  let labs = attr : maybeToList (lookup attr styles)+  st <- getState+  let oldCharsParsed = synStCharsParsedInLine st+  let prevchar = if null txt then '\n' else last txt+  updateState $ \st -> st { synStCharsParsedInLine = oldCharsParsed + length txt, synStPrevChar = prevchar } +  return (labs, txt)++styles = [("Alert","al")]++parseExpressionInternal = do+  context <- currentContext+  parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes))++list_alerts = Set.fromList $ words $ "### ALERT BUG DANGER DEPRECATED FIXME HACK NOTE NOTICE SECURITY TASK TEST TESTING TODO WARNING"+++defaultAttributes = [("Normal Text","Normal Text")]++parseRules "Normal Text" = +  do (attr, result) <- ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_alerts >>= withAttribute "Alert"))+     return (attr, result)++parseRules x = fail $ "Unknown context" ++ x

@@ -0,0 +1,197 @@+{- This module was generated from data in the Kate syntax highlighting file ansys.xml, version 1.1,+   by  Giovanni Bacci (giovanni@castellodilari.it) -}++module Text.Highlighting.Kate.Syntax.Ansys ( 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 = "Ansys"++-- | Filename extensions for this language.+syntaxExtensions :: String+syntaxExtensions = "*.ans"++-- | 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 = "Ansys" }+  context <- currentContext <|> (pushContext "Normal Text" >> 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 [("Ansys",["Normal Text"])], synStLanguage = "Ansys", synStCurrentLine = "", synStCharsParsedInLine = 0, synStPrevChar = '\n', synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}++parseSourceLine = manyTill parseExpressionInternal pEndLine++pEndLine = do+  lookAhead $ newline <|> (eof >> return '\n')+  context <- currentContext+  case context of+    "Normal Text" -> (popContext) >> pEndLine+    "doublequotestring" -> return () >> pHandleEndLine+    "functions" -> (popContext) >> pEndLine+    "open_parentesis" -> (popContext) >> pEndLine+    "comment" -> (popContext) >> pEndLine+    "functions_arg" -> (popContext) >> pEndLine+    _ -> pHandleEndLine++withAttribute attr txt = do+  when (null txt) $ fail "Parser matched no text"+  let labs = attr : maybeToList (lookup attr styles)+  st <- getState+  let oldCharsParsed = synStCharsParsedInLine st+  let prevchar = if null txt then '\n' else last txt+  updateState $ \st -> st { synStCharsParsedInLine = oldCharsParsed + length txt, synStPrevChar = prevchar } +  return (labs, txt)++styles = [("Keyword","kw"),("MatProp","dt"),("Labels","ch"),("APDLcmd","fu"),("SESSIONcmd","fu"),("DBcmd","fu"),("GRPH_cmds","fu"),("PREP7Commands","fu"),("SOLUCommands","fu"),("POST1Commands","fu"),("POST26Commands","fu"),("AUX2cmds","fu"),("AUX3cmds","fu"),("AUX12cmds","fu"),("AUX15cmds","fu"),("RUNSTATcmds","fu"),("OPTIMIZATIONcmds","fu"),("PROBcmds","fu"),("DISPLAYcmds","fu"),("REDUORDERcmds","fu"),("Commands","ot"),("variable","ot"),("String","st"),("NumInt","dv"),("NumFloat","fl"),("functions_arg","kw"),("comment","co"),("parentesis_not_closed","re"),("error","er")]++parseExpressionInternal = do+  context <- currentContext+  parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes))++list_session'5fcmds = Set.fromList $ words $ "/batch /config /cwd /eof /exit /filname help /input keyw memm /menu /mstart /nerr /output /status /syp /sys /ui /uis /aux2 /aux3 /aux12 /aux15 finish /opt /post1 /post26 /prep7 /quit /runst /solu /assign /clog /copy /delete /fdele /ftype lgwrite *list /rename /com /go /golist /gopr /nolist /nopr"+list_database'5fcmds = Set.fromList $ words $ "/clear resume save /smbc stat /stitle /title undo /units allsel asll asel aslv dofsel esel esla esll esln eslv ksel ksll ksln lsel lsla lslk nsel nsla nsle nslk nsll nslv partsel vsel vsla cm cmdele cmedit cmgrp cmlist cmmod cmplot cmsel kwpave kwplan lwplan nwpave nwplan wpave wpcsys wplane wpoffs wprota wpstyl clocal cs cscir csdele cskp cslist cswpla csys local fitem flst"+list_graphic'5fcmds = Set.fromList $ words $ "/cmap /color /device dsys /dv3d /erase erase /gcmd /gcolumn /gfile gplot /graphics /gresume /gsave /gtype hpgl /image immed jpeg /mrep /noerase /pcopy pngr pscr /pstatus /replot /reset /seg /show tiff /window /angle /auto /dist /focus /user /vcone /view /vup /xfrm /zoom /dscale /iclwid /icscale /ratio /shrink /sscale /txtre /vscale /cplane /ctype /edge /eshape /facet /gline /gmarker gmface /light /normal /shade /trlcy /type /cformat /clabel /contour /cval /gformat /hbc /number /pbc /pbf pgsele /pice /plopts /pnum /psf /psymb /triad /udoc /axlab /grid /gropt /grtyp /gthk /xrange /yrange /an3d /annot /anum /larc /line /lspec /lsymbol /pcircle /pmore /polygon /pspec /pwedge /tlabel /tspec"+list_APDL'5fcommands = Set.fromList $ words $ "get *abbr abbres abbsav *afun *ask *cfclos *cfopen *cfwrite *create *cycle *del /dflab *dim /directory *do *dowhile *else *elseif *end *enddo *endif *exit *get *go *if /inquire /mail *mfouri *mfun *moper *msg *mwrite parres parsav /pmacro /psearch *repeat *return *set *sread *status *taxis /tee *toper *tread /ucmd *ulib *use *vabs *vcol *vcum *vedit *vfact *vfill *vfun *vget *vitrp *vlen *vmask *voper *vplot *vput *vread *vscfun *vstat *vwrite /wait"+list_prep7'5fcommands = Set.fromList $ words $ "aflist cdread cdwrite cdopt cecheck check cncheck fc fccheck fcdele fclist igesout nooffset numcmp nummrg numoff numstr dof et etcontrol etdele etlist keyopt nsvr r rdele rlist rmodif rmore setfgap emunit *eval *mooney mp mpamod mpchg mpcopy mpdata mpdele mpdres /mplib mplist mpplot mpread mptemp mptgen mptres mpwrite tbft uimp tb tbcopy tbdata tbdele tbfield tblist tbmodif tbplot tbpt tbtemp blc4 blc5 block con4 cone cyl4 cyl5 cylind pcirc poly pri2 prism ptxy rectng rpoly rpr4 rprism sph4 sph5 sphere torus gsum k kbetw kcenter kdele kdist kfill kgen kl klist kmodif kmove knode kplot kpscale kscale ksum ksymm ktran source hptcreate hptdelete bsplin circle gsum l l2ang l2tan lang larc larea lcomb ldele ldiv ldrag lextnd lfillt lgen llist lplot lreverse lrotat lsscale lstr lsum lsymm ltan ltran spline ssln a aatt adele adgl adrag afillt agen al alist anorm aoffst aplot areverse arotat arscale arsym askin asub asum atran gsum splot extopt gsum v va vdele vdgl vdrag vext vgen vlist vlscale voffst vplot vrotat vsum vsymm vtran aadd aglue aina ainp ainv aovlap aptn asba asbl asbv asbw boptn btol lcsl lglue lina linl linp linv lovlap lptn lsba lsbl lsbv lsbw vadd vglue vinp vinv vovlap vptn vsba vsbv vsbw accat aclear aesize amap amesh arefine chkmsh clrmshln cpcyc desize eorient erefine esize esys fvmesh gsgdata imesh katta kclear kesize kmesh krefine kscon latt lccat lclear lesize lmesh lrefine mat mcheck modmsh mopt mshape mshcopy mshkey mshmid mshpattern nrefine psmesh real rthick shpp smrtsize tchg timp type vatt vclear vimp vmesh veorient vsweep center fill move n nang ndele ndist ngen nkpt nlist nmodif nplot nread nrotat nrrang nscale nsmooth nsym nwrite quad source transfer afsurf e edele egen eintf elist emid emodif emore emtgen en endrelease engen enorm ensym eorient eplot eread errang esurf esym esys ewrite laylist layplot lfsurf mat ndsurf real shsd swadd swdel swgen swlist tshap type upgeom se sedlist selistl sesymm setran bellow bend branch flange miter pcorro pdrag pfluid pgap pinsul popt ppres pspec psprng ptemp punit reduce run tee valve dig dmove dset dsurf cp cpdele cpintf cplgen cplist cpngen cpsgen ce cecyc cedele ceintf celist cerig cesgen rbe3 noorder waves werase wfront wmid wmore wsort wstart fldata fldata1 fldata2 fldata3 fldata4 fldata4a fldata5 fldata6 fldata7 fldata8 fldata9 fldata10 fldata11 fldata12 fldata13 fldata14 fldata15 fldata16 fldata17 fldata18 fldata19 fldata20 fldata20a fldata20b fldata21 fldata22 fldata23 fldata24 fldata24a fldata24b fldata24c fldata24d fldata24e fldata24f fldata24g fldata24h fldata40 fldata25 fldata26 fldata34 fldata27 fldata28 fldata29 fldata30 fldata31 fldata32 fldata33 fldata35 fldata36 fldata37 fldata38 fldata39 icvfrc plvfrc msadv mscap msdata msmass msmeth msmir msnomf msprop msquad msrelax mssolu msspec msterm msvary /cycexpand cyclic cycopt emsym hferefine perbc2d physics race areas bool ceqn couple digit elem etype fatigue febody fecons fefor fesurf flotran geometry keypts line mater meshing nodes pipe pmeth prim rcon reorder selm tble volumes edasmp edbound edbx edcgen edclist edcmore edcnstr edcontact edcrb edcurve eddbl eddc edipart edlcs edmp ednb edndtsd ednrot edpart edpc edsp edweld alpfill arcollapse ardetach arfill armerge arsplit gapfinish gaplist gapmerge gapopt gapplot lncollapse lndetach lnfill lnmerge lnsplit sarplot slpplot slsplot vcvfill bsax bsm1 bsm2 bsmd bss1 bss2 bste bstq prssol sdelete secdata secjoint /seclib seclock secnum secoffset secplot secread secstop sectype secwrite slist ssbt ssmt sspa sspb sspd sspe sspm morph damorph demorph dvmorph tzamesh tzdele tzegen pmlopt pmlsize fsan fsco fsdt fsin fsit fsor fsou fsre fsstat fsti fstr"+list_solution'5fcommands = Set.fromList $ words $ "abextract adams adapt antype bcsoption cecheck check cmatrix cmsopt cncheck cutcontrol cycopt dmpext dsproc dsopt ematwrite eqslv eresx escheck essolv expass fsrs fssolv gauge gmatrix hfeigopt hfpa hfpcswp hfscat hfsweep lmatrix lumpm monitor msave opncontrol precision pscontrol psolve rate rstoff seexp segen seopt solcontrol /solu solve spscan spswp staopt toffst pconv pexclude pinclude /pmeth pmopts pprange arclena arctrm bucopt cnvtol crplim /gst lnsrch mxpand ncnv neqit nldiag nldpost nlgeom nlhist nropt pred pstres sstif subopt alphad betad dmprat harfrq hrexp hropt hrout lvscale mdamp mdplot modopt mxpand rigid subopt timint tintp trnopt addam coval cqc dsum freq grp nrlsum pfact psdcom psdfrq psdgraph psdspl psdunit psdval psdwav qdval rock sed spopt srss sv svtyp vddam autots cecmod deltim expsol hmagsolv kbc kuse magopt magsolv mode nsubst numexp time tref tsres upcoord usrcal wrfull da dadele dalist dk dkdele dklist dl dldele dllist dtran fk fkdele fklist ftran sfa sfadele sfalist sfl sfldele sfllist sftran bfa bfadele bfalist bfk bfkdele bfklist bfl bfldele bfllist bftran bfv bfvdele bfvlist acel cgloc cgomga cmacel cmdomega cmomega dcgomg domega irlf omega biot fmagbc hfport ic icdele ice icedele icelist iclist isfile mpchg outpr outres pgraph pgsave pgwrite plwave rescontrol sbclist sbctran wsprings lsclear lsdele lsread lssolve lswrite m mdele mgen mlist total gp gpdele gplist rezone mapsolve remesh aremesh ealive ekill estif d dcum ddele dj djdele djlist dlist dscale dsym gsbdata gslist ldread f fcum fdele fj fjdele fjlist flist fscale sf sfbeam sfcum sfdele sfe sfedele sfelist sffun sfgrad sflist sfscale bf bfcum bfdele bfe bfecum bfedele bfelist bfescal bflist bfscale bfunif ldread rimport tunif bioopt deact dynopt gap genopt inrtia lsoper master nlopt outopt smbody smcons smfor smsurf soluopt sptopt edadapt edale edbvis edcadapt edcpu edcsc edcts eddamp eddrelax eddump edenergy edfplot edgcale edhgls edhist edhtime edint edis edload edopt edout edpl edpvel edrc edrd edri edrst edrun edshell edsolv edstart edterm edtp edvel edwrite rexport flocheck pemopts hemiopt radopt rdec rsurf rsymm spcnod spctemp stef v2dopt vfcalc vfopt qsopt fsan fsco fsdt fsin fsit fsor fsou fsre fsrs fsstat fsti fstr mfanalysis mfbucket mfcalc mfclear mfcmmand mfconv mfdtime mfelem mfem mfexter mffname mfimport mfinter mfiter mflist mfmap mforder mfoutput mfrelax mfrstart mfsurface mftime mftol mfvolume"+list_POST1'5fcommands = Set.fromList $ words $ "append detab dnsol file hrcplx pgrset /post1 reset set subset avprin avres /efacet ernorm force inres layer rsys shell nsort nusort plconv pldisp plesol plnsol plvect pplot prconv presol prjsol prnld prnsol prrfor prrsol prssol prvect sumtype desol esort etable eusort pletab plls plvect pretab prvect sabs sadd sallow sexp sfact sfcalc smax smin smult ssum tallow vcross vdot /format /header irlist /page prerr priter ancntr ancut andata andscl ancyc andyna /anfile anflow anharm anim anisos anmode anmres antime trtime padele paget paput paresu pasave path pcalc pcross pdef pdot plpagm plpath plsect pmap ppath prange prpath prsect psel pvect sucalc sucr sudel sueval suget sumap supl supr suresu susave susel suvect lcabs lcase lcdef lcfact lcfile lcoper lcsel lcsum lcwrite lczero rappnd curr2d emagerr emf emft fluxv fmagsum for2d impd mmf plf2d powerh qfact reflcoef senergy sparm torq2d torqc2d torqsum fe felist fl fllist fp fplist fs fsdele fslist fsnode fsplot fssect ftcalc ftsize ftwrite pltrac trpdel trplis trpoin flread bfint cbdof cmsfile /cycexpand cycphase /expand expand fssparm fsum hfang hfarray hfnear hfpower hfsym intsrf kcalc nforce plcrack plhffar plsch plsyz prhffar prsyz rmflvec rsplit spoint datadef define display lccalc point print sort spec fc fccheck fcdele fclist"+list_POST26'5fcommands = Set.fromList $ words $ "ansol data edread esol file gapf gssol jsol nsol nstore numvar /post26 reset rforce /rgb solu store timerange vardel varnam cfact force layerp26 shell tvar abs add atan clog conjug deriv exp filldata imagin int1 large nlog prod quot realvar small sqrt plcplx pltime plvar spread xvar extrem lines nprint prcplx prtime prvar cvar pmgtran resp rpsd smooth vget vput define operate plotting print"+list_aux2'5fcmds = Set.fromList $ words $ "/aux2 dump fileaux2 form hbmat"+list_aux3'5fcmds = Set.fromList $ words $ "/aux3 compress delete fileaux3 list modify undelete"+list_aux12'5fcmds = Set.fromList $ words $ "/aux12 emis geom mprint space stef vfquery vtype write"+list_aux15'5fcmds = Set.fromList $ words $ "/aux15 igesin ioptn"+list_runstats'5fcmds = Set.fromList $ words $ "rall rfilsz riter rmemry rspeed rstat rtimst /runst rwfrnt"+list_optimization'5fcmds = Set.fromList $ words $ "/opt opeqn opfact opfrst opgrad opkeep oploop opprnt oprand opsubp opsweep optype opuser opvar tocomp todef tofreq totype tovar opadd opclr opdel opmake opsel opanl opdata opresu opsave opexe toexe toloop oplfa oplgr oplist oplsw oprfa oprgr oprsw plvaropt prvaropt tograph tolist toplot toprint tostat xvaropt"+list_probabilistic'5fcmds = Set.fromList $ words $ "/pds pdanl pdcorr pdinqr pdplot pdvar pddoel pddmcs pdmeth pduser pdexe pdcdf pdcmat pdhist pdpinv pdprob pdropt pdscat pdsens pdshis pdwrite pdclr pdresu pdsave rsfit rsplot rsprnt rssims"+list_display'5fcmds = Set.fromList $ words $ "/cmap /devdisp filedisp helpdisp nocolor /seg /showdisp trans grph term finish plot stat"+list_reduced'5forder'5fcmds = Set.fromList $ words $ "rmresume rmsave rmndisp rmnevec rmalist rmanl rmaster rmcap rmclist rmmlist rmmrange rmmselect rmporder rmrgenerate rmroptions rmrplot rmrstatus rmsmple rmxport dcvswp rmlvscale rmuse"+list_parametric'5ffunctions = Set.fromList $ words $ "abs sign exp log log10 sqrt nint mod rand gdis sin cos tan sinh cosh tanh asin acos atan atan2 valchr chrval upcase lwcase"+list_elements = Set.fromList $ words $ "link1 plane2 beam3 beam4 solid5 combin7 link8 infin9 link10 link11 contac12 plane13 combin14 pipe16 pipe17 pipe18 pipe20 mass21 beam23 beam24 plane25 matrix27 shell28 fluid29 fluid30 link31 link32 link33 link34 plane35 sourc36 combin37 fluid38 combin39 combin40 shell41 plane42 shell43 beam44 solid45 solid46 infin47 matrix50 shell51 contac52 plane53 beam54 plane55 hyper56 shell57 hyper58 pipe59 pipe60 shell61 solid62 shell63 solid64 solid65 plane67 link68 solid69 solid70 mass71 hyper74 plane75 plane77 plane78 fluid79 fluid80 fluid81 plane82 plane83 hyper84 hyper86 solid87 visco88 visco89 solid90 shell91 solid92 shell93 circu94 solid95 solid96 solid97 solid98 shell99 visco106 visco107 visco108 trans109 infin110 infin111 inter115 fluid116 solid117 hf118 hf119 hf120 plane121 solid122 solid123 circu124 circu125 trans126 solid127 solid128 fluid129 fluid130 shell131 shell132 fluid136 fluid138 fluid139 fluid141 fluid142 shell143 rom144 plane145 plane146 solid147 solid148 shell150 surf151 surf152 surf153 surf154 shell157 hyper158 link160 beam161 plane162 shell163 solid164 combi165 mass166 link167 solid168 targe169 targe170 conta171 conta172 conta173 conta174 conta175 conta178 prets179 link180 shell181 plane182 plane183 mpc184 solid185 solid186 solid187 beam188 beam189 solsh190 solid191 inter192 inter193 inter194 inter195 mesh200 follw201 shell208 shell209 plane223 solid226 solid227 plane230 solid231 solid232 surf251 surf252"+list_material'5fproperties = Set.fromList $ words $ "ex ey ez gxy nuxy alpx alpy alpz ctex ctey ctez thsx thsy thsz reft prxy pryz prxz nuxy nuyz nuxz gxy gyz gxz damp dmpr mu dens c enth kxx kyy kzz hf emis qrate visc sonc rsvx rsvy rsvz perx murx mury murz mgxx mgyy mgzz lsst sbkx"+list_force'2ddisplacement'2dlabels = Set.fromList $ words $ "ux uy uz fx fy fz mx my mz heat hbot he2 he3 htop flow amps chrg csgx csgy csgz rotx roty rotz warp temp tbot te2 te3 ttop pres vx vy vz enke ends sp01 sp02 sp03 sp04 sp05 sp06 volt mag ax ayaz"+list_antype'5fflag = Set.fromList $ words $ "static buckle modal harmic trans substr spectr"+list_various'5flabels = Set.fromList $ words $ "nx ny nz"++regex_'5bA'2dZa'2dZ0'2d9'5d'2b'5c'3d = compileRegex "[A-Za-Z0-9]+\\="++defaultAttributes = [("Normal Text","Normal Text"),("doublequotestring","String"),("functions","Normal Text"),("open_parentesis","parentesis_not_closed"),("comment","comment"),("functions_arg","NumFloat")]++parseRules "Normal Text" = +  do (attr, result) <- (((pFirstNonSpace >> pString False "C***" >>= withAttribute "comment") >>~ pushContext "comment")+                        <|>+                        ((pDetectChar False '!' >>= withAttribute "comment") >>~ pushContext "comment")+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&;?[]^{|}~\\" list_various'5flabels >>= withAttribute "MatProp"))+                        <|>+                        ((pRangeDetect '(' ')' >>= withAttribute "Normal Text"))+                        <|>+                        ((pDetectChar False '(' >>= withAttribute "error") >>~ pushContext "open_parentesis")+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bA'2dZa'2dZ0'2d9'5d'2b'5c'3d >>= withAttribute "Normal Text"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&;?[]^{|}~\\" list_elements >>= withAttribute "Keyword"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&;?[]^{|}~\\" list_material'5fproperties >>= withAttribute "MatProp"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&;?[]^{|}~\\" list_force'2ddisplacement'2dlabels >>= withAttribute "Labels"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&;?[]^{|}~\\" list_antype'5fflag >>= withAttribute "Labels"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&;?[]^{|}~\\" list_parametric'5ffunctions >>= withAttribute "Commands"))+                        <|>+                        ((pFirstNonSpace >> pKeyword " \n\t.():!+,-<=>%&;?[]^{|}~\\" list_session'5fcmds >>= withAttribute "SESSIONcmd"))+                        <|>+                        ((pFirstNonSpace >> pKeyword " \n\t.():!+,-<=>%&;?[]^{|}~\\" list_database'5fcmds >>= withAttribute "DBcmd"))+                        <|>+                        ((pFirstNonSpace >> pKeyword " \n\t.():!+,-<=>%&;?[]^{|}~\\" list_graphic'5fcmds >>= withAttribute "GRPH_cmds"))+                        <|>+                        ((pFirstNonSpace >> pKeyword " \n\t.():!+,-<=>%&;?[]^{|}~\\" list_APDL'5fcommands >>= withAttribute "APDLcmd"))+                        <|>+                        ((pFirstNonSpace >> pKeyword " \n\t.():!+,-<=>%&;?[]^{|}~\\" list_prep7'5fcommands >>= withAttribute "PREP7Commands"))+                        <|>+                        ((pFirstNonSpace >> pKeyword " \n\t.():!+,-<=>%&;?[]^{|}~\\" list_solution'5fcommands >>= withAttribute "SOLUCommands"))+                        <|>+                        ((pFirstNonSpace >> pKeyword " \n\t.():!+,-<=>%&;?[]^{|}~\\" list_POST1'5fcommands >>= withAttribute "POST1Commands"))+                        <|>+                        ((pFirstNonSpace >> pKeyword " \n\t.():!+,-<=>%&;?[]^{|}~\\" list_POST26'5fcommands >>= withAttribute "POST26Commands"))+                        <|>+                        ((pFirstNonSpace >> pKeyword " \n\t.():!+,-<=>%&;?[]^{|}~\\" list_aux2'5fcmds >>= withAttribute "AUX2cmds"))+                        <|>+                        ((pFirstNonSpace >> pKeyword " \n\t.():!+,-<=>%&;?[]^{|}~\\" list_aux3'5fcmds >>= withAttribute "AUX3cmds"))+                        <|>+                        ((pFirstNonSpace >> pKeyword " \n\t.():!+,-<=>%&;?[]^{|}~\\" list_aux12'5fcmds >>= withAttribute "AUX12cmds"))+                        <|>+                        ((pFirstNonSpace >> pKeyword " \n\t.():!+,-<=>%&;?[]^{|}~\\" list_aux15'5fcmds >>= withAttribute "AUX15cmds"))+                        <|>+                        ((pFirstNonSpace >> pKeyword " \n\t.():!+,-<=>%&;?[]^{|}~\\" list_runstats'5fcmds >>= withAttribute "RUNSTATScmds"))+                        <|>+                        ((pFirstNonSpace >> pKeyword " \n\t.():!+,-<=>%&;?[]^{|}~\\" list_optimization'5fcmds >>= withAttribute "OPTIMIZATIONcmds"))+                        <|>+                        ((pFirstNonSpace >> pKeyword " \n\t.():!+,-<=>%&;?[]^{|}~\\" list_probabilistic'5fcmds >>= withAttribute "PROBcmds"))+                        <|>+                        ((pFirstNonSpace >> pKeyword " \n\t.():!+,-<=>%&;?[]^{|}~\\" list_display'5fcmds >>= withAttribute "DISPLAYcmds"))+                        <|>+                        ((pFirstNonSpace >> pKeyword " \n\t.():!+,-<=>%&;?[]^{|}~\\" list_reduced'5forder'5fcmds >>= withAttribute "REDUORDERcmds"))+                        <|>+                        ((pDetectChar False '"' >>= withAttribute "String") >>~ pushContext "doublequotestring")+                        <|>+                        ((pRangeDetect '\'' '\'' >>= withAttribute "String"))+                        <|>+                        ((pRangeDetect '%' '%' >>= withAttribute "variable"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&;?[]^{|}~\\" list_APDL'5fcommands >>= withAttribute "MatProp"))+                        <|>+                        ((pFloat >>= withAttribute "NumFloat"))+                        <|>+                        (withChildren (pInt >>= withAttribute "NumInt") ((pString False "**" >>= withAttribute "NumInt"))))+     return (attr, result)++parseRules "doublequotestring" = +  do (attr, result) <- ((pDetectChar False '"' >>= withAttribute "String") >>~ (popContext))+     return (attr, result)++parseRules "functions" = +  do (attr, result) <- (((pRangeDetect '(' ')' >>= withAttribute "Normal Text") >>~ (popContext))+                        <|>+                        ((pDetectChar False '(' >>= withAttribute "error") >>~ pushContext "open_parentesis"))+     return (attr, result)++parseRules "open_parentesis" = +  do (attr, result) <- ((pDetectChar False ')' >>= withAttribute "Normal Text") >>~ (popContext))+     return (attr, result)++parseRules "comment" = +  pzero++parseRules "functions_arg" = +  do (attr, result) <- (((pDetectChar False '(' >>= withAttribute "Keyword"))+                        <|>+                        ((pDetectChar False ')' >>= withAttribute "Keyword") >>~ (popContext)))+     return (attr, result)++parseRules x = fail $ "Unknown context" ++ x

@@ -0,0 +1,157 @@+{- This module was generated from data in the Kate syntax highlighting file apache.xml, version 1.11,+   by  Jan Janssen (medhefgo@googlemail.com) -}++module Text.Highlighting.Kate.Syntax.Apache ( highlight, parseExpression, syntaxName, syntaxExtensions ) where+import Text.Highlighting.Kate.Definitions+import Text.Highlighting.Kate.Common+import qualified Text.Highlighting.Kate.Syntax.Alert+import Text.ParserCombinators.Parsec+import Control.Monad (when)+import Data.Map (fromList)+import Data.Maybe (fromMaybe, maybeToList)++import qualified Data.Set as Set+-- | Full name of language.+syntaxName :: String+syntaxName = "Apache Configuration"++-- | Filename extensions for this language.+syntaxExtensions :: String+syntaxExtensions = "httpd.conf;httpd2.conf;apache.conf;apache2.conf;.htaccess*;.htpasswd*"++-- | Highlight source code using this syntax definition.+highlight :: String -> Either String [SourceLine]+highlight input =+  case runParser parseSource startingState "source" input of+    Left err     -> Left $ show err+    Right result -> Right result++-- | Parse an expression using appropriate local context.+parseExpression :: GenParser Char SyntaxState LabeledSource+parseExpression = do+  st <- getState+  let oldLang = synStLanguage st+  setState $ st { synStLanguage = "Apache Configuration" }+  context <- currentContext <|> (pushContext "apache" >> 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 [("Apache Configuration",["apache"])], synStLanguage = "Apache Configuration", synStCurrentLine = "", synStCharsParsedInLine = 0, synStPrevChar = '\n', synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}++parseSourceLine = manyTill parseExpressionInternal pEndLine++pEndLine = do+  lookAhead $ newline <|> (eof >> return '\n')+  context <- currentContext+  case context of+    "apache" -> return () >> pHandleEndLine+    "String Directives" -> (popContext) >> pEndLine+    "Integer Directives" -> (popContext) >> pEndLine+    "Alternative Directives" -> (popContext) >> pEndLine+    "Comment" -> (popContext) >> pEndLine+    "Container Open" -> (popContext) >> pEndLine+    "Container Close" -> (popContext) >> pEndLine+    "Comment Alert" -> (popContext) >> pEndLine+    "Alert" -> (popContext) >> pEndLine+    _ -> pHandleEndLine++withAttribute attr txt = do+  when (null txt) $ fail "Parser matched no text"+  let labs = attr : maybeToList (lookup attr styles)+  st <- getState+  let oldCharsParsed = synStCharsParsedInLine st+  let prevchar = if null txt then '\n' else last txt+  updateState $ \st -> st { synStCharsParsedInLine = oldCharsParsed + length txt, synStPrevChar = prevchar } +  return (labs, txt)++styles = [("Comment","co"),("Directives","ot"),("String","st"),("Float","fl"),("Int","fl"),("Alternates","kw"),("Alert","er"),("Container","fu"),("Attribute","ot"),("Other","ch")]++parseExpressionInternal = do+  context <- currentContext+  parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes))++list_String_Directives = Set.fromList $ words $ "acceptfilter accessfilename action addalt addaltbyencoding addaltbytype addcharset adddefaultcharset adddescription addencoding addhandler addicon addiconbyencoding addiconbytype addinputfilter addlanguage addmoduleinfo addoutputfilter addoutputfilterbytype addtype alias aliasmatch allow anonymous authbasicprovider authdbmgroupfile authdbmuserfile authdigestdomain authdigestfile authdigestgroupfile authdigestnonceformat authdigestprovider authgroupfile authldapbinddn authldapbindpassword authldapcharsetconfig authldapgroupattribute authldapurl authname authuserfile browsermatch browsermatchnocase bs2000account cachedisable cacheenable cachefile cachegcclean cachegcunused cacheroot cgimapextension charsetdefault charsetoptions charsetsourceenc cookiedomain cookielog cookiename coredumpdirectory customlog dav davgenericlockdb davlockdb dbdparams dbdpreparesql dbdriver defaulticon defaultlanguage defaulttype deflatefilternote deny directoryindex documentroot errordocument errorlog example expiresbytype expiresdefault extfilterdefine extfilteroptions filterchain filterdeclare filterprotocol filterprovider filtertrace forcetype forensiclog group header headername imapbase include indexignore indexoptions indexstylesheet isapicachefile languagepriority ldapsharedcachefile ldaptrustedca ldaptrustedcatype ldaptrustedclientcert ldaptrustedglobalcert listen loadfile loadmodule lockfile logformat metadir metasuffix mimemagicfile mmapfile namevirtualhost noproxy nwssltrustedcerts nwsslupgradeable passenv pidfile proxyblock proxydomain proxypass proxypassreverse proxypassreversecookiedomain proxypassreversecookiepath proxyremote proxyremotematch readmename redirect redirectmatch redirectpermanent redirecttemp removecharset removeencoding removehandler removeinputfilter removelanguage removeoutputfilter removetype requestheader require rewritebase rewritecond rewritelock rewritelog rewritemap rewriterule scoreboardfile script scriptalias scriptaliasmatch scriptlog scriptsock securelisten serveradmin serveralias servername serverpath serverroot setenv setenvif setenvifnocase sethandler setinputfilter setoutputfilter ssiendtag ssierrormsg ssistarttag ssitimeformat ssiundefinedecho sslcacertificatefile sslcacertificatepath sslcadnrequestfile sslcadnrequestpath sslcarevocationfile sslcarevocationpath sslcertificatechainfile sslcertificatefile sslcertificatekeyfile sslciphersuite sslcryptodevice sslhonorciperorder sslpassphrasedialog sslproxycacertificatefile sslproxycacertificatepath sslproxycarevocationfile sslproxycarevocationpath sslproxyciphersuite sslproxymachinecertificatefile sslproxymachinecertificatepath sslproxyprotocol sslrandomseed sslrequire sslrequiressl sslusername suexecusergroup transferlog typesconfig unsetenv user userdir virtualdocumentroot virtualdocumentrootip virtualscriptalias virtualscriptaliasip win32disableacceptex"+list_Integer_Directives = Set.fromList $ words $ "allowconnect assignuserid authdigestnoncelifetime authdigestshmemsize cachedefaultexpire cachedirlength cachedirlevels cacheforcecompletion cachegcdaily cachegcinterval cachegcmemusage cachelastmodifiedfactor cachemaxexpire cachemaxfilesize cacheminfilesize cachesize cachetimemargin childperuserid cookieexpires davmintimeout dbdexptime dbdkeep dbdmax dbdmin dbdpersist deflatebuffersize deflatecompressionlevel deflatememlevel deflatewindowsize identitychecktimeout isapireadaheadbuffer keepalivetimeout ldapcacheentries ldapcachettl ldapconnectiontimeout ldapopcacheentries ldapopcachettl ldapsharedcachesize limitinternalrecursion limitrequestbody limitrequestfields limitrequestfieldsize limitrequestline limitxmlrequestbody listenbacklog maxclients maxkeepaliverequests maxmemfree maxrequestsperchild maxrequestsperthread maxspareservers maxsparethreads maxthreads maxthreadsperchild mcachemaxobjectcount mcachemaxobjectsize mcachemaxstreamingbuffer mcacheminobjectsize mcachesize minspareservers minsparethreads numservers proxyiobuffersize proxymaxforwards proxyreceivebuffersize proxytimeout rewriteloglevel rlimitcpu rlimitmem rlimitnproc scriptlogbuffer scriptloglength sendbuffersize serverlimit sslproxyverifydepth sslsessioncachetimeout sslverifydepth startservers startthreads threadlimit threadsperchild threadstacksize timeout"+list_Alternative_Directives = Set.fromList $ words $ "acceptmutex acceptpathinfo allowencodedslashes allowoverride anonymous_authoritative anonymous_logemail anonymous_mustgiveemail anonymous_nouserid anonymous_verifyemail authauthoritative authbasicauthoritative authbasicprovider authdbmauthoritative authdbmtype authdefaultauthoritative authdigestalgorithm authdigestnccheck authdigestqop authldapauthoritative authldapcomparednonserver authldapdereferencealiases authldapenabled authldapfrontpagehack authldapgroupattributeisdn authldapremoteuserisdn authtype authzdbmauthoritative authzdbmtype authzdefaultauthoritative authzgroupfileauthoritative authzldapauthoritative authzownerauthoritative authzuserauthoritative bufferedlogs cacheexpirycheck cacheignorecachecontrol cacheignoreheaders cacheignorenolastmod cachenegotiateddocs cachestorenostore cachestoreprivate checkspelling contentdigest cookiestyle cookietracking coredumpdirectory customlog davdepthinfinity directoryslash dumpioinput dumpiooutput enableexceptionhook enablemmap enablesendfile expiresactive extendedstatus fileetag forcelanguagepriority hostnamelookups identitycheck imapdefault imapmenu indexorderdefault isapiappendlogtoerrors isapiappendlogtoquery isapifakeasync isapilognotsupported keepalive ldaptrustedmode ldapverifyservercert loglevel mcacheremovalalgorithm metafiles modmimeusepathinfo multiviewsmatch options order protocolecho proxybadheader proxyerroroverride proxypreservehost proxyrequests proxyvia rewriteengine rewriteoptions satisfy scriptinterpretersource serversignature servertokens sslengine sslmutex ssloptions sslprotocol sslproxyengine sslproxyverify sslsessioncache sslverifyclient usecanonicalname xbithack"+list_Alternates = Set.fromList $ words $ "on off default flock fcntl posixsem pthread sysvsem all none authconfig fileinfo indexes limit options execcgi followsymlinks includes includesnoexec indexes multiviews symlinksifownermatch stdenvvars compatenvvars exportcertdata fakebasicauth strictrequire optrenegotiate sdbm gdbm ndbm db md5 md5-sess auth auth-int never searching finding always basic digest connection keep-alive proxy-authenticate proxy-authorization te trailers transfer-encoding upgrade netscape cookie cookie2 rfc2109 rfc2965 inode mtime size prefer fallback double error nocontent map referer formatted semiformatted unformatted ascending descending name date size description ssl tls starttls emerg alert crit error warn notice info debug lru gdsf any negotiatedonly filters handlers deny,allow allow,deny mutual-failure iserror ignore startbody full block inherit registry registry-strict script email major minor min minimal prod productonly os full optional posixsem sysvsem sem pthread fcntl: flock: file: yes no sslv2 sslv3 tlsv1 require optional_no_ca nonenotnull dbm: shm: dc: dns"++regex_'3c'5cw'2b = compileRegex "<\\w+"+regex_'3c'2f'5cw'2b = compileRegex "</\\w+"+regex_'5b'5e'23'5d'2a = compileRegex "[^#]*"+regex_'5b'5e'23'3e'5d'2a = compileRegex "[^#>]*"++defaultAttributes = [("apache","Normal Text"),("String Directives","Directives"),("Integer Directives","Other"),("Alternative Directives","Other"),("Comment","Comment"),("Container Open","Container"),("Container Close","Container"),("Comment Alert","Normal Text"),("Alert","Alert")]++parseRules "apache" = +  do (attr, result) <- (((pKeyword " \n\t.():!+-<=>%&*/;?[]^{|}~\\" list_String_Directives >>= withAttribute "Normal Text") >>~ pushContext "String Directives")+                        <|>+                        ((pKeyword " \n\t.():!+-<=>%&*/;?[]^{|}~\\" list_Integer_Directives >>= withAttribute "Directives") >>~ pushContext "Integer Directives")+                        <|>+                        ((pKeyword " \n\t.():!+-<=>%&*/;?[]^{|}~\\" list_Alternative_Directives >>= withAttribute "Directives") >>~ pushContext "Alternative Directives")+                        <|>+                        ((pRegExpr regex_'3c'5cw'2b >>= withAttribute "Container") >>~ pushContext "Container Open")+                        <|>+                        ((pRegExpr regex_'3c'2f'5cw'2b >>= withAttribute "Container") >>~ pushContext "Container Close")+                        <|>+                        ((pFirstNonSpace >> pDetectChar False '#' >>= withAttribute "Comment") >>~ pushContext "Comment"))+     return (attr, result)++parseRules "String Directives" = +  do (attr, result) <- (((pRegExpr regex_'5b'5e'23'5d'2a >>= withAttribute "String"))+                        <|>+                        ((parseRules "Comment Alert")))+     return (attr, result)++parseRules "Integer Directives" = +  do (attr, result) <- (((pFloat >>= withAttribute "Float") >>~ pushContext "Integer Directives")+                        <|>+                        ((pInt >>= withAttribute "Int") >>~ pushContext "Integer Directives")+                        <|>+                        ((parseRules "Comment Alert")))+     return (attr, result)++parseRules "Alternative Directives" = +  do (attr, result) <- (((pKeyword " \n\t.():!+-<=>%&*/;?[]^{|}~\\" list_Alternates >>= withAttribute "Alternates"))+                        <|>+                        ((pDetectChar False '-' >>= withAttribute "Alternates"))+                        <|>+                        ((pDetectChar False '+' >>= withAttribute "Alternates"))+                        <|>+                        ((parseRules "Comment Alert")))+     return (attr, result)++parseRules "Comment" = +  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Comment"))+                        <|>+                        ((Text.Highlighting.Kate.Syntax.Alert.parseExpression))+                        <|>+                        ((pDetectIdentifier >>= withAttribute "Comment")))+     return (attr, result)++parseRules "Container Open" = +  do (attr, result) <- (((pDetectChar False '>' >>= withAttribute "Container") >>~ pushContext "Alert")+                        <|>+                        ((pRegExpr regex_'5b'5e'23'3e'5d'2a >>= withAttribute "Attribute"))+                        <|>+                        ((parseRules "Comment Alert")))+     return (attr, result)++parseRules "Container Close" = +  do (attr, result) <- ((pDetectChar False '>' >>= withAttribute "Container") >>~ pushContext "Alert")+     return (attr, result)++parseRules "Comment Alert" = +  do (attr, result) <- ((pDetectChar False '#' >>= withAttribute "Alert") >>~ pushContext "Alert")+     return (attr, result)++parseRules "Alert" = +  pzero++parseRules x = fail $ "Unknown context" ++ x

@@ -0,0 +1,89 @@+{- This module was generated from data in the Kate syntax highlighting file asn1.xml, version 1.00,+   by  Philippe Rigault -}++module Text.Highlighting.Kate.Syntax.Asn1 ( highlight, parseExpression, syntaxName, syntaxExtensions ) where+import Text.Highlighting.Kate.Definitions+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 = "ASN.1"++-- | Filename extensions for this language.+syntaxExtensions :: String+syntaxExtensions = "*.asn*.asn1"++-- | Highlight source code using this syntax definition.+highlight :: String -> Either String [SourceLine]+highlight input =+  case runParser parseSource startingState "source" input of+    Left err     -> Left $ show err+    Right result -> Right result++-- | Parse an expression using appropriate local context.+parseExpression :: GenParser Char SyntaxState LabeledSource+parseExpression = do+  st <- getState+  let oldLang = synStLanguage st+  setState $ st { synStLanguage = "ASN.1" }+  context <- currentContext <|> (pushContext "Normal Text" >> 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 [("ASN.1",["Normal Text"])], synStLanguage = "ASN.1", synStCurrentLine = "", synStCharsParsedInLine = 0, synStPrevChar = '\n', synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}++parseSourceLine = manyTill parseExpressionInternal pEndLine++pEndLine = do+  lookAhead $ newline <|> (eof >> return '\n')+  context <- currentContext+  case context of+    "Normal Text" -> return () >> pHandleEndLine+    "Comment" -> (popContext) >> pEndLine+    _ -> pHandleEndLine++withAttribute attr txt = do+  when (null txt) $ fail "Parser matched no text"+  let labs = attr : maybeToList (lookup attr styles)+  st <- getState+  let oldCharsParsed = synStCharsParsedInLine st+  let prevchar = if null txt then '\n' else last txt+  updateState $ \st -> st { synStCharsParsedInLine = oldCharsParsed + length txt, synStPrevChar = prevchar } +  return (labs, txt)++styles = [("Keyword","kw"),("Comment","co"),("Data Type","dt")]++parseExpressionInternal = do+  context <- currentContext+  parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes))++list_keywords = Set.fromList $ words $ "DEFINITIONS BEGIN END EXPORTS IMPORTS FROM APPLICATION PRIVATE UNIVERSAL DEFAULT OPTIONAL FALSE TRUE"+list_types = Set.fromList $ words $ "BOOLEAN INTEGER OCTET STRING NULL REAL ENUMERATED SEQUENCE SET CHOICE OF VisibleString StringStore"+++defaultAttributes = [("Normal Text","Normal Text"),("Comment","Comment")]++parseRules "Normal Text" = +  do (attr, result) <- (((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_keywords >>= withAttribute "Keyword"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_types >>= withAttribute "Data Type"))+                        <|>+                        ((pDetect2Chars False '-' '-' >>= withAttribute "Comment") >>~ pushContext "Comment"))+     return (attr, result)++parseRules "Comment" = +  pzero++parseRules x = fail $ "Unknown context" ++ x

@@ -47,25 +47,23 @@ parseSourceLine = manyTill parseExpressionInternal pEndLine  pEndLine = do-  newline <|> (eof >> return '\n')+  lookAhead $ newline <|> (eof >> return '\n')   context <- currentContext   case context of-    "nosource" -> return ()-    "aspsource" -> return ()-    "asp_onelinecomment" -> (popContext >> return ())-    "doublequotestring" -> return ()-    "singlequotestring" -> return ()-    "htmltag" -> return ()-    "htmlcomment" -> return ()-    "identifiers" -> return ()-    "types1" -> return ()-    "types2" -> return ()-    "scripts" -> return ()-    "scripts_onelinecomment" -> (popContext >> return ())-    "twolinecomment" -> return ()-    _ -> return ()-  lineContents <- lookAhead wholeLine-  updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }+    "nosource" -> return () >> pHandleEndLine+    "aspsource" -> return () >> pHandleEndLine+    "asp_onelinecomment" -> (popContext) >> pEndLine+    "doublequotestring" -> return () >> pHandleEndLine+    "singlequotestring" -> return () >> pHandleEndLine+    "htmltag" -> return () >> pHandleEndLine+    "htmlcomment" -> return () >> pHandleEndLine+    "identifiers" -> return () >> pHandleEndLine+    "types1" -> return () >> pHandleEndLine+    "types2" -> return () >> pHandleEndLine+    "scripts" -> return () >> pHandleEndLine+    "scripts_onelinecomment" -> (popContext) >> pEndLine+    "twolinecomment" -> return () >> pHandleEndLine+    _ -> pHandleEndLine  withAttribute attr txt = do   when (null txt) $ fail "Parser matched no text"@@ -135,9 +133,9 @@      return (attr, result)  parseRules "aspsource" = -  do (attr, result) <- (((pString False "%>" >>= withAttribute "Keyword") >>~ (popContext >> return ()))+  do (attr, result) <- (((pString False "%>" >>= withAttribute "Keyword") >>~ (popContext))                         <|>-                        ((pRegExpr regex_'3c'5cs'2a'5c'2f'5cs'2ascript'5cs'2a'3e >>= withAttribute "HTML Tag") >>~ (popContext >> return ()))+                        ((pRegExpr regex_'3c'5cs'2a'5c'2f'5cs'2ascript'5cs'2a'3e >>= withAttribute "HTML Tag") >>~ (popContext))                         <|>                         ((pDetectChar False '\'' >>= withAttribute "Comment") >>~ pushContext "asp_onelinecomment")                         <|>@@ -217,7 +215,7 @@      return (attr, result)  parseRules "asp_onelinecomment" = -  do (attr, result) <- ((pString False "%>" >>= withAttribute "Keyword") >>~ (popContext >> popContext >> return ()))+  do (attr, result) <- ((pString False "%>" >>= withAttribute "Keyword") >>~ (popContext >> popContext))      return (attr, result)  parseRules "doublequotestring" = @@ -227,19 +225,19 @@                         <|>                         ((pRegExpr regex_'5c'5cx'5b0'2d9A'2dFa'2df'5d'7b1'2c2'7d >>= withAttribute "Escape Code"))                         <|>-                        ((pDetectChar False '"' >>= withAttribute "String") >>~ (popContext >> return ())))+                        ((pDetectChar False '"' >>= withAttribute "String") >>~ (popContext)))      return (attr, result)  parseRules "singlequotestring" =    do (attr, result) <- (((pDetect2Chars False '\'' '\'' >>= withAttribute "Escape Code"))                         <|>-                        ((pDetectChar False '\'' >>= withAttribute "String") >>~ (popContext >> return ())))+                        ((pDetectChar False '\'' >>= withAttribute "String") >>~ (popContext)))      return (attr, result)  parseRules "htmltag" = -  do (attr, result) <- (((pDetect2Chars False '/' '>' >>= withAttribute "HTML Tag") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetect2Chars False '/' '>' >>= withAttribute "HTML Tag") >>~ (popContext))                         <|>-                        ((pDetectChar False '>' >>= withAttribute "HTML Tag") >>~ (popContext >> return ()))+                        ((pDetectChar False '>' >>= withAttribute "HTML Tag") >>~ (popContext))                         <|>                         ((pString False "<%" >>= withAttribute "Keyword") >>~ pushContext "aspsource")                         <|>@@ -253,13 +251,13 @@                         <|>                         ((pString False "<%" >>= withAttribute "Keyword") >>~ pushContext "aspsource")                         <|>-                        ((pString False "-->" >>= withAttribute "HTML Comment") >>~ (popContext >> return ()))+                        ((pString False "-->" >>= withAttribute "HTML Comment") >>~ (popContext))                         <|>                         ((pRegExpr regex_'5cs'2a'3d'5cs'2a >>= withAttribute "Normal Text") >>~ pushContext "identifiers"))      return (attr, result)  parseRules "identifiers" = -  do (attr, result) <- (((pRegExpr regex_'5cs'2a'23'3f'5ba'2dzA'2dZ0'2d9'5d'2a >>= withAttribute "String") >>~ (popContext >> return ()))+  do (attr, result) <- (((pRegExpr regex_'5cs'2a'23'3f'5ba'2dzA'2dZ0'2d9'5d'2a >>= withAttribute "String") >>~ (popContext))                         <|>                         ((pDetectChar False '\'' >>= withAttribute "Types") >>~ pushContext "types1")                         <|>@@ -271,7 +269,7 @@                         <|>                         ((pString False "<%" >>= withAttribute "Keyword") >>~ pushContext "aspsource")                         <|>-                        ((pDetectChar False '\'' >>= withAttribute "Types") >>~ (popContext >> popContext >> return ())))+                        ((pDetectChar False '\'' >>= withAttribute "Types") >>~ (popContext >> popContext)))      return (attr, result)  parseRules "types2" = @@ -279,7 +277,7 @@                         <|>                         ((pString False "<%" >>= withAttribute "Keyword") >>~ pushContext "aspsource")                         <|>-                        ((pDetectChar False '"' >>= withAttribute "Types") >>~ (popContext >> popContext >> return ())))+                        ((pDetectChar False '"' >>= withAttribute "Types") >>~ (popContext >> popContext)))      return (attr, result)  parseRules "scripts" = @@ -295,7 +293,7 @@                         <|>                         ((pString False "<%" >>= withAttribute "Keyword") >>~ pushContext "aspsource")                         <|>-                        ((pRegExpr regex_'3c'5cs'2a'5c'2f'5cs'2ascript'5cs'2a'3e >>= withAttribute "HTML Tag") >>~ (popContext >> return ()))+                        ((pRegExpr regex_'3c'5cs'2a'5c'2f'5cs'2ascript'5cs'2a'3e >>= withAttribute "HTML Tag") >>~ (popContext))                         <|>                         ((pDetectChar False '"' >>= withAttribute "String") >>~ pushContext "doublequotestring")                         <|>@@ -319,11 +317,11 @@      return (attr, result)  parseRules "scripts_onelinecomment" = -  do (attr, result) <- ((pRegExpr regex_'3c'5cs'2a'5c'2f'5cs'2ascript'5cs'2a'3e >>= withAttribute "HTML Tag") >>~ (popContext >> popContext >> return ()))+  do (attr, result) <- ((pRegExpr regex_'3c'5cs'2a'5c'2f'5cs'2ascript'5cs'2a'3e >>= withAttribute "HTML Tag") >>~ (popContext >> popContext))      return (attr, result)  parseRules "twolinecomment" = -  do (attr, result) <- ((pDetect2Chars False '*' '/' >>= withAttribute "Comment") >>~ (popContext >> return ()))+  do (attr, result) <- ((pDetect2Chars False '*' '/' >>= withAttribute "Comment") >>~ (popContext))      return (attr, result)  parseRules x = fail $ "Unknown context" ++ x

@@ -48,15 +48,13 @@ parseSourceLine = manyTill parseExpressionInternal pEndLine  pEndLine = do-  newline <|> (eof >> return '\n')+  lookAhead $ newline <|> (eof >> return '\n')   context <- currentContext   case context of-    "Base" -> return ()-    "String" -> return ()-    "Comment" -> (popContext >> return ())-    _ -> return ()-  lineContents <- lookAhead wholeLine-  updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }+    "Base" -> return () >> pHandleEndLine+    "String" -> return () >> pHandleEndLine+    "Comment" -> (popContext) >> pEndLine+    _ -> pHandleEndLine  withAttribute attr txt = do   when (null txt) $ fail "Parser matched no text"@@ -110,7 +108,7 @@      return (attr, result)  parseRules "String" = -  do (attr, result) <- (((pDetectChar False '"' >>= withAttribute "String") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetectChar False '"' >>= withAttribute "String") >>~ (popContext))                         <|>                         ((pHlCStringChar >>= withAttribute "String")))      return (attr, result)

@@ -1,4 +1,4 @@-{- This module was generated from data in the Kate syntax highlighting file bash.xml, version 2.11,+{- This module was generated from data in the Kate syntax highlighting file bash.xml, version 2.12,    by  Wilbert Berendsen (wilbert@kde.nl) -}  module Text.Highlighting.Kate.Syntax.Bash ( highlight, parseExpression, syntaxName, syntaxExtensions ) where@@ -48,61 +48,59 @@ parseSourceLine = manyTill parseExpressionInternal pEndLine  pEndLine = do-  newline <|> (eof >> return '\n')+  lookAhead $ newline <|> (eof >> return '\n')   context <- currentContext   case context of-    "Start" -> return ()-    "FindAll" -> return ()-    "FindMost" -> return ()-    "FindComments" -> (popContext >> return ())-    "Comment" -> (popContext >> return ())-    "FindCommentsParen" -> (popContext >> return ())-    "CommentParen" -> (popContext >> return ())-    "FindCommentsBackq" -> (popContext >> return ())-    "CommentBackq" -> (popContext >> return ())-    "FindCommands" -> return ()-    "FindOthers" -> return ()-    "FindStrings" -> return ()-    "FindSubstitutions" -> return ()-    "FindTests" -> return ()-    "ExprDblParen" -> return ()-    "ExprDblParenSubst" -> return ()-    "ExprSubParen" -> return ()-    "ExprBracket" -> return ()-    "ExprDblBracket" -> return ()-    "Group" -> return ()-    "SubShell" -> return ()-    "Assign" -> (popContext >> return ())-    "AssignArray" -> (popContext >> return ())-    "AssignSubscr" -> (popContext >> return ())-    "Subscript" -> return ()-    "FunctionDef" -> (popContext >> return ())-    "VarName" -> (popContext >> return ())-    "ProcessSubst" -> return ()-    "StringSQ" -> return ()-    "StringDQ" -> return ()-    "StringEsc" -> return ()-    "VarBrace" -> return ()-    "VarAlt" -> return ()-    "VarSubst" -> return ()-    "VarSubst2" -> return ()-    "VarSub" -> return ()-    "VarSub2" -> return ()-    "SubstFile" -> return ()-    "SubstCommand" -> return ()-    "SubstBackq" -> return ()-    "Case" -> return ()-    "CaseIn" -> return ()-    "CaseExpr" -> return ()-    "HereDoc" -> return ()-    "HereDocRemainder" -> (popContext >> return ())-    "HereDocQ" -> return ()-    "HereDocNQ" -> return ()-    "HereDocIQ" -> return ()-    "HereDocINQ" -> return ()-    _ -> return ()-  lineContents <- lookAhead wholeLine-  updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }+    "Start" -> return () >> pHandleEndLine+    "FindAll" -> return () >> pHandleEndLine+    "FindMost" -> return () >> pHandleEndLine+    "FindComments" -> (popContext) >> pEndLine+    "Comment" -> (popContext) >> pEndLine+    "FindCommentsParen" -> (popContext) >> pEndLine+    "CommentParen" -> (popContext) >> pEndLine+    "FindCommentsBackq" -> (popContext) >> pEndLine+    "CommentBackq" -> (popContext) >> pEndLine+    "FindCommands" -> return () >> pHandleEndLine+    "FindOthers" -> return () >> pHandleEndLine+    "FindStrings" -> return () >> pHandleEndLine+    "FindSubstitutions" -> return () >> pHandleEndLine+    "FindTests" -> return () >> pHandleEndLine+    "ExprDblParen" -> return () >> pHandleEndLine+    "ExprDblParenSubst" -> return () >> pHandleEndLine+    "ExprSubParen" -> return () >> pHandleEndLine+    "ExprBracket" -> return () >> pHandleEndLine+    "ExprDblBracket" -> return () >> pHandleEndLine+    "Group" -> return () >> pHandleEndLine+    "SubShell" -> return () >> pHandleEndLine+    "Assign" -> (popContext) >> pEndLine+    "AssignArray" -> (popContext) >> pEndLine+    "AssignSubscr" -> (popContext) >> pEndLine+    "Subscript" -> return () >> pHandleEndLine+    "FunctionDef" -> (popContext) >> pEndLine+    "VarName" -> (popContext) >> pEndLine+    "ProcessSubst" -> return () >> pHandleEndLine+    "StringSQ" -> return () >> pHandleEndLine+    "StringDQ" -> return () >> pHandleEndLine+    "StringEsc" -> return () >> pHandleEndLine+    "VarBrace" -> return () >> pHandleEndLine+    "VarAlt" -> return () >> pHandleEndLine+    "VarSubst" -> return () >> pHandleEndLine+    "VarSubst2" -> return () >> pHandleEndLine+    "VarSub" -> return () >> pHandleEndLine+    "VarSub2" -> return () >> pHandleEndLine+    "SubstFile" -> return () >> pHandleEndLine+    "SubstCommand" -> return () >> pHandleEndLine+    "SubstBackq" -> return () >> pHandleEndLine+    "Case" -> return () >> pHandleEndLine+    "CaseIn" -> return () >> pHandleEndLine+    "CaseExpr" -> return () >> pHandleEndLine+    "HereDoc" -> return () >> pHandleEndLine+    "HereDocRemainder" -> (popContext) >> pEndLine+    "HereDocQ" -> return () >> pHandleEndLine+    "HereDocNQ" -> return () >> pHandleEndLine+    "HereDocIQ" -> return () >> pHandleEndLine+    "HereDocINQ" -> return () >> pHandleEndLine+    _ -> pHandleEndLine  withAttribute attr txt = do   when (null txt) $ fail "Parser matched no text"@@ -122,7 +120,7 @@ list_keywords = Set.fromList $ words $ "else for function in select until while elif then set" list_builtins = Set.fromList $ words $ ": source alias bg bind break builtin cd caller command compgen complete continue dirs disown echo enable eval exec exit fc fg getopts hash help history jobs kill let logout popd printf pushd pwd return set shift shopt suspend test time times trap type ulimit umask unalias wait" list_builtins'5fvar = Set.fromList $ words $ "export unset declare typeset local read readonly"-list_unixcommands = Set.fromList $ words $ "arch awk bash bunzip2 bzcat bzcmp bzdiff bzegrep bzfgrep bzgrep bzip2 bzip2recover bzless bzmore cat chattr chgrp chmod chown chvt cp date dd deallocvt df dir dircolors dmesg dnsdomainname domainname du dumpkeys echo ed egrep false fgconsole fgrep fuser gawk getkeycodes gocr grep groff groups gunzip gzexe gzip hostname igawk install kbd_mode kbdrate killall last lastb link ln loadkeys loadunimap login ls lsattr lsmod lsmod.old mapscrn mesg mkdir mkfifo mknod mktemp more mount mv nano netstat nisdomainname nroff openvt pgawk pidof ping ps pstree pwd rbash readlink red resizecons rm rmdir run-parts sash sed setfont setkeycodes setleds setmetamode setserial sh showkey shred sleep ssed stat stty su sync tar tempfile touch troff true umount uname unicode_start unicode_stop unlink utmpdump uuidgen vdir wall wc ypdomainname zcat zcmp zdiff zegrep zfgrep zforce zgrep zless zmore znew zsh aclocal aconnect aplay apm apmsleep apropos ar arecord as as86 autoconf autoheader automake awk basename bc bison c++ cal cat cc cdda2wav cdparanoia cdrdao cd-read cdrecord chfn chgrp chmod chown chroot chsh clear cmp co col comm cp cpio cpp cut dc dd df diff diff3 dir dircolors directomatic dirname du env expr fbset file find flex flex++ fmt free ftp funzip fuser g++ gawk gc gcc gdb getent getopt gettext gettextize gimp gimp-remote gimptool gmake gs head hexdump id install join kill killall ld ld86 ldd less lex ln locate lockfile logname lp lpr ls lynx m4 make man mkdir mknod msgfmt mv namei nasm nawk nice nl nm nm86 nmap nohup nop od passwd patch pcregrep pcretest perl perror pidof pr printf procmail prune ps2ascii ps2epsi ps2frag ps2pdf ps2ps psbook psmerge psnup psresize psselect pstops rcs rev rm scp sed seq setterm shred size size86 skill slogin snice sort sox split ssh ssh-add ssh-agent ssh-keygen ssh-keyscan stat strings strip sudo suidperl sum tac tail tee test tr uniq unlink unzip updatedb updmap uptime users vmstat w wc wget whatis whereis which who whoami write xargs yacc yes zip zsoelim dcop kdialog kfile xhost xmodmap xset"+list_unixcommands = Set.fromList $ words $ "arch awk bash bunzip2 bzcat bzcmp bzdiff bzegrep bzfgrep bzgrep bzip2 bzip2recover bzless bzmore cat chattr chgrp chmod chown chvt cp date dd deallocvt df dir dircolors dmesg dnsdomainname domainname du dumpkeys echo ed egrep false fgconsole fgrep fuser gawk getkeycodes gocr grep groff groups gunzip gzexe gzip hostname igawk install kbd_mode kbdrate killall last lastb link ln loadkeys loadunimap login ls lsattr lsmod lsmod.old lzcat lzcmp lzdiff lzegrep lzfgrep lzgrep lzless lzcat lzma lzmainfo lzmore mapscrn mesg mkdir mkfifo mknod mktemp more mount mv nano netstat nisdomainname nroff openvt pgawk pidof ping ps pstree pwd rbash readlink red resizecons rm rmdir run-parts sash sed setfont setkeycodes setleds setmetamode setserial sh showkey shred sleep ssed stat stty su sync tar tempfile touch troff true umount uname unicode_start unicode_stop unlink unlzma unxz utmpdump uuidgen vdir wall wc xz xzcat ypdomainname zcat zcmp zdiff zegrep zfgrep zforce zgrep zless zmore znew zsh aclocal aconnect aplay apm apmsleep apropos ar arecord as as86 autoconf autoheader automake awk basename bc bison c++ cal cat cc cdda2wav cdparanoia cdrdao cd-read cdrecord chfn chgrp chmod chown chroot chsh clear cmp co col comm cp cpio cpp cut dc dd df diff diff3 dir dircolors directomatic dirname du env expr fbset file find flex flex++ fmt free ftp funzip fuser g++ gawk gc gcc gdb getent getopt gettext gettextize gimp gimp-remote gimptool gmake gs head hexdump id install join kill killall ld ld86 ldd less lex ln locate lockfile logname lp lpr ls lynx m4 make man mkdir mknod msgfmt mv namei nasm nawk nice nl nm nm86 nmap nohup nop od passwd patch pcregrep pcretest perl perror pidof pr printf procmail prune ps2ascii ps2epsi ps2frag ps2pdf ps2ps psbook psmerge psnup psresize psselect pstops rcs rev rm scp sed seq setterm shred size size86 skill slogin snice sort sox split ssh ssh-add ssh-agent ssh-keygen ssh-keyscan stat strings strip sudo suidperl sum tac tail tee test tr uniq unlink unzip updatedb updmap uptime users vmstat w wc wget whatis whereis which who whoami write xargs yacc yes zip zsoelim dcop kdialog kfile xhost xmodmap xset"  regex_'5b'5cs'3b'5d'28'3f'3d'23'29 = compileRegex "[\\s;](?=#)" regex_'5b'5e'29'5d'28'3f'3d'5c'29'29 = compileRegex "[^)](?=\\))"@@ -134,7 +132,7 @@ regex_'5c'7b'28'3f'3d'28'24'7c'5cs'29'29 = compileRegex "\\{(?=($|\\s))" regex_'5cbdo'28'3f'21'5b'5cw'24'2b'2d'5d'29 = compileRegex "\\bdo(?![\\w$+-])" regex_'5cbdone'28'3f'21'5b'5cw'24'2b'2d'5d'29 = compileRegex "\\bdone(?![\\w$+-])"-regex_'5cbif'28'3f'21'5b'5cw'24'2b'2d'5d'29 = compileRegex "\\bif(?![\\w$+-])"+regex_'5cbif_'28'3f'21'5b'5cw'24'2b'2d'5d'29 = compileRegex "\\bif (?![\\w$+-])" regex_'5cbfi'28'3f'21'5b'5cw'24'2b'2d'5d'29 = compileRegex "\\bfi(?![\\w$+-])" regex_'5cbcase'28'3f'21'5b'5cw'24'2b'2d'5d'29 = compileRegex "\\bcase(?![\\w$+-])" regex_'2d'5bA'2dZa'2dz0'2d9'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a = compileRegex "-[A-Za-z0-9][A-Za-z0-9_]*"@@ -186,6 +184,7 @@ regex_'5b0'2d9'5d'28'3f'3d'5b'3a'7d'5d'29 = compileRegex "[0-9](?=[:}])" regex_'5csin'5cb = compileRegex "\\sin\\b" regex_'5cbesac'28'3f'3d'24'7c'5b'5cs'3b'29'5d'29 = compileRegex "\\besac(?=$|[\\s;)])"+regex_esac'28'3f'3d'24'7c'5b'5cs'3b'29'5d'29 = compileRegex "esac(?=$|[\\s;)])" regex_'28'3c'3c'2d'5cs'2a'22'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'22'29 = compileRegex "(<<-\\s*\"([^|&;()<>\\s]+)\")" regex_'28'3c'3c'2d'5cs'2a'27'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'27'29 = compileRegex "(<<-\\s*'([^|&;()<>\\s]+)')" regex_'28'3c'3c'2d'5cs'2a'5c'5c'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'29 = compileRegex "(<<-\\s*\\\\([^|&;()<>\\s]+))"@@ -240,7 +239,7 @@      return (attr, result)  parseRules "CommentParen" = -  do (attr, result) <- (((pRegExpr regex_'5b'5e'29'5d'28'3f'3d'5c'29'29 >>= withAttribute "Comment") >>~ (popContext >> return ()))+  do (attr, result) <- (((pRegExpr regex_'5b'5e'29'5d'28'3f'3d'5c'29'29 >>= withAttribute "Comment") >>~ (popContext))                         <|>                         ((Text.Highlighting.Kate.Syntax.Alert.parseExpression)))      return (attr, result)@@ -252,7 +251,7 @@      return (attr, result)  parseRules "CommentBackq" = -  do (attr, result) <- (((pRegExpr regex_'5b'5e'60'5d'28'3f'3d'60'29 >>= withAttribute "Comment") >>~ (popContext >> return ()))+  do (attr, result) <- (((pRegExpr regex_'5b'5e'60'5d'28'3f'3d'60'29 >>= withAttribute "Comment") >>~ (popContext))                         <|>                         ((Text.Highlighting.Kate.Syntax.Alert.parseExpression)))      return (attr, result)@@ -276,7 +275,7 @@                         <|>                         ((pRegExpr regex_'5cbdone'28'3f'21'5b'5cw'24'2b'2d'5d'29 >>= withAttribute "Keyword"))                         <|>-                        ((pRegExpr regex_'5cbif'28'3f'21'5b'5cw'24'2b'2d'5d'29 >>= withAttribute "Keyword"))+                        ((pRegExpr regex_'5cbif_'28'3f'21'5b'5cw'24'2b'2d'5d'29 >>= withAttribute "Keyword"))                         <|>                         ((pRegExpr regex_'5cbfi'28'3f'21'5b'5cw'24'2b'2d'5d'29 >>= withAttribute "Keyword"))                         <|>@@ -384,7 +383,7 @@      return (attr, result)  parseRules "ExprDblParen" = -  do (attr, result) <- (((pDetect2Chars False ')' ')' >>= withAttribute "Keyword") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetect2Chars False ')' ')' >>= withAttribute "Keyword") >>~ (popContext))                         <|>                         ((pDetectChar False '(' >>= withAttribute "Normal Text") >>~ pushContext "ExprSubParen")                         <|>@@ -392,7 +391,7 @@      return (attr, result)  parseRules "ExprDblParenSubst" = -  do (attr, result) <- (((pDetect2Chars False ')' ')' >>= withAttribute "Variable") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetect2Chars False ')' ')' >>= withAttribute "Variable") >>~ (popContext))                         <|>                         ((pDetectChar False '(' >>= withAttribute "Normal Text") >>~ pushContext "ExprSubParen")                         <|>@@ -400,7 +399,7 @@      return (attr, result)  parseRules "ExprSubParen" = -  do (attr, result) <- (((pDetectChar False ')' >>= withAttribute "Normal Text") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetectChar False ')' >>= withAttribute "Normal Text") >>~ (popContext))                         <|>                         ((pDetectChar False '(' >>= withAttribute "Normal Text") >>~ pushContext "ExprSubParen")                         <|>@@ -408,9 +407,9 @@      return (attr, result)  parseRules "ExprBracket" = -  do (attr, result) <- (((pRegExpr regex_'5cs'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 >>= withAttribute "Builtin") >>~ (popContext >> return ()))+  do (attr, result) <- (((pRegExpr regex_'5cs'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 >>= withAttribute "Builtin") >>~ (popContext))                         <|>-                        ((pColumn 0 >> pRegExpr regex_'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 >>= withAttribute "Builtin") >>~ (popContext >> return ()))+                        ((pColumn 0 >> pRegExpr regex_'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 >>= withAttribute "Builtin") >>~ (popContext))                         <|>                         ((pDetectChar False '(' >>= withAttribute "Normal Text") >>~ pushContext "ExprSubParen")                         <|>@@ -420,9 +419,9 @@      return (attr, result)  parseRules "ExprDblBracket" = -  do (attr, result) <- (((pRegExpr regex_'5cs'5c'5d'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 >>= withAttribute "Keyword") >>~ (popContext >> return ()))+  do (attr, result) <- (((pRegExpr regex_'5cs'5c'5d'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 >>= withAttribute "Keyword") >>~ (popContext))                         <|>-                        ((pColumn 0 >> pRegExpr regex_'5c'5d'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 >>= withAttribute "Keyword") >>~ (popContext >> return ()))+                        ((pColumn 0 >> pRegExpr regex_'5c'5d'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 >>= withAttribute "Keyword") >>~ (popContext))                         <|>                         ((pDetectChar False '(' >>= withAttribute "Normal Text") >>~ pushContext "ExprSubParen")                         <|>@@ -432,13 +431,13 @@      return (attr, result)  parseRules "Group" = -  do (attr, result) <- (((pDetectChar False '}' >>= withAttribute "Keyword") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetectChar False '}' >>= withAttribute "Keyword") >>~ (popContext))                         <|>                         ((parseRules "FindAll")))      return (attr, result)  parseRules "SubShell" = -  do (attr, result) <- (((pDetectChar False ')' >>= withAttribute "Keyword") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetectChar False ')' >>= withAttribute "Keyword") >>~ (popContext))                         <|>                         ((parseRules "FindAll")))      return (attr, result)@@ -454,11 +453,11 @@                         <|>                         ((pRegExpr regex_'5b'5cw'3a'2c'2b'5f'2e'2f'2d'5d >>= withAttribute "Normal Text"))                         <|>-                        ((popContext >> return ()) >> return ([], "")))+                        ((popContext) >> return ([], "")))      return (attr, result)  parseRules "AssignArray" = -  do (attr, result) <- (((pDetectChar False ')' >>= withAttribute "Variable") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetectChar False ')' >>= withAttribute "Variable") >>~ (popContext))                         <|>                         ((pDetectChar False '[' >>= withAttribute "Variable") >>~ pushContext "Subscript")                         <|>@@ -480,11 +479,11 @@                         <|>                         ((parseRules "FindOthers"))                         <|>-                        ((popContext >> return ()) >> return ([], "")))+                        ((popContext) >> return ([], "")))      return (attr, result)  parseRules "Subscript" = -  do (attr, result) <- (((pDetectChar False ']' >>= withAttribute "Variable") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetectChar False ']' >>= withAttribute "Variable") >>~ (popContext))                         <|>                         ((parseRules "FindStrings"))                         <|>@@ -494,9 +493,9 @@      return (attr, result)  parseRules "FunctionDef" = -  do (attr, result) <- (((pRegExpr regex_'5cs'2b'5bA'2dZa'2dz'5f'3a'5d'5bA'2dZa'2dz0'2d9'5f'3a'23'25'40'2d'5d'2a'28'5cs'2a'5c'28'5c'29'29'3f >>= withAttribute "Function") >>~ (popContext >> return ()))+  do (attr, result) <- (((pRegExpr regex_'5cs'2b'5bA'2dZa'2dz'5f'3a'5d'5bA'2dZa'2dz0'2d9'5f'3a'23'25'40'2d'5d'2a'28'5cs'2a'5c'28'5c'29'29'3f >>= withAttribute "Function") >>~ (popContext))                         <|>-                        ((popContext >> return ()) >> return ([], "")))+                        ((popContext) >> return ([], "")))      return (attr, result)  parseRules "VarName" = @@ -514,11 +513,11 @@                         <|>                         ((pRegExpr regex_'5b'5e'5d'7d'29'7c'3b'60'26'3e'3c'5d >>= withAttribute "Normal Text"))                         <|>-                        ((popContext >> return ()) >> return ([], "")))+                        ((popContext) >> return ([], "")))      return (attr, result)  parseRules "ProcessSubst" = -  do (attr, result) <- (((pDetectChar False ')' >>= withAttribute "Redirection") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetectChar False ')' >>= withAttribute "Redirection") >>~ (popContext))                         <|>                         ((parseRules "FindCommentsParen"))                         <|>@@ -532,11 +531,11 @@      return (attr, result)  parseRules "StringSQ" = -  do (attr, result) <- ((pDetectChar False '\'' >>= withAttribute "String SingleQ") >>~ (popContext >> return ()))+  do (attr, result) <- ((pDetectChar False '\'' >>= withAttribute "String SingleQ") >>~ (popContext))      return (attr, result)  parseRules "StringDQ" = -  do (attr, result) <- (((pDetectChar False '"' >>= withAttribute "String DoubleQ") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetectChar False '"' >>= withAttribute "String DoubleQ") >>~ (popContext))                         <|>                         ((pRegExpr regex_'5c'5c'5b'60'22'5c'5c'24'5cn'5d >>= withAttribute "String Escape"))                         <|>@@ -544,7 +543,7 @@      return (attr, result)  parseRules "StringEsc" = -  do (attr, result) <- (((pDetectChar False '\'' >>= withAttribute "String SingleQ") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetectChar False '\'' >>= withAttribute "String SingleQ") >>~ (popContext))                         <|>                         ((pRegExpr regex_'5c'5c'5babefnrtv'5c'5c'27'5d >>= withAttribute "String Escape"))                         <|>@@ -552,7 +551,7 @@      return (attr, result)  parseRules "VarBrace" = -  do (attr, result) <- (((pDetectChar False '}' >>= withAttribute "Variable") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetectChar False '}' >>= withAttribute "Variable") >>~ (popContext))                         <|>                         ((pDetectChar False '[' >>= withAttribute "Variable") >>~ pushContext "Subscript")                         <|>@@ -564,7 +563,7 @@      return (attr, result)  parseRules "VarAlt" = -  do (attr, result) <- (((pDetectChar False '}' >>= withAttribute "Variable") >>~ (popContext >> popContext >> return ()))+  do (attr, result) <- (((pDetectChar False '}' >>= withAttribute "Variable") >>~ (popContext >> popContext))                         <|>                         ((parseRules "FindStrings"))                         <|>@@ -572,7 +571,7 @@      return (attr, result)  parseRules "VarSubst" = -  do (attr, result) <- (((pDetectChar False '}' >>= withAttribute "Variable") >>~ (popContext >> popContext >> return ()))+  do (attr, result) <- (((pDetectChar False '}' >>= withAttribute "Variable") >>~ (popContext >> popContext))                         <|>                         ((pDetectChar False '/' >>= withAttribute "Variable") >>~ pushContext "VarSubst2")                         <|>@@ -582,7 +581,7 @@      return (attr, result)  parseRules "VarSubst2" = -  do (attr, result) <- (((pDetectChar False '}' >>= withAttribute "Variable") >>~ (popContext >> popContext >> popContext >> return ()))+  do (attr, result) <- (((pDetectChar False '}' >>= withAttribute "Variable") >>~ (popContext >> popContext >> popContext))                         <|>                         ((parseRules "FindStrings"))                         <|>@@ -592,7 +591,7 @@ parseRules "VarSub" =    do (attr, result) <- (((pDetectChar False ':' >>= withAttribute "Variable") >>~ pushContext "VarSub2")                         <|>-                        ((pDetectChar False '}' >>= withAttribute "Variable") >>~ (popContext >> popContext >> return ()))+                        ((pDetectChar False '}' >>= withAttribute "Variable") >>~ (popContext >> popContext))                         <|>                         ((pRegExpr regex_'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a >>= withAttribute "Variable"))                         <|>@@ -602,7 +601,7 @@      return (attr, result)  parseRules "VarSub2" = -  do (attr, result) <- (((pDetectChar False '}' >>= withAttribute "Variable") >>~ (popContext >> popContext >> popContext >> return ()))+  do (attr, result) <- (((pDetectChar False '}' >>= withAttribute "Variable") >>~ (popContext >> popContext >> popContext))                         <|>                         ((pRegExpr regex_'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a >>= withAttribute "Variable"))                         <|>@@ -612,7 +611,7 @@      return (attr, result)  parseRules "SubstFile" = -  do (attr, result) <- (((pDetectChar False ')' >>= withAttribute "Redirection") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetectChar False ')' >>= withAttribute "Redirection") >>~ (popContext))                         <|>                         ((parseRules "FindCommentsParen"))                         <|>@@ -624,7 +623,7 @@      return (attr, result)  parseRules "SubstCommand" = -  do (attr, result) <- (((pDetectChar False ')' >>= withAttribute "Variable") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetectChar False ')' >>= withAttribute "Variable") >>~ (popContext))                         <|>                         ((parseRules "FindCommentsParen"))                         <|>@@ -638,7 +637,7 @@      return (attr, result)  parseRules "SubstBackq" = -  do (attr, result) <- (((pDetectChar False '`' >>= withAttribute "Backquote") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetectChar False '`' >>= withAttribute "Backquote") >>~ (popContext))                         <|>                         ((parseRules "FindCommentsBackq"))                         <|>@@ -658,7 +657,7 @@      return (attr, result)  parseRules "CaseIn" = -  do (attr, result) <- (((pRegExpr regex_'5cbesac'28'3f'3d'24'7c'5b'5cs'3b'29'5d'29 >>= withAttribute "Keyword") >>~ (popContext >> popContext >> return ()))+  do (attr, result) <- (((pRegExpr regex_'5cbesac'28'3f'3d'24'7c'5b'5cs'3b'29'5d'29 >>= withAttribute "Keyword") >>~ (popContext >> popContext))                         <|>                         ((pDetectChar False ')' >>= withAttribute "Keyword") >>~ pushContext "CaseExpr")                         <|>@@ -668,8 +667,10 @@      return (attr, result)  parseRules "CaseExpr" = -  do (attr, result) <- (((pDetect2Chars False ';' ';' >>= withAttribute "Keyword") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetect2Chars False ';' ';' >>= withAttribute "Keyword") >>~ (popContext))                         <|>+                        ((pFirstNonSpace >> lookAhead (pRegExpr regex_esac'28'3f'3d'24'7c'5b'5cs'3b'29'5d'29) >> return ([],"") ) >>~ (popContext))+                        <|>                         ((parseRules "FindAll")))      return (attr, result) @@ -690,7 +691,7 @@                         <|>                         ((lookAhead (pRegExpr regex_'28'3c'3c'5cs'2a'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'29) >> return ([],"") ) >>~ pushContext "HereDocNQ")                         <|>-                        ((pString False "<<" >>= withAttribute "Redirection") >>~ (popContext >> return ())))+                        ((pString False "<<" >>= withAttribute "Redirection") >>~ (popContext)))      return (attr, result)  parseRules "HereDocRemainder" = @@ -700,13 +701,13 @@ parseRules "HereDocQ" =    do (attr, result) <- (((pRegExprDynamic "%1" >>= withAttribute "Redirection") >>~ pushContext "HereDocRemainder")                         <|>-                        ((pColumn 0 >> pRegExprDynamic "%2\\b" >>= withAttribute "Redirection") >>~ (popContext >> popContext >> return ())))+                        ((pColumn 0 >> pRegExprDynamic "%2\\b" >>= withAttribute "Redirection") >>~ (popContext >> popContext)))      return (attr, result)  parseRules "HereDocNQ" =    do (attr, result) <- (((pRegExprDynamic "%1" >>= withAttribute "Redirection") >>~ pushContext "HereDocRemainder")                         <|>-                        ((pColumn 0 >> pRegExprDynamic "%2\\b" >>= withAttribute "Redirection") >>~ (popContext >> popContext >> return ()))+                        ((pColumn 0 >> pRegExprDynamic "%2\\b" >>= withAttribute "Redirection") >>~ (popContext >> popContext))                         <|>                         ((parseRules "FindSubstitutions")))      return (attr, result)@@ -714,13 +715,13 @@ parseRules "HereDocIQ" =    do (attr, result) <- (((pRegExprDynamic "%1" >>= withAttribute "Redirection") >>~ pushContext "HereDocRemainder")                         <|>-                        ((pColumn 0 >> pRegExprDynamic "\\t*%2\\b" >>= withAttribute "Redirection") >>~ (popContext >> popContext >> return ())))+                        ((pColumn 0 >> pRegExprDynamic "\\t*%2\\b" >>= withAttribute "Redirection") >>~ (popContext >> popContext)))      return (attr, result)  parseRules "HereDocINQ" =    do (attr, result) <- (((pRegExprDynamic "%1" >>= withAttribute "Redirection") >>~ pushContext "HereDocRemainder")                         <|>-                        ((pColumn 0 >> pRegExprDynamic "\\t*%2\\b" >>= withAttribute "Redirection") >>~ (popContext >> popContext >> return ()))+                        ((pColumn 0 >> pRegExprDynamic "\\t*%2\\b" >>= withAttribute "Redirection") >>~ (popContext >> popContext))                         <|>                         ((parseRules "FindSubstitutions")))      return (attr, result)

@@ -1,5 +1,5 @@-{- This module was generated from data in the Kate syntax highlighting file bibtex.xml, version 1.13,-   by  Jeroen Wijnhout (Jeroen.Wijnhout@kdemail.net) -}+{- This module was generated from data in the Kate syntax highlighting file bibtex.xml, version 1.17,+   by  Jeroen Wijnhout (Jeroen.Wijnhout@kdemail.net)+Thomas Braun (thomas.braun@virtuell-zuhause.de) -}  module Text.Highlighting.Kate.Syntax.Bibtex ( highlight, parseExpression, syntaxName, syntaxExtensions ) where import Text.Highlighting.Kate.Definitions@@ -47,15 +47,17 @@ parseSourceLine = manyTill parseExpressionInternal pEndLine  pEndLine = do-  newline <|> (eof >> return '\n')+  lookAhead $ newline <|> (eof >> return '\n')   context <- currentContext   case context of-    "Normal" -> return ()-    "Entry" -> return ()-    "String" -> return ()-    _ -> return ()-  lineContents <- lookAhead wholeLine-  updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }+    "Normal" -> return () >> pHandleEndLine+    "PreambleCommand" -> return () >> pHandleEndLine+    "StringCommand" -> return () >> pHandleEndLine+    "Entry" -> return () >> pHandleEndLine+    "Field" -> return () >> pHandleEndLine+    "CurlyBracket" -> return () >> pHandleEndLine+    "QuotedText" -> return () >> pHandleEndLine+    _ -> pHandleEndLine  withAttribute attr txt = do   when (null txt) $ fail "Parser matched no text"@@ -66,52 +68,100 @@   updateState $ \st -> st { synStCharsParsedInLine = oldCharsParsed + length txt, synStPrevChar = prevchar }    return (labs, txt) -styles = [("Entry","kw"),("Command","fu"),("Field","dt"),("Ref Key","ot"),("String","st"),("Char","ch")]+styles = [("Entry","kw"),("Command","fu"),("Field","dt"),("Ref Key","ot"),("LatexCommand","ch"),("Comment","co"),("Error","al"),("String","st")]  parseExpressionInternal = do   context <- currentContext   parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes)) -list_kw'5fentry = Set.fromList $ words $ "@article @book @booklet @conference @inbook @incollection @inproceedings @manual @mastersthesis @misc @phdthesis @proceedings @techreport @unpublished @collection @patent"-list_kw'5fcommand = Set.fromList $ words $ "@string @preamble @comment"+list_kw'5fentry = Set.fromList $ words $ "@article @book @booklet @conference @collection @electronic @inbook @incollection @inproceedings @manual @mastersthesis @misc @online @patent @periodical @proceedings @report @phdthesis @set @thesis @techreport @unpublished @www @person @company @place" -regex_'28'5ba'2dzA'2dZ'5d'2b'29'5cs'2a'3d = compileRegex "([a-zA-Z]+)\\s*="-regex_'5c'5c'28'5ba'2dzA'2dZ'5d'2b'7c'2e'29 = compileRegex "\\\\([a-zA-Z]+|.)"+regex_'5ba'2dzA'2dZ0'2d9'5c'2d'5d'2b = compileRegex "[a-zA-Z0-9\\-]+"+regex_'5ba'2dzA'2dZ0'2d9'5f'40'5c'5c'2d'5c'5c'3a'5d'2b = compileRegex "[a-zA-Z0-9_@\\\\-\\\\:]+"+regex_'5ba'2dzA'2dZ0'2d9'5c'2d'5f'5c'2e'5d'2b = compileRegex "[a-zA-Z0-9\\-_\\.]+"+regex_'5b0'2d9'5d'2b = compileRegex "[0-9]+"+regex_'2e = compileRegex "."+regex_'5c'5c'28'5ba'2dzA'2dZ'40'5d'2b'7c'5b'5e_'5d'29 = compileRegex "\\\\([a-zA-Z@]+|[^ ])"+regex_'7d'24 = compileRegex "}$" -defaultAttributes = [("Normal","Normal Text"),("Entry","Ref Key"),("String","String")]+defaultAttributes = [("Normal","Comment"),("PreambleCommand","Normal Text"),("StringCommand","Normal Text"),("Entry","Normal Text"),("Field","Normal Text"),("CurlyBracket","Normal Text"),("QuotedText","String")]  parseRules "Normal" = -  do (attr, result) <- (((pFirstNonSpace >> pRegExpr regex_'28'5ba'2dzA'2dZ'5d'2b'29'5cs'2a'3d >>= withAttribute "Field"))+  do (attr, result) <- (((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~" list_kw'5fentry >>= withAttribute "Entry") >>~ pushContext "Entry")                         <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~" list_kw'5fentry >>= withAttribute "Entry") >>~ pushContext "Entry")+                        ((pString False "@string" >>= withAttribute "Command") >>~ pushContext "StringCommand")                         <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~" list_kw'5fcommand >>= withAttribute "Command"))+                        ((pString False "@preamble" >>= withAttribute "Command") >>~ pushContext "PreambleCommand")                         <|>-                        ((pDetectChar False '{' >>= withAttribute "Normal Text"))+                        ((pString False "@comment" >>= withAttribute "Comment")))+     return (attr, result)++parseRules "PreambleCommand" = +  do (attr, result) <- (((pDetectChar False '{' >>= withAttribute "Normal Text") >>~ pushContext "CurlyBracket")                         <|>-                        ((pDetectChar False '}' >>= withAttribute "Normal Text"))+                        ((popContext) >> return ([], "")))+     return (attr, result)++parseRules "StringCommand" = +  do (attr, result) <- (((pDetectChar False '{' >>= withAttribute "Normal Text") >>~ pushContext "CurlyBracket")                         <|>-                        ((pRegExpr regex_'5c'5c'28'5ba'2dzA'2dZ'5d'2b'7c'2e'29 >>= withAttribute "Char"))+                        ((pRegExpr regex_'5ba'2dzA'2dZ0'2d9'5c'2d'5d'2b >>= withAttribute "String") >>~ pushContext "CurlyBracket")                         <|>-                        ((pDetectChar False '"' >>= withAttribute "String") >>~ pushContext "String"))+                        ((popContext) >> return ([], "")))      return (attr, result)  parseRules "Entry" = -  do (attr, result) <- (((pDetectChar False ',' >>= withAttribute "Normal Text") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetectChar False '{' >>= withAttribute "Normal Text"))                         <|>-                        ((pDetectChar False '{' >>= withAttribute "Normal Text"))+                        ((pRegExpr regex_'5ba'2dzA'2dZ0'2d9'5f'40'5c'5c'2d'5c'5c'3a'5d'2b >>= withAttribute "Ref Key"))                         <|>-                        ((pDetectChar False '}' >>= withAttribute "Normal Text"))+                        ((pDetectChar False ',' >>= withAttribute "Normal Text") >>~ pushContext "Field")                         <|>-                        ((pRegExpr regex_'5c'5c'28'5ba'2dzA'2dZ'5d'2b'7c'2e'29 >>= withAttribute "Char"))+                        ((pDetectChar False '}' >>= withAttribute "Normal Text") >>~ (popContext)))+     return (attr, result)++parseRules "Field" = +  do (attr, result) <- (((pFirstNonSpace >> pRegExpr regex_'5ba'2dzA'2dZ0'2d9'5c'2d'5f'5c'2e'5d'2b >>= withAttribute "Field"))                         <|>-                        ((pDetectChar False '"' >>= withAttribute "String") >>~ (popContext >> return ())))+                        ((pDetectSpaces >>= withAttribute "Normal Text"))+                        <|>+                        ((pDetectChar False '=' >>= withAttribute "Normal Text"))+                        <|>+                        ((pDetectSpaces >>= withAttribute "Normal Text"))+                        <|>+                        ((pDetectChar False '{' >>= withAttribute "Normal Text") >>~ pushContext "CurlyBracket")+                        <|>+                        ((lookAhead (pDetectChar False '}') >> return ([],"") ) >>~ (popContext))+                        <|>+                        ((pDetectChar False '"' >>= withAttribute "Normal Text") >>~ pushContext "QuotedText")+                        <|>+                        ((pDetectChar False ',' >>= withAttribute "Normal Text"))+                        <|>+                        ((pDetectChar False '#' >>= withAttribute "Normal Text"))+                        <|>+                        ((pRegExpr regex_'5b0'2d9'5d'2b >>= withAttribute "Normal Text"))+                        <|>+                        ((pRegExpr regex_'5ba'2dzA'2dZ0'2d9'5c'2d'5d'2b >>= withAttribute "String"))+                        <|>+                        ((pDetectSpaces >>= withAttribute "Normal Text"))+                        <|>+                        ((pRegExpr regex_'2e >>= withAttribute "Error")))      return (attr, result) -parseRules "String" = -  do (attr, result) <- (((pRegExpr regex_'5c'5c'28'5ba'2dzA'2dZ'5d'2b'7c'2e'29 >>= withAttribute "Char"))+parseRules "CurlyBracket" = +  do (attr, result) <- (((pDetectChar False '{' >>= withAttribute "Normal Text") >>~ pushContext "CurlyBracket")                         <|>-                        ((pDetectChar False '"' >>= withAttribute "String") >>~ (popContext >> return ())))+                        ((pRegExpr regex_'5c'5c'28'5ba'2dzA'2dZ'40'5d'2b'7c'5b'5e_'5d'29 >>= withAttribute "LatexCommand"))+                        <|>+                        ((pRegExpr regex_'7d'24 >>= withAttribute "Normal Text") >>~ (popContext >> popContext))+                        <|>+                        ((pDetectChar False '}' >>= withAttribute "Normal Text") >>~ (popContext)))+     return (attr, result)++parseRules "QuotedText" = +  do (attr, result) <- (((pDetectChar False '"' >>= withAttribute "Normal Text") >>~ (popContext))+                        <|>+                        ((pRegExpr regex_'5c'5c'28'5ba'2dzA'2dZ'40'5d'2b'7c'5b'5e_'5d'29 >>= withAttribute "LatexCommand")))      return (attr, result)  parseRules x = fail $ "Unknown context" ++ x

@@ -0,0 +1,299 @@+{- This module was generated from data in the Kate syntax highlighting file boo.xml, version 0.91,+   by  Marc Dassonneville -}++module Text.Highlighting.Kate.Syntax.Boo ( highlight, parseExpression, syntaxName, syntaxExtensions ) where+import Text.Highlighting.Kate.Definitions+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 = "Boo"++-- | Filename extensions for this language.+syntaxExtensions :: String+syntaxExtensions = "*.boo"++-- | Highlight source code using this syntax definition.+highlight :: String -> Either String [SourceLine]+highlight input =+  case runParser parseSource startingState "source" input of+    Left err     -> Left $ show err+    Right result -> Right result++-- | Parse an expression using appropriate local context.+parseExpression :: GenParser Char SyntaxState LabeledSource+parseExpression = do+  st <- getState+  let oldLang = synStLanguage st+  setState $ st { synStLanguage = "Boo" }+  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 [("Boo",["Normal"])], synStLanguage = "Boo", synStCurrentLine = "", synStCharsParsedInLine = 0, synStPrevChar = '\n', synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}++parseSourceLine = manyTill parseExpressionInternal pEndLine++pEndLine = do+  lookAhead $ newline <|> (eof >> return '\n')+  context <- currentContext+  case context of+    "Normal" -> return () >> pHandleEndLine+    "parenthesised" -> return () >> pHandleEndLine+    "Quasi-Quotation" -> return () >> pHandleEndLine+    "Tripple A-comment" -> return () >> pHandleEndLine+    "Tripple Q-comment" -> return () >> pHandleEndLine+    "Tripple A-string" -> return () >> pHandleEndLine+    "Raw Tripple A-string" -> return () >> pHandleEndLine+    "Tripple Q-string" -> return () >> pHandleEndLine+    "Raw Tripple Q-string" -> return () >> pHandleEndLine+    "Comment SlashSlash" -> (popContext) >> pEndLine+    "Single A-comment" -> return () >> pHandleEndLine+    "Single Q-comment" -> return () >> pHandleEndLine+    "Single A-string" -> return () >> pHandleEndLine+    "Single Q-string" -> return () >> pHandleEndLine+    "Raw A-string" -> return () >> pHandleEndLine+    "Raw Q-string" -> return () >> pHandleEndLine+    _ -> pHandleEndLine++withAttribute attr txt = do+  when (null txt) $ fail "Parser matched no text"+  let labs = attr : maybeToList (lookup attr styles)+  st <- getState+  let oldCharsParsed = synStCharsParsedInLine st+  let prevchar = if null txt then '\n' else last txt+  updateState $ \st -> st { synStCharsParsedInLine = oldCharsParsed + length txt, synStPrevChar = prevchar } +  return (labs, txt)++styles = [("Definition Keyword","kw"),("Data Type","dt"),("Flow Control Keyword","kw"),("Builtin Function","dt"),("Special Variable","ot"),("Preprocessor","ch"),("String Char","ch"),("Long","ot"),("Float","fl"),("Int","dv"),("Hex","ot"),("Octal","ot"),("Complex","ot"),("Comment","co"),("String","st"),("Raw String","st")]++parseExpressionInternal = do+  context <- currentContext+  parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes))++list_namespace = Set.fromList $ words $ "import from as namespace"+list_operators = Set.fromList $ words $ "and assert in is not or"+list_primitive = Set.fromList $ words $ "bool byte sbyte double decimal single short ushort int char uint long ulong object duck string regex date timespan"+list_definition = Set.fromList $ words $ "abstract virtual override static final transient macro protected private public internal partial class struct interface enum callable of def constructor destructor do get set event return yield"+list_boolean = Set.fromList $ words $ "true false"+list_literals = Set.fromList $ words $ "null self super"+list_keywords = Set.fromList $ words $ "and break cast continue elif else except ensure for given goto if in is isa not or otherwise pass raise try unless when while ref"+list_builtins = Set.fromList $ words $ "assert __eval__ __switch__ enumerate filter len typeof map max min property using getter required lock range zip checked unchecked rawArrayIndexing normalArrayIndexing print array matrix yieldAll"++regex_'5ba'2dzA'2dZ'5f'5d'5ba'2dzA'2dZ'5f0'2d9'5d'2b = compileRegex "[a-zA-Z_][a-zA-Z_0-9]+"+regex__'28'28'28'5b0'2d9'5d'2a'5c'2e'5b0'2d9'5d'2b'7c'5b0'2d9'5d'2b'5c'2e'29'7c'28'5b0'2d9'5d'2b'7c'28'5b0'2d9'5d'2a'5c'2e'5b0'2d9'5d'2b'7c'5b0'2d9'5d'2b'5c'2e'29'29'5beE'5d'28'5c'2b'7c'2d'29'3f'5b0'2d9'5d'2b'29'7c'5b0'2d9'5d'2b'29'5bjJ'5d = compileRegex " ((([0-9]*\\.[0-9]+|[0-9]+\\.)|([0-9]+|([0-9]*\\.[0-9]+|[0-9]+\\.))[eE](\\+|-)?[0-9]+)|[0-9]+)[jJ]"+regex_'28'5b0'2d9'5d'2b'5c'2e'5b0'2d9'5d'2a'7c'5c'2e'5b0'2d9'5d'2b'29'28'5beE'5d'5b0'2d9'5d'2b'29'3f = compileRegex "([0-9]+\\.[0-9]*|\\.[0-9]+)([eE][0-9]+)?"+regex_'28'5b1'2d9'5d'5b0'2d9'5d'2a'28'5beE'5d'5b0'2d9'5d'2b'29'3f'7c0'29 = compileRegex "([1-9][0-9]*([eE][0-9]+)?|0)"+regex_'5b1'2d9'5d'5b0'2d9'5d'2a'28'5beE'5d'5b0'2d9'2e'5d'2b'29'3f'5bLl'5d = compileRegex "[1-9][0-9]*([eE][0-9.]+)?[Ll]"+regex_0'5bXx'5d'5b0'2d9a'2dfA'2dF'5d'2b = compileRegex "0[Xx][0-9a-fA-F]+"+regex_0'5b1'2d9'5d'5b0'2d9'5d'2a = compileRegex "0[1-9][0-9]*"+regex_'5brR'5d'27'27'27 = compileRegex "[rR]'''"+regex_'5brR'5d'22'22'22 = compileRegex "[rR]\"\"\""+regex_'5brR'5d'27 = compileRegex "[rR]'"+regex_'5brR'5d'22 = compileRegex "[rR]\""+regex_'23'2e'2a'24 = compileRegex "#.*$"+regex_'5cs'2au'3f'27'27'27 = compileRegex "\\s*u?'''"+regex_'5cs'2au'3f'22'22'22 = compileRegex "\\s*u?\"\"\""+regex_'5b'2b'2a'2f'25'5c'7c'3d'3b'5c'21'3c'3e'21'5e'26'7e'2d'5d = compileRegex "[+*/%\\|=;\\!<>!^&~-]"+regex_'25'5ba'2dzA'2dZ'5d = compileRegex "%[a-zA-Z]"+regex_'22'22'22 = compileRegex "\"\"\""+regex_'25'5c'28'5ba'2dzA'2dZ0'2d9'5f'5d'2b'5c'29'5ba'2dzA'2dZ'5d = compileRegex "%\\([a-zA-Z0-9_]+\\)[a-zA-Z]"+regex_'27'27'27 = compileRegex "'''"++defaultAttributes = [("Normal","Normal Text"),("parenthesised","Normal Text"),("Quasi-Quotation","Operator"),("Tripple A-comment","Comment"),("Tripple Q-comment","Comment"),("Tripple A-string","String"),("Raw Tripple A-string","Raw String"),("Tripple Q-string","String"),("Raw Tripple Q-string","Raw String"),("Comment SlashSlash","Comment"),("Single A-comment","Comment"),("Single Q-comment","Comment"),("Single A-string","String"),("Single Q-string","String"),("Raw A-string","Raw String"),("Raw Q-string","Raw String")]++parseRules "Normal" = +  do (attr, result) <- (((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_namespace >>= withAttribute "Preprocessor"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_definition >>= withAttribute "Definition Keyword"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_operators >>= withAttribute "Operator"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_keywords >>= withAttribute "Flow Control Keyword"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_builtins >>= withAttribute "Builtin Function"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_literals >>= withAttribute "Special Variable"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_boolean >>= withAttribute "Special Variable"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_primitive >>= withAttribute "Data Type"))+                        <|>+                        ((pRegExpr regex_'5ba'2dzA'2dZ'5f'5d'5ba'2dzA'2dZ'5f0'2d9'5d'2b >>= withAttribute "Normal"))+                        <|>+                        ((pRegExpr regex__'28'28'28'5b0'2d9'5d'2a'5c'2e'5b0'2d9'5d'2b'7c'5b0'2d9'5d'2b'5c'2e'29'7c'28'5b0'2d9'5d'2b'7c'28'5b0'2d9'5d'2a'5c'2e'5b0'2d9'5d'2b'7c'5b0'2d9'5d'2b'5c'2e'29'29'5beE'5d'28'5c'2b'7c'2d'29'3f'5b0'2d9'5d'2b'29'7c'5b0'2d9'5d'2b'29'5bjJ'5d >>= withAttribute "Complex"))+                        <|>+                        ((pRegExpr regex_'28'5b0'2d9'5d'2b'5c'2e'5b0'2d9'5d'2a'7c'5c'2e'5b0'2d9'5d'2b'29'28'5beE'5d'5b0'2d9'5d'2b'29'3f >>= withAttribute "Float"))+                        <|>+                        ((pRegExpr regex_'28'5b1'2d9'5d'5b0'2d9'5d'2a'28'5beE'5d'5b0'2d9'5d'2b'29'3f'7c0'29 >>= withAttribute "Int"))+                        <|>+                        ((pRegExpr regex_'5b1'2d9'5d'5b0'2d9'5d'2a'28'5beE'5d'5b0'2d9'2e'5d'2b'29'3f'5bLl'5d >>= withAttribute "Long"))+                        <|>+                        ((pRegExpr regex_0'5bXx'5d'5b0'2d9a'2dfA'2dF'5d'2b >>= withAttribute "Hex"))+                        <|>+                        ((pRegExpr regex_0'5b1'2d9'5d'5b0'2d9'5d'2a >>= withAttribute "Octal"))+                        <|>+                        ((pRegExpr regex_'5brR'5d'27'27'27 >>= withAttribute "Raw String") >>~ pushContext "Raw Tripple A-string")+                        <|>+                        ((pRegExpr regex_'5brR'5d'22'22'22 >>= withAttribute "Raw String") >>~ pushContext "Raw Tripple Q-string")+                        <|>+                        ((pRegExpr regex_'5brR'5d'27 >>= withAttribute "Raw String") >>~ pushContext "Raw A-string")+                        <|>+                        ((pRegExpr regex_'5brR'5d'22 >>= withAttribute "Raw String") >>~ pushContext "Raw Q-string")+                        <|>+                        ((pRegExpr regex_'23'2e'2a'24 >>= withAttribute "Comment"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5cs'2au'3f'27'27'27 >>= withAttribute "Comment") >>~ pushContext "Tripple A-comment")+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5cs'2au'3f'22'22'22 >>= withAttribute "Comment") >>~ pushContext "Tripple Q-comment")+                        <|>+                        ((pDetect2Chars False '/' '/' >>= withAttribute "Comment") >>~ pushContext "Comment SlashSlash")+                        <|>+                        ((pString False "'''" >>= withAttribute "String") >>~ pushContext "Tripple A-string")+                        <|>+                        ((pString False "\"\"\"" >>= withAttribute "String") >>~ pushContext "Tripple Q-string")+                        <|>+                        ((pDetectChar False '\'' >>= withAttribute "String") >>~ pushContext "Single A-string")+                        <|>+                        ((pDetectChar False '"' >>= withAttribute "String") >>~ pushContext "Single Q-string")+                        <|>+                        ((pDetectChar False '(' >>= withAttribute "Operator") >>~ pushContext "parenthesised")+                        <|>+                        ((pDetectChar False ')' >>= withAttribute "Operator") >>~ (popContext))+                        <|>+                        ((pString False "[|" >>= withAttribute "Operator") >>~ pushContext "Quasi-Quotation")+                        <|>+                        ((pString False "|]" >>= withAttribute "Operator") >>~ (popContext))+                        <|>+                        ((pRegExpr regex_'5b'2b'2a'2f'25'5c'7c'3d'3b'5c'21'3c'3e'21'5e'26'7e'2d'5d >>= withAttribute "Operator"))+                        <|>+                        ((pRegExpr regex_'25'5ba'2dzA'2dZ'5d >>= withAttribute "String Substitution")))+     return (attr, result)++parseRules "parenthesised" = +  do (attr, result) <- ((parseRules "Normal"))+     return (attr, result)++parseRules "Quasi-Quotation" = +  do (attr, result) <- ((parseRules "Normal"))+     return (attr, result)++parseRules "Tripple A-comment" = +  do (attr, result) <- ((pString False "'''" >>= withAttribute "Comment") >>~ (popContext))+     return (attr, result)++parseRules "Tripple Q-comment" = +  do (attr, result) <- (((pHlCChar >>= withAttribute "Comment"))+                        <|>+                        ((pRegExpr regex_'22'22'22 >>= withAttribute "Comment") >>~ (popContext)))+     return (attr, result)++parseRules "Tripple A-string" = +  do (attr, result) <- (((pHlCStringChar >>= withAttribute "String Char"))+                        <|>+                        ((pRegExpr regex_'25'5c'28'5ba'2dzA'2dZ0'2d9'5f'5d'2b'5c'29'5ba'2dzA'2dZ'5d >>= withAttribute "String Substitution"))+                        <|>+                        ((pRegExpr regex_'25'5ba'2dzA'2dZ'5d >>= withAttribute "String Substitution"))+                        <|>+                        ((pRegExpr regex_'27'27'27 >>= withAttribute "String") >>~ (popContext)))+     return (attr, result)++parseRules "Raw Tripple A-string" = +  do (attr, result) <- (((pHlCStringChar >>= withAttribute "Raw String"))+                        <|>+                        ((pRegExpr regex_'25'5c'28'5ba'2dzA'2dZ0'2d9'5f'5d'2b'5c'29'5ba'2dzA'2dZ'5d >>= withAttribute "String Substitution"))+                        <|>+                        ((pRegExpr regex_'25'5ba'2dzA'2dZ'5d >>= withAttribute "String Substitution"))+                        <|>+                        ((pRegExpr regex_'27'27'27 >>= withAttribute "String") >>~ (popContext)))+     return (attr, result)++parseRules "Tripple Q-string" = +  do (attr, result) <- (((pHlCStringChar >>= withAttribute "String Char"))+                        <|>+                        ((pRegExpr regex_'25'5c'28'5ba'2dzA'2dZ0'2d9'5f'5d'2b'5c'29'5ba'2dzA'2dZ'5d >>= withAttribute "String Substitution"))+                        <|>+                        ((pRegExpr regex_'25'5ba'2dzA'2dZ'5d >>= withAttribute "String Substitution"))+                        <|>+                        ((pRegExpr regex_'22'22'22 >>= withAttribute "String") >>~ (popContext)))+     return (attr, result)++parseRules "Raw Tripple Q-string" = +  do (attr, result) <- (((pHlCStringChar >>= withAttribute "Raw String"))+                        <|>+                        ((pRegExpr regex_'25'5c'28'5ba'2dzA'2dZ0'2d9'5f'5d'2b'5c'29'5ba'2dzA'2dZ'5d >>= withAttribute "String Substitution"))+                        <|>+                        ((pRegExpr regex_'25'5ba'2dzA'2dZ'5d >>= withAttribute "String Substitution"))+                        <|>+                        ((pRegExpr regex_'22'22'22 >>= withAttribute "String") >>~ (popContext)))+     return (attr, result)++parseRules "Comment SlashSlash" = +  do (attr, result) <- ((pLineContinue >>= withAttribute "Comment"))+     return (attr, result)++parseRules "Single A-comment" = +  do (attr, result) <- (((pHlCStringChar >>= withAttribute "Comment"))+                        <|>+                        ((pDetectChar False '\'' >>= withAttribute "Comment") >>~ (popContext)))+     return (attr, result)++parseRules "Single Q-comment" = +  do (attr, result) <- (((pHlCStringChar >>= withAttribute "Comment"))+                        <|>+                        ((pDetectChar False '"' >>= withAttribute "Comment") >>~ (popContext)))+     return (attr, result)++parseRules "Single A-string" = +  do (attr, result) <- (((pHlCStringChar >>= withAttribute "String Char"))+                        <|>+                        ((pRegExpr regex_'25'5c'28'5ba'2dzA'2dZ0'2d9'5f'5d'2b'5c'29'5ba'2dzA'2dZ'5d >>= withAttribute "String Substitution"))+                        <|>+                        ((pRegExpr regex_'25'5ba'2dzA'2dZ'5d >>= withAttribute "String Substitution"))+                        <|>+                        ((pDetectChar False '\'' >>= withAttribute "String") >>~ (popContext)))+     return (attr, result)++parseRules "Single Q-string" = +  do (attr, result) <- (((pHlCStringChar >>= withAttribute "String Char"))+                        <|>+                        ((pRegExpr regex_'25'5c'28'5ba'2dzA'2dZ0'2d9'5f'5d'2b'5c'29'5ba'2dzA'2dZ'5d >>= withAttribute "String Substitution"))+                        <|>+                        ((pRegExpr regex_'25'5ba'2dzA'2dZ'5d >>= withAttribute "String Substitution"))+                        <|>+                        ((pDetectChar False '"' >>= withAttribute "String") >>~ (popContext)))+     return (attr, result)++parseRules "Raw A-string" = +  do (attr, result) <- (((pHlCStringChar >>= withAttribute "Raw String"))+                        <|>+                        ((pRegExpr regex_'25'5c'28'5ba'2dzA'2dZ0'2d9'5f'5d'2b'5c'29'5ba'2dzA'2dZ'5d >>= withAttribute "String Substitution"))+                        <|>+                        ((pRegExpr regex_'25'5ba'2dzA'2dZ'5d >>= withAttribute "String Substitution"))+                        <|>+                        ((pDetectChar False '\'' >>= withAttribute "Raw String") >>~ (popContext)))+     return (attr, result)++parseRules "Raw Q-string" = +  do (attr, result) <- (((pHlCStringChar >>= withAttribute "Raw String"))+                        <|>+                        ((pRegExpr regex_'25'5c'28'5ba'2dzA'2dZ0'2d9'5f'5d'2b'5c'29'5ba'2dzA'2dZ'5d >>= withAttribute "String Substitution"))+                        <|>+                        ((pRegExpr regex_'25'5ba'2dzA'2dZ'5d >>= withAttribute "String Substitution"))+                        <|>+                        ((pDetectChar False '"' >>= withAttribute "Raw String") >>~ (popContext)))+     return (attr, result)++parseRules x = fail $ "Unknown context" ++ x

@@ -1,4 +1,4 @@-{- This module was generated from data in the Kate syntax highlighting file c.xml, version 1.41,+{- This module was generated from data in the Kate syntax highlighting file c.xml, version 1.44,    by   -}  module Text.Highlighting.Kate.Syntax.C ( highlight, parseExpression, syntaxName, syntaxExtensions ) where@@ -49,23 +49,21 @@ parseSourceLine = manyTill parseExpressionInternal pEndLine  pEndLine = do-  newline <|> (eof >> return '\n')+  lookAhead $ newline <|> (eof >> return '\n')   context <- currentContext   case context of-    "Normal" -> return ()-    "String" -> (popContext >> return ())-    "Region Marker" -> (popContext >> return ())-    "Commentar 1" -> (popContext >> return ())-    "Commentar 2" -> return ()-    "AfterHash" -> (popContext >> return ())-    "Preprocessor" -> (popContext >> return ())-    "Define" -> (popContext >> return ())-    "Commentar/Preprocessor" -> return ()-    "Outscoped" -> return ()-    "Outscoped intern" -> return ()-    _ -> return ()-  lineContents <- lookAhead wholeLine-  updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }+    "Normal" -> return () >> pHandleEndLine+    "String" -> (popContext) >> pEndLine+    "Region Marker" -> (popContext) >> pEndLine+    "Commentar 1" -> (popContext) >> pEndLine+    "Commentar 2" -> return () >> pHandleEndLine+    "AfterHash" -> (popContext) >> pEndLine+    "Preprocessor" -> (popContext) >> pEndLine+    "Define" -> (popContext) >> pEndLine+    "Commentar/Preprocessor" -> return () >> pHandleEndLine+    "Outscoped" -> return () >> pHandleEndLine+    "Outscoped intern" -> return () >> pHandleEndLine+    _ -> pHandleEndLine  withAttribute attr txt = do   when (null txt) $ fail "Parser matched no text"@@ -83,9 +81,9 @@   parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes))  list_keywords = Set.fromList $ words $ "break case continue default do else enum extern for goto if inline return sizeof struct switch typedef union while"-list_types = Set.fromList $ words $ "auto char const double float int long register restrict short signed static unsigned void volatile _Imaginary _Complex _Bool"+list_types = Set.fromList $ words $ "auto char const double float int long register restrict short signed static unsigned void volatile int8_t int16_t int32_t int64_t uint8_t uint16_t uint32_t uint64_t wchar_t _Imaginary _Complex _Bool" -regex_'23'5cs'2aif'5cs'2b0 = compileRegex "#\\s*if\\s+0"+regex_'23'5cs'2aif'5cs'2b0'5cs'2a'24 = compileRegex "#\\s*if\\s+0\\s*$" regex_'23'5cs'2aif'28'3f'3adef'7cndef'29'3f'28'3f'3d'5cs'2b'5cS'29 = compileRegex "#\\s*if(?:def|ndef)?(?=\\s+\\S)" regex_'23'5cs'2aendif = compileRegex "#\\s*endif" regex_'23'5cs'2adefine'2e'2a'28'28'3f'3d'5c'5c'29'29 = compileRegex "#\\s*define.*((?=\\\\))"@@ -99,7 +97,7 @@ parseRules "Normal" =    do (attr, result) <- (((pDetectSpaces >>= withAttribute "Normal Text"))                         <|>-                        ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2aif'5cs'2b0 >>= withAttribute "Preprocessor") >>~ pushContext "Outscoped")+                        ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2aif'5cs'2b0'5cs'2a'24 >>= withAttribute "Preprocessor") >>~ pushContext "Outscoped")                         <|>                         ((pFirstNonSpace >> lookAhead (pDetectChar False '#') >> return ([],"") ) >>~ pushContext "AfterHash")                         <|>@@ -107,9 +105,9 @@                         <|>                         ((pFirstNonSpace >> pString False "//END" >>= withAttribute "Region Marker") >>~ pushContext "Region Marker")                         <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_keywords >>= withAttribute "Keyword"))+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\'\"" list_keywords >>= withAttribute "Keyword"))                         <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_types >>= withAttribute "Data Type"))+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\'\"" list_types >>= withAttribute "Data Type"))                         <|>                         ((pDetectIdentifier >>= withAttribute "Normal Text"))                         <|>@@ -157,7 +155,7 @@                         <|>                         ((pHlCStringChar >>= withAttribute "String Char"))                         <|>-                        ((pDetectChar False '"' >>= withAttribute "String") >>~ (popContext >> return ())))+                        ((pDetectChar False '"' >>= withAttribute "String") >>~ (popContext)))      return (attr, result)  parseRules "Region Marker" = @@ -170,7 +168,7 @@      return (attr, result)  parseRules "Commentar 2" = -  do (attr, result) <- (((pDetect2Chars False '*' '/' >>= withAttribute "Comment") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetect2Chars False '*' '/' >>= withAttribute "Comment") >>~ (popContext))                         <|>                         ((Text.Highlighting.Kate.Syntax.Alert.parseExpression)))      return (attr, result)@@ -204,7 +202,7 @@      return (attr, result)  parseRules "Commentar/Preprocessor" = -  do (attr, result) <- ((pDetect2Chars False '*' '/' >>= withAttribute "Comment") >>~ (popContext >> return ()))+  do (attr, result) <- ((pDetect2Chars False '*' '/' >>= withAttribute "Comment") >>~ (popContext))      return (attr, result)  parseRules "Outscoped" = @@ -224,9 +222,9 @@                         <|>                         ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2aif >>= withAttribute "Comment") >>~ pushContext "Outscoped intern")                         <|>-                        ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2ael'28'3f'3ase'7cif'29 >>= withAttribute "Preprocessor") >>~ (popContext >> return ()))+                        ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2ael'28'3f'3ase'7cif'29 >>= withAttribute "Preprocessor") >>~ (popContext))                         <|>-                        ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2aendif >>= withAttribute "Preprocessor") >>~ (popContext >> return ())))+                        ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2aendif >>= withAttribute "Preprocessor") >>~ (popContext)))      return (attr, result)  parseRules "Outscoped intern" = @@ -246,7 +244,7 @@                         <|>                         ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2aif >>= withAttribute "Comment") >>~ pushContext "Outscoped intern")                         <|>-                        ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2aendif >>= withAttribute "Comment") >>~ (popContext >> return ())))+                        ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2aendif >>= withAttribute "Comment") >>~ (popContext)))      return (attr, result)  parseRules x = fail $ "Unknown context" ++ x

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

@@ -0,0 +1,167 @@+{- This module was generated from data in the Kate syntax highlighting file cisco.xml, version 1.10,+   by  Raphaël GRAPINET -}++module Text.Highlighting.Kate.Syntax.Cisco ( 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 = "Cisco"++-- | Filename extensions for this language.+syntaxExtensions :: String+syntaxExtensions = "*.cis"++-- | 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 = "Cisco" }+  context <- currentContext <|> (pushContext "Base" >> 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 [("Cisco",["Base"])], synStLanguage = "Cisco", synStCurrentLine = "", synStCharsParsedInLine = 0, synStPrevChar = '\n', synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}++parseSourceLine = manyTill parseExpressionInternal pEndLine++pEndLine = do+  lookAhead $ newline <|> (eof >> return '\n')+  context <- currentContext+  case context of+    "Base" -> return () >> pHandleEndLine+    "String" -> return () >> pHandleEndLine+    "Single Quote" -> return () >> pHandleEndLine+    "Substitution" -> return () >> pHandleEndLine+    "Parameter" -> return () >> pHandleEndLine+    _ -> pHandleEndLine++withAttribute attr txt = do+  when (null txt) $ fail "Parser matched no text"+  let labs = attr : maybeToList (lookup attr styles)+  st <- getState+  let oldCharsParsed = synStCharsParsedInLine st+  let prevchar = if null txt then '\n' else last txt+  updateState $ \st -> st { synStCharsParsedInLine = oldCharsParsed + length txt, synStPrevChar = prevchar } +  return (labs, txt)++styles = [("Keyword","kw"),("Decimal","dv"),("Float","fl"),("Char","ch"),("String","st"),("Comment","co"),("Substitution","ot"),("Parameter","ot"),("Operator","ot")]++parseExpressionInternal = do+  context <- currentContext+  parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes))++list_commands = Set.fromList $ words $ "aaa access-list address alias arp async-bootp banner boot bridge buffers busy-message call-history-mib cdp chat-script class-map clock cns config-register controller crypto default default-value dialer dialer-list dnsix-dmdp dnsix-nat downward-compatible-config enable end exception exit file frame-relay help hostname interface ip isdn isdn-mib kerberos key line logging login-string map-class map-list memory-size menu modemcap multilink netbios no ntp partition policy-map priority-list privilege process-max-time prompt queue-list resume-string rlogin rmon route-map router rtr scheduler service snmp-server sntp stackmaker state-machine subscriber-policy tacacs-server template terminal-queue tftp-server time-range username virtual-profile virtual-template vpdn vpdn-group x25 x29"+list_parameters = Set.fromList $ words $ "accounting accounting-list accounting-threshold accounting-transits address-pool as-path audit auth-proxy authentication authorization bgp-community bootp cef classless community-list default-gateway default-network dhcp dhcp-server domain-list domain-lookup domain-name dvmrp exec-callback extcommunity-list finger flow-aggregation flow-cache flow-export forward-protocol ftp gratuitous-arps host host-routing hp-host http icmp inspect local mrm mroute msdp multicast multicast-routing name-server nat new-model ospf password password-encryption pgm pim port-map prefix-list radius rcmd reflexive-list route routing rsvp rtcp sap sdr security source-route subnet-zero tacacs tcp tcp-small-servers telnet tftp timestamps udp-small-servers vrf wccp"+list_options = Set.fromList $ words $ "accounting accounting-list accounting-threshold accounting-transits address-pool as-path audit auth-proxy authentication authorization bgp-community bootp cef classless community-list default-gateway default-network dhcp dhcp-server domain-list domain-lookup domain-name dvmrp exec-callback extcommunity-list finger flow-aggregation flow-cache flow-export forward-protocol ftp gratuitous-arps host host-routing hp-host http icmp inspect local mrm mroute msdp multicast multicast-routing name-server nat new-model ospf password password-encryption pgm pim port-map prefix-list radius rcmd reflexive-list route routing rsvp rtcp sap sdr security source-route subnet-zero tacacs tcp tcp-small-servers telnet tftp timestamps udp-small-servers vrf wccp"++regex_'5cbdone'5cb = compileRegex "\\bdone\\b"+regex_'5cbdo'5cb = compileRegex "\\bdo\\b"+regex_'5cbelif'5cb = compileRegex "\\belif\\b"+regex_'5cbif'5cb = compileRegex "\\bif\\b"+regex_'5cbfi'5cb = compileRegex "\\bfi\\b"+regex_'5cbcase'5cb = compileRegex "\\bcase\\b"+regex_'5cbesac'5cb = compileRegex "\\besac\\b"+regex_'5b'5e'28'29'5d'2b'5c'29 = compileRegex "[^()]+\\)"+regex_'5c'24'5bA'2dZa'2dz0'2d9'5f'3f'7b'7d'21'5d'2b = compileRegex "\\$[A-Za-z0-9_?{}!]+"+regex_'23'2e'2a'24 = compileRegex "#.*$"+regex_'5c'24'5bA'2dZa'2dz0'2d9'5f'3f'5d'2b = compileRegex "\\$[A-Za-z0-9_?]+"++defaultAttributes = [("Base","Normal Text"),("String","String"),("Single Quote","String"),("Substitution","Substitution"),("Parameter","Parameter")]++parseRules "Base" = +  do (attr, result) <- (((pRegExpr regex_'5cbdone'5cb >>= withAttribute "Keyword"))+                        <|>+                        ((pRegExpr regex_'5cbdo'5cb >>= withAttribute "Keyword"))+                        <|>+                        ((pRegExpr regex_'5cbelif'5cb >>= withAttribute "Keyword"))+                        <|>+                        ((pRegExpr regex_'5cbif'5cb >>= withAttribute "Keyword"))+                        <|>+                        ((pRegExpr regex_'5cbfi'5cb >>= withAttribute "Keyword"))+                        <|>+                        ((pRegExpr regex_'5cbcase'5cb >>= withAttribute "Keyword"))+                        <|>+                        ((pRegExpr regex_'5cbesac'5cb >>= withAttribute "Keyword"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5b'5e'28'29'5d'2b'5c'29 >>= withAttribute "Keyword"))+                        <|>+                        ((pDetect2Chars False ';' ';' >>= withAttribute "Keyword"))+                        <|>+                        ((pDetectChar False '{' >>= withAttribute "Keyword"))+                        <|>+                        ((pDetectChar False '}' >>= withAttribute "Keyword"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_commands >>= withAttribute "Command"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_parameters >>= withAttribute "Parameter"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_options >>= withAttribute "Keyword"))+                        <|>+                        ((pInt >>= withAttribute "Decimal"))+                        <|>+                        ((pRegExpr regex_'5c'24'5bA'2dZa'2dz0'2d9'5f'3f'7b'7d'21'5d'2b >>= withAttribute "Parameter"))+                        <|>+                        ((pRangeDetect '"' '"' >>= withAttribute "String"))+                        <|>+                        ((pAnyChar "|<>=;" >>= withAttribute "Operator"))+                        <|>+                        ((pDetectChar False '\'' >>= withAttribute "String") >>~ pushContext "Single Quote")+                        <|>+                        ((pDetectChar False '`' >>= withAttribute "Substitution") >>~ pushContext "Substitution")+                        <|>+                        ((pDetect2Chars False '\\' '#' >>= withAttribute "Normal Text"))+                        <|>+                        ((pRegExpr regex_'23'2e'2a'24 >>= withAttribute "Comment")))+     return (attr, result)++parseRules "String" = +  do (attr, result) <- (((pDetect2Chars False '\\' '\\' >>= withAttribute "String"))+                        <|>+                        ((pDetect2Chars False '\\' '"' >>= withAttribute "String"))+                        <|>+                        ((pDetectChar False '"' >>= withAttribute "String") >>~ (popContext)))+     return (attr, result)++parseRules "Single Quote" = +  do (attr, result) <- (((pDetect2Chars False '\\' '\\' >>= withAttribute "String"))+                        <|>+                        ((pDetect2Chars False '\\' '\'' >>= withAttribute "String"))+                        <|>+                        ((pDetectChar False '\'' >>= withAttribute "String") >>~ (popContext)))+     return (attr, result)++parseRules "Substitution" = +  do (attr, result) <- (((pDetect2Chars False '\\' '\\' >>= withAttribute "String"))+                        <|>+                        ((pDetect2Chars False '\\' '`' >>= withAttribute "String"))+                        <|>+                        ((pDetectChar False '`' >>= withAttribute "Substitution") >>~ (popContext)))+     return (attr, result)++parseRules "Parameter" = +  do (attr, result) <- ((pRegExpr regex_'5c'24'5bA'2dZa'2dz0'2d9'5f'3f'5d'2b >>= withAttribute "Parameter") >>~ (popContext))+     return (attr, result)++parseRules x = fail $ "Unknown context" ++ x

@@ -1,5 +1,5 @@-{- This module was generated from data in the Kate syntax highlighting file cmake.xml, version 1.04,-   by   -}+{- This module was generated from data in the Kate syntax highlighting file cmake.xml, version 1.13,+   by  Alexander Neundorf (neundorf@kde.org) -}  module Text.Highlighting.Kate.Syntax.Cmake ( highlight, parseExpression, syntaxName, syntaxExtensions ) where import Text.Highlighting.Kate.Definitions@@ -48,15 +48,16 @@ parseSourceLine = manyTill parseExpressionInternal pEndLine  pEndLine = do-  newline <|> (eof >> return '\n')+  lookAhead $ newline <|> (eof >> return '\n')   context <- currentContext   case context of-    "Normal Text" -> return ()-    "Function Args" -> return ()-    "Comment" -> (popContext >> return ())-    _ -> return ()-  lineContents <- lookAhead wholeLine-  updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }+    "Normal Text" -> return () >> pHandleEndLine+    "Detect Variables" -> return () >> pHandleEndLine+    "Command Args" -> return () >> pHandleEndLine+    "Macro Args" -> return () >> pHandleEndLine+    "Comment" -> (popContext) >> pEndLine+    "String" -> return () >> pHandleEndLine+    _ -> pHandleEndLine  withAttribute attr txt = do   when (null txt) $ fail "Parser matched no text"@@ -67,51 +68,88 @@   updateState $ \st -> st { synStCharsParsedInLine = oldCharsParsed + length txt, synStPrevChar = prevchar }    return (labs, txt) -styles = [("Special Args","ot"),("Commands","kw"),("Macros","kw"),("Variable","dv"),("Comment","co"),("Region Marker","re")]+styles = [("Special Args","ot"),("Properties","ot"),("Commands","kw"),("Third-Party Commands","fu"),("Macros","fu"),("Strings","st"),("Escapes","ch"),("CMake Variable","dv"),("Environment Variable","fl"),("Comment","co"),("Region Marker","re")]  parseExpressionInternal = do   context <- currentContext   parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes)) -list_commands = Set.fromList $ words $ "ABSTRACT_FILES ADD_CUSTOM_COMMAND ADD_CUSTOM_TARGET ADD_DEFINITIONS ADD_DEPENDENCIES ADD_EXECUTABLE ADD_LIBRARY ADD_SUBDIRECTORY ADD_TEST AUX_SOURCE_DIRECTORY BUILD_COMMAND BUILD_NAME CMAKE_MINIMUM_REQUIRED CONFIGURE_FILE CREATE_TEST_SOURCELIST ELSE ELSEIF ENABLE_TESTING ENDFOREACH ENDIF ENDMACRO EXEC_PROGRAM EXPORT_LIBRARY_DEPENDENCIES FILE FIND_FILE FIND_LIBRARY FIND_PACKAGE FIND_PATH FIND_PROGRAM FLTK_WRAP_UI FOREACH GET_CMAKE_PROPERTY GET_DIRECTORY_PROPERTY GET_FILENAME_COMPONENT GET_SOURCE_FILE_PROPERTY GET_TARGET_PROPERTY IF INCLUDE INCLUDE_DIRECTORIES INCLUDE_EXTERNAL_MSPROJECT INCLUDE_REGULAR_EXPRESSION INSTALL INSTALL_FILES INSTALL_PROGRAMS INSTALL_TARGETS ITK_WRAP_TCL LINK_DIRECTORIES LINK_LIBRARIES LIST LOAD_CACHE LOAD_COMMAND MACRO MAKE_DIRECTORY MARK_AS_ADVANCED MESSAGE OPTION OUTPUT_REQUIRED_FILES PROJECT QT_WRAP_CPP QT_WRAP_UI REMOVE REMOVE_DEFINITIONS SEPARATE_ARGUMENTS SET SET_DIRECTORY_PROPERTIES SET_SOURCE_FILES_PROPERTIES SET_TARGET_PROPERTIES SITE_NAME SOURCE_FILES SOURCE_FILES_REMOVE SOURCE_GROUP STRING SUBDIRS SUBDIR_DEPENDS TARGET_LINK_LIBRARIES TRY_COMPILE TRY_RUN USE_MANGLED_MESA UTILITY_SOURCE VARIABLE_REQUIRES VTK_MAKE_INSTANTIATOR VTK_WRAP_JAVA VTK_WRAP_PYTHON VTK_WRAP_TCL WRAP_EXCLUDE_FILES WRITE_FILE"-list_special'5fargs = Set.fromList $ words $ "ABSOLUTE ABSTRACT ADDITIONAL_MAKE_CLEAN_FILES ALL AND APPEND ARCHIVE ARGS ASCII BEFORE CACHE CACHE_VARIABLES CLEAR CMAKE_FLAGS CODE COMMAND COMMANDS COMMAND_NAME COMMENT COMPARE COMPILE_FLAGS COMPONENT CONFIGURATIONS COPYONLY DEFINED DEFINE_SYMBOL DEPENDS DESTINATION DIRECTORY_PERMISSIONS DOC EQUAL ESCAPE_QUOTES EXCLUDE EXCLUDE_FROM_ALL EXISTS EXPORT_MACRO EXT EXTRA_INCLUDE FATAL_ERROR FILE FILES FILE_PERMISSIONS FORCE FUNCTION GENERATED GLOB GLOB_RECURSE GREATER GROUP_SIZE HEADER_FILE_ONLY HEADER_LOCATION IMMEDIATE INCLUDES INCLUDE_DIRECTORIES INCLUDE_INTERNALS INCLUDE_REGULAR_EXPRESSION INTERNAL LESS LIBRARY LINK_DIRECTORIES LINK_FLAGS LOCATION MACOSX_BUNDLE MACROS MAIN_DEPENDENCY MAKE_DIRECTORY MATCH MATCHALL MATCHES MODULE NAME NAMES NAME_WE NOT NOTEQUAL NO_SYSTEM_PATH OBJECT_DEPENDS OPTIONAL OR OUTPUT OUTPUT_VARIABLE PATH PATHS PATTERN PERMISSIONS POST_BUILD POST_INSTALL_SCRIPT PREFIX PREORDER PRE_BUILD PRE_INSTALL_SCRIPT PRE_LINK PROGRAM PROGRAMS PROGRAM_ARGS PROPERTIES QUIET RANGE READ REGEX REGULAR_EXPRESSION RENAME REPLACE REQUIRED RETURN_VALUE RUNTIME RUNTIME_DIRECTORY SCRIPT SEND_ERROR SHARED SOURCES STATIC STATUS STREQUAL STRGREATER STRLESS SUFFIX TARGET TARGETS TOLOWER TOUPPER USE_SOURCE_PERMISSIONS VAR VARIABLES VERSION WIN32 WRAP_EXCLUDE WRITE"+list_commands = Set.fromList $ words $ "add_custom_command add_custom_target add_definitions add_dependencies add_executable add_library add_subdirectory add_test aux_source_directory break build_command build_name cmake_minimum_required cmake_policy configure_file create_test_sourcelist define_property else elseif enable_language enable_testing endforeach endfunction endif endmacro endwhile exec_program execute_process export export_library_dependencies file find_file find_library find_package find_path find_program fltk_wrap_ui foreach function get_cmake_property get_directory_property get_filename_component get_property get_source_file_property get_target_property get_test_property if include include_directories include_external_msproject include_regular_expression install install_files install_programs install_targets link_directories link_libraries list load_cache load_command macro make_directory mark_as_advanced math message option output_required_files project qt_wrap_cpp qt_wrap_ui remove remove_definitions return separate_arguments set set_directory_properties set_property set_source_files_properties set_target_properties set_tests_properties site_name source_group string subdir_depends subdirs target_link_libraries try_compile try_run unset use_mangled_mesa utility_source variable_requires variable_watch while write_file"+list_itkvtk'5fcommands = Set.fromList $ words $ "itk_wrap_tcl vtk_make_instantiator vtk_wrap_java vtk_wrap_python vtk_wrap_tcl"+list_special'5fargs = Set.fromList $ words $ "A ABSOLUTE AFTER ALL ALPHABET AND APPEND ARCHIVE ARGS ASCII AUTHOR_WARNING B BEFORE BRIEF_DOCS BUNDLE CACHE CLEAR CMAKE_FIND_ROOT_PATH_BOTH CMAKE_FLAGS CODE COMMAND COMMAND_NAME COMMENT COMPARE COMPILE_DEFINITIONS COMPILE_OUTPUT_VARIABLE COMPILE_RESULT_VAR COMPONENT COMPONENTS CONFIGS CONFIGURATION CONFIGURATIONS CONFIGURE COPYONLY COPY_FILE DEFINED DEFINITION DEPENDS DESTINATION DIRECTORY DIRECTORY_PERMISSIONS DOC DOWNLOAD ENV EQUAL ERROR_FILE ERROR_QUIET ERROR_STRIP_TRAILING_WHITESPACE ERROR_VARIABLE ESCAPE_QUOTES EXACT EXCLUDE EXCLUDE_FROM_ALL EXISTS EXPORT EXPR EXT EXTRA_INCLUDE FATAL_ERROR FILE FILES FILES_MATCHING FILE_PERMISSIONS FIND FOLLOW_SYMLINKS FORCE FRAMEWORK FULL_DOCS FUNCTION GET GLOB GLOB_RECURSE GREATER GROUP_EXECUTE GROUP_READ HEX HINTS IMPLICIT_DEPENDS IMPORTED IN INCLUDE_INTERNALS INHERITED INPUT_FILE INSERT IS_ABSOLUTE IS_DIRECTORY IS_NEWER_THAN IS_SYMLINK ITEMS LENGTH LENGTH_MAXIMUM LENGTH_MINIMUM LESS LIBRARY LIMIT LIMIT_COUNT LIMIT_INPUT LIMIT_OUTPUT LINK_INTERFACE_LIBRARIES LISTS LOG MACOSX_BUNDLE MAIN_DEPENDENCY MAKE_DIRECTORY MATCH MATCHALL MATCHES MODULE NAME NAMELINK_ONLY NAMELINK_SKIP NAMES NAMESPACE NAME_WE NEW NEWLINE_CONSUME NOT NOTEQUAL NO_CMAKE_BUILDS_PATH NO_CMAKE_ENVIRONMENT_PATH NO_CMAKE_FIND_ROOT_PATH NO_CMAKE_PACKAGE_REGISTRY NO_CMAKE_PATH NO_CMAKE_SYSTEM_PATH NO_DEFAULT_PATH NO_HEX_CONVERSION NO_MODULE NO_POLICY_SCOPE NO_SOURCE_PERMISSIONS NO_SYSTEM_ENVIRONMENT_PATH OFFSET OLD ONLY_CMAKE_FIND_ROOT_PATH OPTIONAL OR OUTPUT OUTPUT_DIRECTORY OUTPUT_FILE OUTPUT_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE OWNER_EXECUTE OWNER_READ OWNER_WRITE PACKAGE PARENT_SCOPE PATH PATHS PATH_SUFFIXES PATH_TO_MESA PATTERN PERMISSIONS POLICY POP POST_BUILD PREORDER PRE_BUILD PRE_LINK PRIVATE_HEADER PROGRAM PROGRAMS PROGRAM_ARGS PROJECT_NAME PROPERTIES PROPERTY PUBLIC_HEADER PUSH QUIET RANDOM RANDOM_SEED RANGE READ READ_WITH_PREFIX REALPATH REGEX REGULAR_EXPRESSION RELATIVE RELATIVE_PATH REMOVE REMOVE_AT REMOVE_DUPLICATES REMOVE_ITEM REMOVE_RECURSE RENAME REPLACE REQUIRED REQUIRED_VARIABLE1 REQUIRED_VARIABLE2 RESOURCE RESULT_VAR RESULT_VARIABLE RETURN_VALUE REVERSE RUNTIME RUNTIME_DIRECTORY RUN_OUTPUT_VARIABLE RUN_RESULT_VAR SCRIPT SEND_ERROR SET SHARED SORT SOURCE SOURCES STATIC STATUS STREQUAL STRGREATER STRINGS STRIP STRLESS SUBSTRING SYSTEM TARGET TARGETS TEST TEST_VARIABLE TIMEOUT TOLOWER TOUPPER TO_CMAKE_PATH TO_NATIVE_PATH USE_SOURCE_PERMISSIONS VALUE VAR VAR2 VARIABLE VERBATIM VERSION VERSION_EQUAL VERSION_GREATER VERSION_LESS WARNING WIN32 WORKING_DIRECTORY WRITE"+list_extra'5fspecial'5fargs = Set.fromList $ words $ "GLOBAL INTERNAL"+list_properties = Set.fromList $ words $ "ABSTRACT ADDITIONAL_MAKE_CLEAN_FILES ADVANCED ALLOW_DUPLICATE_CUSTOM_TARGETS ARCHIVE_OUTPUT_DIRECTORY ARCHIVE_OUTPUT_NAME ATTACHED_FILES ATTACHED_FILES_ON_FAIL BUILD_WITH_INSTALL_RPATH CACHE_VARIABLES CLEAN_NO_CUSTOM COMPILE_DEFINITIONS COMPILE_FLAGS COST DEBUG_CONFIGURATIONS DEBUG_POSTFIX DEFINE_SYMBOL DEFINITIONS DEPENDS DISABLED_FEATURES ENABLED_FEATURES ENABLED_LANGUAGES ENABLE_EXPORTS ENVIRONMENT EXCLUDE_FROM_ALL EXTERNAL_OBJECT EchoString FAIL_REGULAR_EXPRESSION FIND_LIBRARY_USE_LIB64_PATHS FIND_LIBRARY_USE_OPENBSD_VERSIONING FRAMEWORK Fortran_MODULE_DIRECTORY GENERATED GENERATOR_FILE_NAME GLOBAL_DEPENDS_DEBUG_MODE GLOBAL_DEPENDS_NO_CYCLES HAS_CXX HEADER_FILE_ONLY HELPSTRING IMPLICIT_DEPENDS_INCLUDE_TRANSFORM IMPORTED IMPORTED_CONFIGURATIONS IMPORTED_IMPLIB IMPORTED_LINK_DEPENDENT_LIBRARIES IMPORTED_LINK_INTERFACE_LANGUAGES IMPORTED_LINK_INTERFACE_LIBRARIES IMPORTED_LINK_INTERFACE_MULTIPLICITY IMPORTED_LOCATION IMPORTED_SONAME IMPORT_PREFIX IMPORT_SUFFIX INCLUDE_DIRECTORIES INCLUDE_REGULAR_EXPRESSION INSTALL_NAME_DIR INSTALL_RPATH INSTALL_RPATH_USE_LINK_PATH INTERPROCEDURAL_OPTIMIZATION IN_TRY_COMPILE KEEP_EXTENSION LABELS LANGUAGE LIBRARY_OUTPUT_DIRECTORY LIBRARY_OUTPUT_NAME LINKER_LANGUAGE LINK_DIRECTORIES LINK_FLAGS LINK_INTERFACE_LIBRARIES LINK_INTERFACE_MULTIPLICITY LINK_SEARCH_END_STATIC LISTFILE_STACK LOCATION MACOSX_BUNDLE MACOSX_BUNDLE_INFO_PLIST MACOSX_FRAMEWORK_INFO_PLIST MACOSX_PACKAGE_LOCATION MACROS MEASUREMENT MODIFIED OBJECT_DEPENDS OBJECT_OUTPUTS OSX_ARCHITECTURES OUTPUT_NAME PACKAGES_FOUND PACKAGES_NOT_FOUND PARENT_DIRECTORY PASS_REGULAR_EXPRESSION POST_INSTALL_SCRIPT PREFIX PRE_INSTALL_SCRIPT PRIVATE_HEADER PROCESSORS PROJECT_LABEL PUBLIC_HEADER REPORT_UNDEFINED_PROPERTIES REQUIRED_FILES RESOURCE RULE_LAUNCH_COMPILE RULE_LAUNCH_CUSTOM RULE_LAUNCH_LINK RULE_MESSAGES RUNTIME_OUTPUT_DIRECTORY RUNTIME_OUTPUT_NAME RUN_SERIAL SKIP_BUILD_RPATH SOURCES SOVERSION STATIC_LIBRARY_FLAGS STRINGS SUFFIX SYMBOLIC TARGET_ARCHIVES_MAY_BE_SHARED_LIBS TARGET_SUPPORTS_SHARED_LIBS TEST_INCLUDE_FILE TIMEOUT TYPE VALUE VARIABLES VERSION VS_KEYWORD VS_SCC_LOCALPATH VS_SCC_PROJECTNAME VS_SCC_PROVIDER WILL_FAIL WIN32_EXECUTABLE WRAP_EXCLUDE __CMAKE_DELETE_CACHE_CHANGE_VARS_"+list_extra'5fproperties = Set.fromList $ words $ "COMMANDS DEFINITION"  regex_'23'5cs'2aBEGIN'2e'2a'24 = compileRegex "#\\s*BEGIN.*$" regex_'23'5cs'2aEND'2e'2a'24 = compileRegex "#\\s*END.*$"-regex_'5c'24'5c'7b'5cs'2a'5cw'2b'5cs'2a'5c'7d = compileRegex "\\$\\{\\s*\\w+\\s*\\}" regex_'5cw'2b'5cs'2a'28'3f'3d'5c'28'29 = compileRegex "\\w+\\s*(?=\\()"+regex_'5c'24ENV'5c'7b'5cs'2a'5cw'2b'5cs'2a'5c'7d = compileRegex "\\$ENV\\{\\s*\\w+\\s*\\}"+regex_'5c'24'5c'7b'5cs'2a'5cw'2b'5cs'2a'5c'7d = compileRegex "\\$\\{\\s*\\w+\\s*\\}" regex_'23'2e'2a'24 = compileRegex "#.*$"+regex_'22'28'3f'3d'5b_'29'3b'5d'7c'24'29 = compileRegex "\"(?=[ );]|$)"+regex_'5c'5c'5b'22'24n'5c'5c'5d = compileRegex "\\\\[\"$n\\\\]" -defaultAttributes = [("Normal Text","Normal Text"),("Function Args","Normal Text"),("Comment","Comment")]+defaultAttributes = [("Normal Text","Normal Text"),("Detect Variables","Normal Text"),("Command Args","Normal Text"),("Macro Args","Normal Text"),("Comment","Comment"),("String","Strings")]  parseRules "Normal Text" =    do (attr, result) <- (((pDetectSpaces >>= withAttribute "Normal Text"))                         <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_commands >>= withAttribute "Commands") >>~ pushContext "Function Args")+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_commands >>= withAttribute "Commands") >>~ pushContext "Command Args")                         <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_itkvtk'5fcommands >>= withAttribute "Third-Party Commands"))+                        <|>                         ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2aBEGIN'2e'2a'24 >>= withAttribute "Region Marker"))                         <|>                         ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2aEND'2e'2a'24 >>= withAttribute "Region Marker"))                         <|>                         ((pDetectChar False '#' >>= withAttribute "Comment") >>~ pushContext "Comment")                         <|>-                        ((pRegExpr regex_'5c'24'5c'7b'5cs'2a'5cw'2b'5cs'2a'5c'7d >>= withAttribute "Variable"))+                        ((parseRules "Detect Variables"))                         <|>-                        ((pRegExpr regex_'5cw'2b'5cs'2a'28'3f'3d'5c'28'29 >>= withAttribute "Macros")))+                        ((pRegExpr regex_'5cw'2b'5cs'2a'28'3f'3d'5c'28'29 >>= withAttribute "Macros") >>~ pushContext "Macro Args"))      return (attr, result) -parseRules "Function Args" = -  do (attr, result) <- (((pDetectChar False ')' >>= withAttribute "Normal Text") >>~ (popContext >> return ()))+parseRules "Detect Variables" = +  do (attr, result) <- (((pRegExpr regex_'5c'24ENV'5c'7b'5cs'2a'5cw'2b'5cs'2a'5c'7d >>= withAttribute "Environment Variable"))                         <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_special'5fargs >>= withAttribute "Special Args"))+                        ((pRegExpr regex_'5c'24'5c'7b'5cs'2a'5cw'2b'5cs'2a'5c'7d >>= withAttribute "CMake Variable")))+     return (attr, result)++parseRules "Command Args" = +  do (attr, result) <- (((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_special'5fargs >>= withAttribute "Special Args"))                         <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_extra'5fspecial'5fargs >>= withAttribute "Special Args"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_properties >>= withAttribute "Properties"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_extra'5fproperties >>= withAttribute "Properties"))+                        <|>+                        ((parseRules "Macro Args")))+     return (attr, result)++parseRules "Macro Args" = +  do (attr, result) <- (((pDetectChar False ')' >>= withAttribute "Normal Text") >>~ (popContext))+                        <|>+                        ((pString False "\\\"" >>= withAttribute "Escapes"))+                        <|>+                        ((pDetectChar False '"' >>= withAttribute "Strings") >>~ pushContext "String")+                        <|>                         ((pRegExpr regex_'23'2e'2a'24 >>= withAttribute "Comment"))                         <|>-                        ((pRegExpr regex_'5c'24'5c'7b'5cs'2a'5cw'2b'5cs'2a'5c'7d >>= withAttribute "Variable")))+                        ((parseRules "Detect Variables")))      return (attr, result)  parseRules "Comment" =    do (attr, result) <- ((Text.Highlighting.Kate.Syntax.Alert.parseExpression))+     return (attr, result)++parseRules "String" = +  do (attr, result) <- (((pRegExpr regex_'22'28'3f'3d'5b_'29'3b'5d'7c'24'29 >>= withAttribute "Strings") >>~ (popContext))+                        <|>+                        ((pRegExpr regex_'5c'5c'5b'22'24n'5c'5c'5d >>= withAttribute "Escapes"))+                        <|>+                        ((parseRules "Detect Variables")))      return (attr, result)  parseRules x = fail $ "Unknown context" ++ x

@@ -47,33 +47,31 @@ parseSourceLine = manyTill parseExpressionInternal pEndLine  pEndLine = do-  newline <|> (eof >> return '\n')+  lookAhead $ newline <|> (eof >> return '\n')   context <- currentContext   case context of-    "Normal Text" -> return ()-    "ctxCFSCRIPT Tag" -> return ()-    "ctxSCRIPT Tag" -> return ()-    "ctxSTYLE Tag" -> return ()-    "ctxTag" -> return ()-    "ctxTable Tag" -> return ()-    "ctxAnchor Tag" -> return ()-    "ctxImage Tag" -> return ()-    "ctxCF Tag" -> return ()-    "ctxCustom Tag" -> return ()-    "ctxCFX Tag" -> return ()-    "ctxHTML Comment" -> return ()-    "ctxCF Comment" -> return ()-    "ctxC Style Comment" -> return ()-    "ctxOne Line Comment" -> (popContext >> return ())-    "ctxHTML Entities" -> (popContext >> return ())-    "ctxCFSCRIPT Block" -> return ()-    "ctxSCRIPT Block" -> return ()-    "ctxSTYLE Block" -> return ()-    "ctxStyle Properties" -> return ()-    "ctxStyle Values" -> (popContext >> return ())-    _ -> return ()-  lineContents <- lookAhead wholeLine-  updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }+    "Normal Text" -> return () >> pHandleEndLine+    "ctxCFSCRIPT Tag" -> return () >> pHandleEndLine+    "ctxSCRIPT Tag" -> return () >> pHandleEndLine+    "ctxSTYLE Tag" -> return () >> pHandleEndLine+    "ctxTag" -> return () >> pHandleEndLine+    "ctxTable Tag" -> return () >> pHandleEndLine+    "ctxAnchor Tag" -> return () >> pHandleEndLine+    "ctxImage Tag" -> return () >> pHandleEndLine+    "ctxCF Tag" -> return () >> pHandleEndLine+    "ctxCustom Tag" -> return () >> pHandleEndLine+    "ctxCFX Tag" -> return () >> pHandleEndLine+    "ctxHTML Comment" -> return () >> pHandleEndLine+    "ctxCF Comment" -> return () >> pHandleEndLine+    "ctxC Style Comment" -> return () >> pHandleEndLine+    "ctxOne Line Comment" -> (popContext) >> pEndLine+    "ctxHTML Entities" -> (popContext) >> pEndLine+    "ctxCFSCRIPT Block" -> return () >> pHandleEndLine+    "ctxSCRIPT Block" -> return () >> pHandleEndLine+    "ctxSTYLE Block" -> return () >> pHandleEndLine+    "ctxStyle Properties" -> return () >> pHandleEndLine+    "ctxStyle Values" -> (popContext) >> pEndLine+    _ -> pHandleEndLine  withAttribute attr txt = do   when (null txt) $ fail "Parser matched no text"@@ -174,7 +172,7 @@      return (attr, result)  parseRules "ctxTag" = -  do (attr, result) <- (((pDetectChar False '>' >>= withAttribute "Tags") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetectChar False '>' >>= withAttribute "Tags") >>~ (popContext))                         <|>                         ((pDetectChar False '=' >>= withAttribute "Normal Text"))                         <|>@@ -184,7 +182,7 @@      return (attr, result)  parseRules "ctxTable Tag" = -  do (attr, result) <- (((pDetectChar False '>' >>= withAttribute "Table Tags") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetectChar False '>' >>= withAttribute "Table Tags") >>~ (popContext))                         <|>                         ((pDetectChar False '=' >>= withAttribute "Normal Text"))                         <|>@@ -194,7 +192,7 @@      return (attr, result)  parseRules "ctxAnchor Tag" = -  do (attr, result) <- (((pDetectChar False '>' >>= withAttribute "Anchor Tags") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetectChar False '>' >>= withAttribute "Anchor Tags") >>~ (popContext))                         <|>                         ((pDetectChar False '=' >>= withAttribute "Normal Text"))                         <|>@@ -204,7 +202,7 @@      return (attr, result)  parseRules "ctxImage Tag" = -  do (attr, result) <- (((pDetectChar False '>' >>= withAttribute "Image Tags") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetectChar False '>' >>= withAttribute "Image Tags") >>~ (popContext))                         <|>                         ((pDetectChar False '=' >>= withAttribute "Normal Text"))                         <|>@@ -214,7 +212,7 @@      return (attr, result)  parseRules "ctxCF Tag" = -  do (attr, result) <- (((pDetectChar False '>' >>= withAttribute "CF Tags") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetectChar False '>' >>= withAttribute "CF Tags") >>~ (popContext))                         <|>                         ((pDetectChar False '=' >>= withAttribute "Normal Text"))                         <|>@@ -224,7 +222,7 @@      return (attr, result)  parseRules "ctxCustom Tag" = -  do (attr, result) <- (((pDetectChar False '>' >>= withAttribute "Custom Tags") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetectChar False '>' >>= withAttribute "Custom Tags") >>~ (popContext))                         <|>                         ((pDetectChar False '=' >>= withAttribute "Normal Text"))                         <|>@@ -234,7 +232,7 @@      return (attr, result)  parseRules "ctxCFX Tag" = -  do (attr, result) <- (((pDetectChar False '>' >>= withAttribute "CFX Tags") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetectChar False '>' >>= withAttribute "CFX Tags") >>~ (popContext))                         <|>                         ((pDetectChar False '=' >>= withAttribute "Normal Text"))                         <|>@@ -246,22 +244,22 @@ parseRules "ctxHTML Comment" =    do (attr, result) <- (((pString False "<!---" >>= withAttribute "CF Comment") >>~ pushContext "ctxCF Comment")                         <|>-                        ((pString False "-->" >>= withAttribute "HTML Comment") >>~ (popContext >> return ())))+                        ((pString False "-->" >>= withAttribute "HTML Comment") >>~ (popContext)))      return (attr, result)  parseRules "ctxCF Comment" = -  do (attr, result) <- ((pString False "--->" >>= withAttribute "CF Comment") >>~ (popContext >> return ()))+  do (attr, result) <- ((pString False "--->" >>= withAttribute "CF Comment") >>~ (popContext))      return (attr, result)  parseRules "ctxC Style Comment" = -  do (attr, result) <- ((pDetect2Chars False '*' '/' >>= withAttribute "Script Comment") >>~ (popContext >> return ()))+  do (attr, result) <- ((pDetect2Chars False '*' '/' >>= withAttribute "Script Comment") >>~ (popContext))      return (attr, result)  parseRules "ctxOne Line Comment" =    pzero  parseRules "ctxHTML Entities" = -  do (attr, result) <- ((pDetectChar False ';' >>= withAttribute "HTML Entities") >>~ (popContext >> return ()))+  do (attr, result) <- ((pDetectChar False ';' >>= withAttribute "HTML Entities") >>~ (popContext))      return (attr, result)  parseRules "ctxCFSCRIPT Block" = @@ -285,7 +283,7 @@                         <|>                         ((pKeyword " \n\t.():!+,<=>%&*/;?[]^{|}~\\" list_CFSCRIPT_Functions >>= withAttribute "Script Functions"))                         <|>-                        ((pRegExpr regex_'3c'2f'5bcC'5d'5bfF'5d'5bsS'5d'5bcC'5d'5brR'5d'5biI'5d'5bpP'5d'5btT'5d'3e >>= withAttribute "Script Tags") >>~ (popContext >> popContext >> return ())))+                        ((pRegExpr regex_'3c'2f'5bcC'5d'5bfF'5d'5bsS'5d'5bcC'5d'5brR'5d'5biI'5d'5bpP'5d'5btT'5d'3e >>= withAttribute "Script Tags") >>~ (popContext >> popContext)))      return (attr, result)  parseRules "ctxSCRIPT Block" = @@ -311,7 +309,7 @@                         <|>                         ((pKeyword " \n\t.():!+,<=>%&*/;?[]^{|}~\\" list_Script_Methods >>= withAttribute "Script Functions"))                         <|>-                        ((pRegExpr regex_'3c'2f'5bsS'5d'5bcC'5d'5brR'5d'5biI'5d'5bpP'5d'5btT'5d'3e >>= withAttribute "Script Tags") >>~ (popContext >> popContext >> return ())))+                        ((pRegExpr regex_'3c'2f'5bsS'5d'5bcC'5d'5brR'5d'5biI'5d'5bpP'5d'5btT'5d'3e >>= withAttribute "Script Tags") >>~ (popContext >> popContext)))      return (attr, result)  parseRules "ctxSTYLE Block" = @@ -319,11 +317,11 @@                         <|>                         ((pDetectChar False '{' >>= withAttribute "Brackets") >>~ pushContext "ctxStyle Properties")                         <|>-                        ((pRegExpr regex_'3c'2f'5bsS'5d'5btT'5d'5byY'5d'5blL'5d'5beE'5d'3e >>= withAttribute "Style Tags") >>~ (popContext >> popContext >> return ())))+                        ((pRegExpr regex_'3c'2f'5bsS'5d'5btT'5d'5byY'5d'5blL'5d'5beE'5d'3e >>= withAttribute "Style Tags") >>~ (popContext >> popContext)))      return (attr, result)  parseRules "ctxStyle Properties" = -  do (attr, result) <- (((pDetectChar False '}' >>= withAttribute "Brackets") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetectChar False '}' >>= withAttribute "Brackets") >>~ (popContext))                         <|>                         ((pDetect2Chars False '/' '*' >>= withAttribute "Script Comment") >>~ pushContext "ctxC Style Comment")                         <|>@@ -331,7 +329,7 @@      return (attr, result)  parseRules "ctxStyle Values" = -  do (attr, result) <- (((pDetectChar False ';' >>= withAttribute "Normal Text") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetectChar False ';' >>= withAttribute "Normal Text") >>~ (popContext))                         <|>                         ((pDetectChar False ',' >>= withAttribute "Normal Text"))                         <|>

@@ -1,4 +1,4 @@-{- This module was generated from data in the Kate syntax highlighting file commonlisp.xml, version 1.02,+{- This module was generated from data in the Kate syntax highlighting file commonlisp.xml, version 1.05,    by  Dominik Haumann (dhdev@gmx.de) -}  module Text.Highlighting.Kate.Syntax.Commonlisp ( highlight, parseExpression, syntaxName, syntaxExtensions ) where@@ -47,17 +47,15 @@ parseSourceLine = manyTill parseExpressionInternal pEndLine  pEndLine = do-  newline <|> (eof >> return '\n')+  lookAhead $ newline <|> (eof >> return '\n')   context <- currentContext   case context of-    "Normal" -> return ()-    "MultiLineComment" -> return ()-    "function_decl" -> return ()-    "SpecialNumber" -> (popContext >> return ())-    "String" -> return ()-    _ -> return ()-  lineContents <- lookAhead wholeLine-  updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }+    "Normal" -> return () >> pHandleEndLine+    "MultiLineComment" -> return () >> pHandleEndLine+    "function_decl" -> return () >> pHandleEndLine+    "SpecialNumber" -> (popContext) >> pEndLine+    "String" -> return () >> pHandleEndLine+    _ -> pHandleEndLine  withAttribute attr txt = do   when (null txt) $ fail "Parser matched no text"@@ -76,7 +74,7 @@  list_symbols = Set.fromList $ words $ "< <= = > >= => - / /= // /// * ** *** + ++ +++ 1- 1+" list_definitions = Set.fromList $ words $ "defclass defconstant defgeneric define-compiler-macro define-condition define-method-combination define-modify-macro define-setf-expander define-setf-method define-symbol-macro defmacro defmethod defpackage defparameter defsetf deftype defvar defun defstruct"-list_keywords = Set.fromList $ words $ "abort abs access acons acos acosh add-method adjoin adjustable-array-p adjust-array allocate-instance alpha-char-p alphanumericp and append apply applyhook apropos apropos-list aref arithmetic-error arithmetic-error-operands arithmetic-error-operation array array-dimension array-dimension-limit array-dimensions array-displacement array-element-type array-has-fill-pointer-p array-in-bounds-p arrayp array-rank array-rank-limit array-row-major-index array-total-size array-total-size-limit ash asin asinh assert assoc assoc-if assoc-if-not atan atanh atom base-char base-string bignum bit bit-and bit-andc1 bit-andc2 bit-eqv bit-ior bit-nand bit-nor bit-not bit-orc1 bit-orc2 bit-vector bit-vector-p bit-xor block boole boole-1 boole-2 boolean boole-and boole-andc1 boole-andc2 boole-c1 boole-c2 boole-clr boole-eqv boole-ior boole-nand boole-nor boole-orc1 boole-orc2 boole-set boole-xor both-case-p boundp break broadcast-stream broadcast-stream-streams built-in-class butlast byte byte-position byte-size call-arguments-limit call-method call-next-method capitalize car case catch ccase cdr ceiling cell-error cell-error-name cerror change-class char char< char<= char= char> char>= char/= character characterp char-bit char-bits char-bits-limit char-code char-code-limit char-control-bit char-downcase char-equal char-font char-font-limit char-greaterp char-hyper-bit char-int char-lessp char-meta-bit char-name char-not-equal char-not-greaterp char-not-lessp char-super-bit char-upcase check-type cis class class-name class-of clear-input clear-output close clrhash code-char coerce commonp compilation-speed compile compiled-function compiled-function-p compile-file compile-file-pathname compiler-let compiler-macro compiler-macro-function complement complex complexp compute-applicable-methods compute-restarts concatenate concatenated-stream concatenated-stream-streams cond condition conjugate cons consp constantly constantp continue control-error copy-alist copy-list copy-pprint-dispatch copy-readtable copy-seq copy-structure copy-symbol copy-tree cos cosh count count-if count-if-not ctypecase debug decf declaim declaration declare decode-float decode-universal-time delete delete-duplicates delete-file delete-if delete-if-not delete-package denominator deposit-field describe describe-object destructuring-bind digit-char digit-char-p directory directory-namestring disassemble division-by-zero do do* do-all-symbols documentation do-exeternal-symbols do-external-symbols dolist do-symbols dotimes double-float double-float-epsilon double-float-negative-epsilon dpb dribble dynamic-extent ecase echo-stream echo-stream-input-stream echo-stream-output-stream ed eighth elt encode-universal-time end-of-file endp enough-namestring ensure-directories-exist ensure-generic-function eq eql equal equalp error etypecase eval evalhook eval-when evenp every exp export expt extended-char fboundp fceiling fdefinition ffloor fifth file-author file-error file-error-pathname file-length file-namestring file-position file-stream file-string-length file-write-date fill fill-pointer find find-all-symbols find-class find-if find-if-not find-method find-package find-restart find-symbol finish-output first fixnum flet float float-digits floating-point-inexact floating-point-invalid-operation floating-point-overflow floating-point-underflow floatp float-precision float-radix float-sign floor fmakunbound force-output format formatter fourth fresh-line fround ftruncate ftype funcall function function-keywords function-lambda-expression functionp gbitp gcd generic-function gensym gentemp get get-decoded-time get-dispatch-macro-character getf gethash get-internal-real-time get-internal-run-time get-macro-character get-output-stream-string get-properties get-setf-expansion get-setf-method get-universal-time go graphic-char-p handler-bind handler-case hash-table hash-table-count hash-table-p hash-table-rehash-size hash-table-rehash-threshold hash-table-size hash-table-test host-namestring identity if if-exists ignorable ignore ignore-errors imagpart import incf initialize-instance inline in-package in-package input-stream-p inspect int-char integer integer-decode-float integer-length integerp interactive-stream-p intern internal-time-units-per-second intersection invalid-method-error invoke-debugger invoke-restart invoke-restart-interactively isqrt keyword keywordp labels lambda lambda-list-keywords lambda-parameters-limit last lcm ldb ldb-test ldiff least-negative-double-float least-negative-long-float least-negative-normalized-double-float least-negative-normalized-long-float least-negative-normalized-short-float least-negative-normalized-single-float least-negative-short-float least-negative-single-float least-positive-double-float least-positive-long-float least-positive-normalized-double-float least-positive-normalized-long-float least-positive-normalized-short-float least-positive-normalized-single-float least-positive-short-float least-positive-single-float length let let* lisp lisp-implementation-type lisp-implementation-version list list* list-all-packages listen list-length listp load load-logical-pathname-translations load-time-value locally log logand logandc1 logandc2 logbitp logcount logeqv logical-pathname logical-pathname-translations logior lognand lognor lognot logorc1 logorc2 logtest logxor long-float long-float-epsilon long-float-negative-epsilon long-site-name loop loop-finish lower-case-p machine-instance machine-type machine-version macroexpand macroexpand-1 macroexpand-l macro-function macrolet make-array make-array make-broadcast-stream make-char make-concatenated-stream make-condition make-dispatch-macro-character make-echo-stream make-hash-table make-instance make-instances-obsolete make-list make-load-form make-load-form-saving-slots make-method make-package make-pathname make-random-state make-sequence make-string make-string-input-stream make-string-output-stream make-symbol make-synonym-stream make-two-way-stream makunbound map mapc mapcan mapcar mapcon maphash map-into mapl maplist mask-field max member member-if member-if-not merge merge-pathname merge-pathnames method method-combination method-combination-error method-qualifiers min minusp mismatch mod most-negative-double-float most-negative-fixnum most-negative-long-float most-negative-short-float most-negative-single-float most-positive-double-float most-positive-fixnum most-positive-long-float most-positive-short-float most-positive-single-float muffle-warning multiple-value-bind multiple-value-call multiple-value-list multiple-value-prog1 multiple-value-seteq multiple-value-setq multiple-values-limit name-char namestring nbutlast nconc next-method-p nil nintersection ninth no-applicable-method no-next-method not notany notevery notinline nreconc nreverse nset-difference nset-exclusive-or nstring nstring-capitalize nstring-downcase nstring-upcase nsublis nsubst nsubst-if nsubst-if-not nsubstitute nsubstitute-if nsubstitute-if-not nth nthcdr nth-value null number numberp numerator nunion oddp open open-stream-p optimize or otherwise output-stream-p package package-error package-error-package package-name package-nicknames packagep package-shadowing-symbols package-used-by-list package-use-list pairlis parse-error parse-integer parse-namestring pathname pathname-device pathname-directory pathname-host pathname-match-p pathname-name pathnamep pathname-type pathname-version peek-char phase pi plusp pop position position-if position-if-not pprint pprint-dispatch pprint-exit-if-list-exhausted pprint-fill pprint-indent pprint-linear pprint-logical-block pprint-newline pprint-pop pprint-tab pprint-tabular prin1 prin1-to-string princ princ-to-string print print-not-readable print-not-readable-object print-object print-unreadable-object probe-file proclaim prog prog* prog1 prog2 progn program-error progv provide psetf psetq push pushnew putprop quote random random-state random-state-p rassoc rassoc-if rassoc-if-not ratio rational rationalize rationalp read read-byte read-char read-char-no-hang read-delimited-list reader-error read-eval-print read-from-string read-line read-preserving-whitespace read-sequence readtable readtable-case readtablep real realp realpart reduce reinitialize-instance rem remf remhash remove remove-duplicates remove-if remove-if-not remove-method remprop rename-file rename-package replace require rest restart restart-bind restart-case restart-name return return-from revappend reverse room rotatef round row-major-aref rplaca rplacd safety satisfies sbit scale-float schar search second sequence serious-condition set set-char-bit set-difference set-dispatch-macro-character set-exclusive-or setf set-macro-character set-pprint-dispatch setq set-syntax-from-char seventh shadow shadowing-import shared-initialize shiftf short-float short-float-epsilon short-float-negative-epsilon short-site-name signal signed-byte signum simle-condition simple-array simple-base-string simple-bit-vector simple-bit-vector-p simple-condition-format-arguments simple-condition-format-control simple-error simple-string simple-string-p simple-type-error simple-vector simple-vector-p simple-warning sin single-flaot-epsilon single-float single-float-epsilon single-float-negative-epsilon sinh sixth sleep slot-boundp slot-exists-p slot-makunbound slot-missing slot-unbound slot-value software-type software-version some sort space special special-form-p special-operator-p speed sqrt stable-sort standard standard-char standard-char-p standard-class standard-generic-function standard-method standard-object step storage-condition store-value stream stream-element-type stream-error stream-error-stream stream-external-format streamp streamup string string< string<= string= string> string>= string/= string-capitalize string-char string-char-p string-downcase string-equal string-greaterp string-left-trim string-lessp string-not-equal string-not-greaterp string-not-lessp stringp string-right-strim string-right-trim string-stream string-trim string-upcase structure structure-class structure-object style-warning sublim sublis subseq subsetp subst subst-if subst-if-not substitute substitute-if substitute-if-not subtypep svref sxhash symbol symbol-function symbol-macrolet symbol-name symbolp symbol-package symbol-plist symbol-value synonym-stream synonym-stream-symbol sys system t tagbody tailp tan tanh tenth terpri the third throw time trace translate-logical-pathname translate-pathname tree-equal truename truncase truncate two-way-stream two-way-stream-input-stream two-way-stream-output-stream type typecase type-error type-error-datum type-error-expected-type type-of typep unbound-slot unbound-slot-instance unbound-variable undefined-function unexport unintern union unless unread unread-char unsigned-byte untrace unuse-package unwind-protect update-instance-for-different-class update-instance-for-redefined-class upgraded-array-element-type upgraded-complex-part-type upper-case-p use-package user user-homedir-pathname use-value values values-list vector vectorp vector-pop vector-push vector-push-extend warn warning when wild-pathname-p with-accessors with-compilation-unit with-condition-restarts with-hash-table-iterator with-input-from-string with-open-file with-open-stream with-output-to-string with-package-iterator with-simple-restart with-slots with-standard-io-syntax write write-byte write-char write-line write-sequence write-string write-to-string yes-or-no-p y-or-n-p zerop"+list_keywords = Set.fromList $ words $ "abort abs access acons acos acosh add-method adjoin adjustable-array-p adjust-array allocate-instance alpha-char-p alphanumericp and append apply applyhook apropos apropos-list aref arithmetic-error arithmetic-error-operands arithmetic-error-operation array array-dimension array-dimension-limit array-dimensions array-displacement array-element-type array-has-fill-pointer-p array-in-bounds-p arrayp array-rank array-rank-limit array-row-major-index array-total-size array-total-size-limit ash asin asinh assert assoc assoc-if assoc-if-not atan atanh atom base-char base-string bignum bit bit-and bit-andc1 bit-andc2 bit-eqv bit-ior bit-nand bit-nor bit-not bit-orc1 bit-orc2 bit-vector bit-vector-p bit-xor block boole boole-1 boole-2 boolean boole-and boole-andc1 boole-andc2 boole-c1 boole-c2 boole-clr boole-eqv boole-ior boole-nand boole-nor boole-orc1 boole-orc2 boole-set boole-xor both-case-p boundp break broadcast-stream broadcast-stream-streams built-in-class butlast byte byte-position byte-size caaaar caaadr caaar caadar caaddr caadr caar cadaar cadadr cadar caddar cadddr caddr cadr call-arguments-limit call-method call-next-method capitalize car case catch ccase cdaaar cdaadr cdaar cdadar cdaddr cdadr cdar cddaar cddadr cddar cdddar cddddr cdddr cddr cdr ceiling cell-error cell-error-name cerror change-class char char< char<= char= char> char>= char/= character characterp char-bit char-bits char-bits-limit char-code char-code-limit char-control-bit char-downcase char-equal char-font char-font-limit char-greaterp char-hyper-bit char-int char-lessp char-meta-bit char-name char-not-equal char-not-greaterp char-not-lessp char-super-bit char-upcase check-type cis class class-name class-of clear-input clear-output close clrhash code-char coerce commonp compilation-speed compile compiled-function compiled-function-p compile-file compile-file-pathname compiler-let compiler-macro compiler-macro-function complement complex complexp compute-applicable-methods compute-restarts concatenate concatenated-stream concatenated-stream-streams cond condition conjugate cons consp constantly constantp continue control-error copy-alist copy-list copy-pprint-dispatch copy-readtable copy-seq copy-structure copy-symbol copy-tree cos cosh count count-if count-if-not ctypecase debug decf declaim declaration declare decode-float decode-universal-time delete delete-duplicates delete-file delete-if delete-if-not delete-package denominator deposit-field describe describe-object destructuring-bind digit-char digit-char-p directory directory-namestring disassemble division-by-zero do do* do-all-symbols documentation do-exeternal-symbols do-external-symbols dolist do-symbols dotimes double-float double-float-epsilon double-float-negative-epsilon dpb dribble dynamic-extent ecase echo-stream echo-stream-input-stream echo-stream-output-stream ed eighth elt encode-universal-time end-of-file endp enough-namestring ensure-directories-exist ensure-generic-function eq eql equal equalp error etypecase eval evalhook eval-when evenp every exp export expt extended-char fboundp fceiling fdefinition ffloor fifth file-author file-error file-error-pathname file-length file-namestring file-position file-stream file-string-length file-write-date fill fill-pointer find find-all-symbols find-class find-if find-if-not find-method find-package find-restart find-symbol finish-output first fixnum flet float float-digits floating-point-inexact floating-point-invalid-operation floating-point-overflow floating-point-underflow floatp float-precision float-radix float-sign floor fmakunbound force-output format formatter fourth fresh-line fround ftruncate ftype funcall function function-keywords function-lambda-expression functionp gbitp gcd generic-function gensym gentemp get get-decoded-time get-dispatch-macro-character getf gethash get-internal-real-time get-internal-run-time get-macro-character get-output-stream-string get-properties get-setf-expansion get-setf-method get-universal-time go graphic-char-p handler-bind handler-case hash-table hash-table-count hash-table-p hash-table-rehash-size hash-table-rehash-threshold hash-table-size hash-table-test host-namestring identity if if-exists ignorable ignore ignore-errors imagpart import incf initialize-instance inline in-package in-package input-stream-p inspect int-char integer integer-decode-float integer-length integerp interactive-stream-p intern internal-time-units-per-second intersection invalid-method-error invoke-debugger invoke-restart invoke-restart-interactively isqrt keyword keywordp labels lambda lambda-list-keywords lambda-parameters-limit last lcm ldb ldb-test ldiff least-negative-double-float least-negative-long-float least-negative-normalized-double-float least-negative-normalized-long-float least-negative-normalized-short-float least-negative-normalized-single-float least-negative-short-float least-negative-single-float least-positive-double-float least-positive-long-float least-positive-normalized-double-float least-positive-normalized-long-float least-positive-normalized-short-float least-positive-normalized-single-float least-positive-short-float least-positive-single-float length let let* lisp lisp-implementation-type lisp-implementation-version list list* list-all-packages listen list-length listp load load-logical-pathname-translations load-time-value locally log logand logandc1 logandc2 logbitp logcount logeqv logical-pathname logical-pathname-translations logior lognand lognor lognot logorc1 logorc2 logtest logxor long-float long-float-epsilon long-float-negative-epsilon long-site-name loop loop-finish lower-case-p machine-instance machine-type machine-version macroexpand macroexpand-1 macroexpand-l macro-function macrolet make-array make-array make-broadcast-stream make-char make-concatenated-stream make-condition make-dispatch-macro-character make-echo-stream make-hash-table make-instance make-instances-obsolete make-list make-load-form make-load-form-saving-slots make-method make-package make-pathname make-random-state make-sequence make-string make-string-input-stream make-string-output-stream make-symbol make-synonym-stream make-two-way-stream makunbound map mapc mapcan mapcar mapcon maphash map-into mapl maplist mask-field max member member-if member-if-not merge merge-pathname merge-pathnames method method-combination method-combination-error method-qualifiers min minusp mismatch mod most-negative-double-float most-negative-fixnum most-negative-long-float most-negative-short-float most-negative-single-float most-positive-double-float most-positive-fixnum most-positive-long-float most-positive-short-float most-positive-single-float muffle-warning multiple-value-bind multiple-value-call multiple-value-list multiple-value-prog1 multiple-value-seteq multiple-value-setq multiple-values-limit name-char namestring nbutlast nconc next-method-p nil nintersection ninth no-applicable-method no-next-method not notany notevery notinline nreconc nreverse nset-difference nset-exclusive-or nstring nstring-capitalize nstring-downcase nstring-upcase nsublis nsubst nsubst-if nsubst-if-not nsubstitute nsubstitute-if nsubstitute-if-not nth nthcdr nth-value null number numberp numerator nunion oddp open open-stream-p optimize or otherwise output-stream-p package package-error package-error-package package-name package-nicknames packagep package-shadowing-symbols package-used-by-list package-use-list pairlis parse-error parse-integer parse-namestring pathname pathname-device pathname-directory pathname-host pathname-match-p pathname-name pathnamep pathname-type pathname-version peek-char phase pi plusp pop position position-if position-if-not pprint pprint-dispatch pprint-exit-if-list-exhausted pprint-fill pprint-indent pprint-linear pprint-logical-block pprint-newline pprint-pop pprint-tab pprint-tabular prin1 prin1-to-string princ princ-to-string print print-not-readable print-not-readable-object print-object print-unreadable-object probe-file proclaim prog prog* prog1 prog2 progn program-error progv provide psetf psetq push pushnew putprop quote random random-state random-state-p rassoc rassoc-if rassoc-if-not ratio rational rationalize rationalp read read-byte read-char read-char-no-hang read-delimited-list reader-error read-eval-print read-from-string read-line read-preserving-whitespace read-sequence readtable readtable-case readtablep real realp realpart reduce reinitialize-instance rem remf remhash remove remove-duplicates remove-if remove-if-not remove-method remprop rename-file rename-package replace require rest restart restart-bind restart-case restart-name return return-from revappend reverse room rotatef round row-major-aref rplaca rplacd safety satisfies sbit scale-float schar search second sequence serious-condition set set-char-bit set-difference set-dispatch-macro-character set-exclusive-or setf set-macro-character set-pprint-dispatch setq set-syntax-from-char seventh shadow shadowing-import shared-initialize shiftf short-float short-float-epsilon short-float-negative-epsilon short-site-name signal signed-byte signum simle-condition simple-array simple-base-string simple-bit-vector simple-bit-vector-p simple-condition-format-arguments simple-condition-format-control simple-error simple-string simple-string-p simple-type-error simple-vector simple-vector-p simple-warning sin single-flaot-epsilon single-float single-float-epsilon single-float-negative-epsilon sinh sixth sleep slot-boundp slot-exists-p slot-makunbound slot-missing slot-unbound slot-value software-type software-version some sort space special special-form-p special-operator-p speed sqrt stable-sort standard standard-char standard-char-p standard-class standard-generic-function standard-method standard-object step storage-condition store-value stream stream-element-type stream-error stream-error-stream stream-external-format streamp streamup string string< string<= string= string> string>= string/= string-capitalize string-char string-char-p string-downcase string-equal string-greaterp string-left-trim string-lessp string-not-equal string-not-greaterp string-not-lessp stringp string-right-strim string-right-trim string-stream string-trim string-upcase structure structure-class structure-object style-warning sublim sublis subseq subsetp subst subst-if subst-if-not substitute substitute-if substitute-if-not subtypep svref sxhash symbol symbol-function symbol-macrolet symbol-name symbolp symbol-package symbol-plist symbol-value synonym-stream synonym-stream-symbol sys system t tagbody tailp tan tanh tenth terpri the third throw time trace translate-logical-pathname translate-pathname tree-equal truename truncase truncate two-way-stream two-way-stream-input-stream two-way-stream-output-stream type typecase type-error type-error-datum type-error-expected-type type-of typep unbound-slot unbound-slot-instance unbound-variable undefined-function unexport unintern union unless unread unread-char unsigned-byte untrace unuse-package unwind-protect update-instance-for-different-class update-instance-for-redefined-class upgraded-array-element-type upgraded-complex-part-type upper-case-p use-package user user-homedir-pathname use-value values values-list vector vectorp vector-pop vector-push vector-push-extend warn warning when wild-pathname-p with-accessors with-compilation-unit with-condition-restarts with-hash-table-iterator with-input-from-string with-open-file with-open-stream with-output-to-string with-package-iterator with-simple-restart with-slots with-standard-io-syntax write write-byte write-char write-line write-sequence write-string write-to-string yes-or-no-p y-or-n-p zerop" list_modifiers = Set.fromList $ words $ ":abort :adjustable :append :array :base :case :circle :conc-name :constructor :copier :count :create :default :defaults :device :direction :directory :displaced-index-offset :displaced-to :element-type :end1 :end2 :end :error :escape :external :from-end :gensym :host :if-does-not-exist:pretty :if-exists:print :include:print-function :index :inherited :initial-contents :initial-element :initial-offset :initial-value :input :internal:size :io :junk-allowed :key :length :level :named :name :new-version :nicknames :output-file :output :overwrite :predicate :preserve-whitespace :probe :radix :read-only :rehash-size :rehash-threshold :rename-and-delete :rename :start1 :start2 :start :stream :supersede :test :test-not :type :use :verbose :version" list_variables = Set.fromList $ words $ "*applyhook* *break-on-signals* *break-on-signals* *break-on-warnings* *compile-file-pathname* *compile-file-pathname* *compile-file-truename* *compile-file-truename* *compile-print* *compile-verbose* *compile-verbose* *debugger-hook* *debug-io* *default-pathname-defaults* *error-output* *evalhook* *features* *gensym-counter* *load-pathname* *load-print* *load-truename* *load-verbose* *macroexpand-hook* *modules* *package* *print-array* *print-base* *print-case* *print-circle* *print-escape* *print-gensym* *print-length* *print-level* *print-lines* *print-miser-width* *print-miser-width* *print-pprint-dispatch* *print-pprint-dispatch* *print-pretty* *print-radix* *print-readably* *print-right-margin* *print-right-margin* *query-io* *random-state* *read-base* *read-default-float-format* *read-eval* *read-suppress* *readtable* *standard-input* *standard-output* *terminal-io* *trace-output*" @@ -127,27 +125,29 @@      return (attr, result)  parseRules "MultiLineComment" = -  do (attr, result) <- ((pDetect2Chars False '|' '#' >>= withAttribute "Comment") >>~ (popContext >> return ()))+  do (attr, result) <- ((pDetect2Chars False '|' '#' >>= withAttribute "Comment") >>~ (popContext))      return (attr, result)  parseRules "function_decl" = -  do (attr, result) <- ((pRegExpr regex_'5cs'2a'5bA'2dZa'2dz0'2d9'2d'2b'5c'3c'5c'3e'2f'2f'5c'2a'5d'2a'5cs'2a >>= withAttribute "Function") >>~ (popContext >> return ()))+  do (attr, result) <- ((pRegExpr regex_'5cs'2a'5bA'2dZa'2dz0'2d9'2d'2b'5c'3c'5c'3e'2f'2f'5c'2a'5d'2a'5cs'2a >>= withAttribute "Function") >>~ (popContext))      return (attr, result)  parseRules "SpecialNumber" = -  do (attr, result) <- (((pFloat >>= withAttribute "Float") >>~ (popContext >> return ()))+  do (attr, result) <- (((pFloat >>= withAttribute "Float") >>~ (popContext))                         <|>-                        ((pInt >>= withAttribute "Decimal") >>~ (popContext >> return ()))+                        ((pInt >>= withAttribute "Decimal") >>~ (popContext))                         <|>-                        ((pHlCOct >>= withAttribute "BaseN") >>~ (popContext >> return ()))+                        ((pHlCOct >>= withAttribute "BaseN") >>~ (popContext))                         <|>-                        ((pHlCHex >>= withAttribute "Float") >>~ (popContext >> return ())))+                        ((pHlCHex >>= withAttribute "Float") >>~ (popContext)))      return (attr, result)  parseRules "String" =    do (attr, result) <- (((pRegExpr regex_'23'5c'5c'2e >>= withAttribute "Char"))                         <|>-                        ((pDetectChar False '"' >>= withAttribute "String") >>~ (popContext >> return ())))+                        ((pHlCStringChar >>= withAttribute "String Char"))+                        <|>+                        ((pDetectChar False '"' >>= withAttribute "String") >>~ (popContext)))      return (attr, result)  parseRules x = fail $ "Unknown context" ++ x

@@ -1,4 +1,4 @@-{- This module was generated from data in the Kate syntax highlighting file cpp.xml, version 1.41,+{- This module was generated from data in the Kate syntax highlighting file cpp.xml, version 1.47,    by   -}  module Text.Highlighting.Kate.Syntax.Cpp ( highlight, parseExpression, syntaxName, syntaxExtensions ) where@@ -49,23 +49,21 @@ parseSourceLine = manyTill parseExpressionInternal pEndLine  pEndLine = do-  newline <|> (eof >> return '\n')+  lookAhead $ newline <|> (eof >> return '\n')   context <- currentContext   case context of-    "Normal" -> return ()-    "String" -> (popContext >> return ())-    "Region Marker" -> (popContext >> return ())-    "Commentar 1" -> (popContext >> return ())-    "Commentar 2" -> return ()-    "AfterHash" -> (popContext >> return ())-    "Preprocessor" -> (popContext >> return ())-    "Define" -> (popContext >> return ())-    "Commentar/Preprocessor" -> return ()-    "Outscoped" -> return ()-    "Outscoped intern" -> return ()-    _ -> return ()-  lineContents <- lookAhead wholeLine-  updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }+    "Normal" -> return () >> pHandleEndLine+    "String" -> (popContext) >> pEndLine+    "Region Marker" -> (popContext) >> pEndLine+    "Commentar 1" -> (popContext) >> pEndLine+    "Commentar 2" -> return () >> pHandleEndLine+    "AfterHash" -> (popContext) >> pEndLine+    "Preprocessor" -> (popContext) >> pEndLine+    "Define" -> (popContext) >> pEndLine+    "Commentar/Preprocessor" -> return () >> pHandleEndLine+    "Outscoped" -> return () >> pHandleEndLine+    "Outscoped intern" -> return () >> pHandleEndLine+    _ -> pHandleEndLine  withAttribute attr txt = do   when (null txt) $ fail "Parser matched no text"@@ -82,11 +80,11 @@   context <- currentContext   parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes)) -list_keywords = Set.fromList $ words $ "asm break case catch class const_cast continue default delete do dynamic_cast else enum explicit export extern false friend for goto if inline namespace new operator private protected public qobject_cast reinterpret_cast return sizeof static_cast struct switch template this throw true try typedef typeid type_info typename union using virtual while and and_eq bad_cast bad_typeid bitand bitor compl not not_eq or or_eq xor xor_eq except finally xalloc"-list_extensions = Set.fromList $ words $ "K_DCOP SLOT SIGNAL Q_CLASSINFO Q_ENUMS Q_EXPORT Q_OBJECT Q_OVERRIDE Q_PROPERTY Q_SETS Q_SIGNALS Q_SLOTS Q_FOREACH Q_DECLARE_FLAGS Q_INIT_RESOURCE Q_CLEANUP_RESOURCE Q_GLOBAL_STATIC Q_GLOBAL_STATIC_WITH_ARGS Q_DECLARE_INTERFACE Q_DECLARE_TYPEINFO Q_DECLARE_SHARED Q_DECLARE_FLAGS Q_DECLARE_OPERATORS_FOR_FLAGS Q_FOREVER Q_DECLARE_PRIVATE Q_DECLARE_PUBLIC Q_D Q_Q Q_DISABLE_COPY Q_INTERFACES Q_FLAGS Q_SCRIPTABLE Q_INVOKABLE Q_GADGET Q_ARG Q_RETURN_ARG Q_ASSERT Q_ASSERT_X Q_PRIVATE_SLOT Q_DECLARE_METATYPE Q_NOREPLY TRUE FALSE connect disconnect emit signals slots foreach forever"+list_keywords = Set.fromList $ words $ "asm break case catch class const_cast continue default delete do dynamic_cast else enum explicit export extern false friend for goto if inline namespace new operator private protected public qobject_cast reinterpret_cast return sizeof static_cast struct switch template this throw true try typedef typeid type_info typename union using virtual while and and_eq bad_cast bad_typeid bitand bitor compl not not_eq or or_eq xor xor_eq"+list_extensions = Set.fromList $ words $ "K_DCOP Q_ARG Q_ASSERT Q_ASSERT_X Q_CHECK_PTR Q_CLASSINFO Q_CLEANUP_RESOURCE Q_D Q_DECLARE_FLAGS Q_DECLARE_FLAGS Q_DECLARE_INTERFACE Q_DECLARE_METATYPE Q_DECLARE_OPERATORS_FOR_FLAGS Q_DECLARE_PRIVATE Q_DECLARE_PUBLIC Q_DECLARE_SHARED Q_DECLARE_TYPEINFO Q_DISABLE_COPY Q_ENUMS Q_EXPORT Q_FLAGS Q_FOREACH Q_FOREVER Q_GADGET Q_GLOBAL_STATIC Q_GLOBAL_STATIC_WITH_ARGS Q_INIT_RESOURCE Q_INTERFACES Q_INVOKABLE Q_NOREPLY Q_OBJECT Q_OVERRIDE Q_PRIVATE_SLOT Q_PROPERTY Q_Q Q_RETURN_ARG Q_SCRIPTABLE Q_SETS Q_SIGNALS Q_SLOTS Q_UNUSED SIGNAL SLOT TRUE FALSE connect disconnect emit signals slots foreach forever qint8 qint16 qint32 qint64 qlonglong qptrdiff qreal quint8 quint16 quint32 quint64 quintptr qulonglong" list_types = Set.fromList $ words $ "auto bool char const double float int long mutable register short signed static unsigned void volatile uchar uint int8_t int16_t int32_t int64_t uint8_t uint16_t uint32_t uint64_t wchar_t" -regex_'23'5cs'2aif'5cs'2b0 = compileRegex "#\\s*if\\s+0"+regex_'23'5cs'2aif'5cs'2b0'5cs'2a'24 = compileRegex "#\\s*if\\s+0\\s*$" regex_'23'5cs'2aif'28'3f'3adef'7cndef'29'3f'28'3f'3d'5cs'2b'5cS'29 = compileRegex "#\\s*if(?:def|ndef)?(?=\\s+\\S)" regex_'23'5cs'2aendif = compileRegex "#\\s*endif" regex_'23'5cs'2adefine'2e'2a'28'28'3f'3d'5c'5c'29'29 = compileRegex "#\\s*define.*((?=\\\\))"@@ -100,7 +98,7 @@ parseRules "Normal" =    do (attr, result) <- (((pDetectSpaces >>= withAttribute "Normal Text"))                         <|>-                        ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2aif'5cs'2b0 >>= withAttribute "Preprocessor") >>~ pushContext "Outscoped")+                        ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2aif'5cs'2b0'5cs'2a'24 >>= withAttribute "Preprocessor") >>~ pushContext "Outscoped")                         <|>                         ((pFirstNonSpace >> lookAhead (pDetectChar False '#') >> return ([],"") ) >>~ pushContext "AfterHash")                         <|>@@ -160,15 +158,17 @@                         <|>                         ((pHlCStringChar >>= withAttribute "String Char"))                         <|>-                        ((pDetectChar False '"' >>= withAttribute "String") >>~ (popContext >> return ())))+                        ((pDetectChar False '"' >>= withAttribute "String") >>~ (popContext)))      return (attr, result)  parseRules "Region Marker" =    pzero  parseRules "Commentar 1" = -  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Comment"))+  do (attr, result) <- (((pLineContinue >>= withAttribute "Comment"))                         <|>+                        ((pDetectSpaces >>= withAttribute "Comment"))+                        <|>                         ((Text.Highlighting.Kate.Syntax.Alert.parseExpression))                         <|>                         ((pDetectIdentifier >>= withAttribute "Comment")))@@ -177,7 +177,7 @@ parseRules "Commentar 2" =    do (attr, result) <- (((pDetectSpaces >>= withAttribute "Comment"))                         <|>-                        ((pDetect2Chars False '*' '/' >>= withAttribute "Comment") >>~ (popContext >> return ()))+                        ((pDetect2Chars False '*' '/' >>= withAttribute "Comment") >>~ (popContext))                         <|>                         ((Text.Highlighting.Kate.Syntax.Alert.parseExpression))                         <|>@@ -217,7 +217,7 @@ parseRules "Commentar/Preprocessor" =    do (attr, result) <- (((pDetectSpaces >>= withAttribute "Comment"))                         <|>-                        ((pDetect2Chars False '*' '/' >>= withAttribute "Comment") >>~ (popContext >> return ()))+                        ((pDetect2Chars False '*' '/' >>= withAttribute "Comment") >>~ (popContext))                         <|>                         ((pDetectIdentifier >>= withAttribute "Comment")))      return (attr, result)@@ -229,8 +229,6 @@                         <|>                         ((pDetectIdentifier >>= withAttribute "Comment"))                         <|>-                        ((pDetectChar False '"' >>= withAttribute "String") >>~ pushContext "String")-                        <|>                         ((Text.Highlighting.Kate.Syntax.Doxygen.parseExpression))                         <|>                         ((pDetect2Chars False '/' '/' >>= withAttribute "Comment") >>~ pushContext "Commentar 1")@@ -239,9 +237,9 @@                         <|>                         ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2aif >>= withAttribute "Comment") >>~ pushContext "Outscoped intern")                         <|>-                        ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2ael'28'3f'3ase'7cif'29 >>= withAttribute "Preprocessor") >>~ (popContext >> return ()))+                        ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2ael'28'3f'3ase'7cif'29 >>= withAttribute "Preprocessor") >>~ (popContext))                         <|>-                        ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2aendif >>= withAttribute "Preprocessor") >>~ (popContext >> return ())))+                        ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2aendif >>= withAttribute "Preprocessor") >>~ (popContext)))      return (attr, result)  parseRules "Outscoped intern" = @@ -261,7 +259,7 @@                         <|>                         ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2aif >>= withAttribute "Comment") >>~ pushContext "Outscoped intern")                         <|>-                        ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2aendif >>= withAttribute "Comment") >>~ (popContext >> return ())))+                        ((pFirstNonSpace >> pRegExpr regex_'23'5cs'2aendif >>= withAttribute "Comment") >>~ (popContext)))      return (attr, result)  parseRules x = fail $ "Unknown context" ++ x

@@ -0,0 +1,175 @@+{- This module was generated from data in the Kate syntax highlighting file cs.xml, version 1.15,+   by   -}++module Text.Highlighting.Kate.Syntax.Cs ( highlight, parseExpression, syntaxName, syntaxExtensions ) where+import Text.Highlighting.Kate.Definitions+import Text.Highlighting.Kate.Common+import qualified Text.Highlighting.Kate.Syntax.Doxygen+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 = "C#"++-- | Filename extensions for this language.+syntaxExtensions :: String+syntaxExtensions = "*.cs"++-- | 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 = "C#" }+  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 [("C#",["Normal"])], synStLanguage = "C#", synStCurrentLine = "", synStCharsParsedInLine = 0, synStPrevChar = '\n', synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}++parseSourceLine = manyTill parseExpressionInternal pEndLine++pEndLine = do+  lookAhead $ newline <|> (eof >> return '\n')+  context <- currentContext+  case context of+    "Normal" -> return () >> pHandleEndLine+    "String" -> (popContext) >> pEndLine+    "Member" -> (popContext) >> pEndLine+    "Commentar 1" -> (popContext) >> pEndLine+    "Commentar 2" -> return () >> pHandleEndLine+    _ -> pHandleEndLine++withAttribute attr txt = do+  when (null txt) $ fail "Parser matched no text"+  let labs = attr : maybeToList (lookup attr styles)+  st <- getState+  let oldCharsParsed = synStCharsParsedInLine st+  let prevchar = if null txt then '\n' else last txt+  updateState $ \st -> st { synStCharsParsedInLine = oldCharsParsed + length txt, synStPrevChar = prevchar } +  return (labs, txt)++styles = [("Keyword","kw"),("Function","fu"),("Data Type","dt"),("Decimal","dv"),("Octal","bn"),("Hex","bn"),("Float","fl"),("Char","ch"),("String","st"),("String Char","ch"),("Comment","co")]++parseExpressionInternal = do+  context <- currentContext+  parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes))++list_keywords = Set.fromList $ words $ "abstract as base break case catch class checked continue default delegate do else enum event explicit extern false for foreach finally fixed goto if implicit in interface internal is lock namespace new null operator out override params private protected public readonly ref return sealed sizeof stackalloc static struct switch this throw true try typeof unchecked unsafe using virtual while #if #else #elif #endif #define #undef #warning #error #line"+list_types = Set.fromList $ words $ "bool byte char const decimal double float int long object uint ushort ulong sbyte short string void"++regex_'5cbpartial'28'3f'3d'5cs'2b'28class'7cstruct'7cinterface'7cvoid'29'29 = compileRegex "\\bpartial(?=\\s+(class|struct|interface|void))"+regex_'5cbvar'28'3f'3d'5cs'2b'5cw'2b'5cs'2a'3d'5cs'2a'5cw'2b'29 = compileRegex "\\bvar(?=\\s+\\w+\\s*=\\s*\\w+)"+regex_'5cbyield'28'3f'3d'5cs'2b'28return'7cbreak'29'29 = compileRegex "\\byield(?=\\s+(return|break))"+regex_'5cb'28set'7cget'29'28'3f'3d'5cs'2a'5b'3b'7b'5d'29 = compileRegex "\\b(set|get)(?=\\s*[;{])"+regex_'5cbglobal'28'3f'3d'5cs'2a'3a'3a'5cs'2a'5cw'2b'29 = compileRegex "\\bglobal(?=\\s*::\\s*\\w+)"+regex_'23region'2e'2a'24 = compileRegex "#region.*$"+regex_'23endregion'2e'2a'24 = compileRegex "#endregion.*$"+regex_'5cb'5b'5f'5cw'5d'5b'5f'5cw'5cd'5d'2a'28'3f'3d'5b'5cs'5d'2a'5b'28'5d'29 = compileRegex "\\b[_\\w][_\\w\\d]*(?=[\\s]*[(])"+regex_'5b'2e'5d'7b1'2c1'7d = compileRegex "[.]{1,1}"+regex_'5cb'5b'5f'5cw'5d'5b'5f'5cw'5cd'5d'2a'28'3f'3d'5b'5cs'5d'2a'29 = compileRegex "\\b[_\\w][_\\w\\d]*(?=[\\s]*)"++defaultAttributes = [("Normal","Normal Text"),("String","String"),("Member","Normal Text"),("Commentar 1","Comment"),("Commentar 2","Comment")]++parseRules "Normal" = +  do (attr, result) <- (((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_keywords >>= withAttribute "Keyword"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_types >>= withAttribute "Data Type"))+                        <|>+                        (withChildren (pFloat >>= withAttribute "Float") ((pAnyChar "fF" >>= withAttribute "Float")))+                        <|>+                        ((pHlCOct >>= withAttribute "Octal"))+                        <|>+                        ((pHlCHex >>= withAttribute "Hex"))+                        <|>+                        (withChildren (pInt >>= withAttribute "Decimal") (((pString False "ULL" >>= withAttribute "Decimal"))+                                                                          <|>+                                                                          ((pString False "LUL" >>= withAttribute "Decimal"))+                                                                          <|>+                                                                          ((pString False "LLU" >>= withAttribute "Decimal"))+                                                                          <|>+                                                                          ((pString False "UL" >>= withAttribute "Decimal"))+                                                                          <|>+                                                                          ((pString False "LU" >>= withAttribute "Decimal"))+                                                                          <|>+                                                                          ((pString False "LL" >>= withAttribute "Decimal"))+                                                                          <|>+                                                                          ((pString False "U" >>= withAttribute "Decimal"))+                                                                          <|>+                                                                          ((pString False "L" >>= withAttribute "Decimal"))))+                        <|>+                        ((pHlCChar >>= withAttribute "Char"))+                        <|>+                        ((pDetectChar False '"' >>= withAttribute "String") >>~ pushContext "String")+                        <|>+                        ((Text.Highlighting.Kate.Syntax.Doxygen.parseExpression))+                        <|>+                        ((pDetect2Chars False '/' '/' >>= withAttribute "Comment") >>~ pushContext "Commentar 1")+                        <|>+                        ((pDetect2Chars False '/' '*' >>= withAttribute "Comment") >>~ pushContext "Commentar 2")+                        <|>+                        ((pDetectChar False '{' >>= withAttribute "Symbol"))+                        <|>+                        ((pDetectChar False '}' >>= withAttribute "Symbol"))+                        <|>+                        ((pRegExpr regex_'5cbpartial'28'3f'3d'5cs'2b'28class'7cstruct'7cinterface'7cvoid'29'29 >>= withAttribute "Keyword"))+                        <|>+                        ((pRegExpr regex_'5cbvar'28'3f'3d'5cs'2b'5cw'2b'5cs'2a'3d'5cs'2a'5cw'2b'29 >>= withAttribute "Data Type"))+                        <|>+                        ((pRegExpr regex_'5cbyield'28'3f'3d'5cs'2b'28return'7cbreak'29'29 >>= withAttribute "Keyword"))+                        <|>+                        ((pRegExpr regex_'5cb'28set'7cget'29'28'3f'3d'5cs'2a'5b'3b'7b'5d'29 >>= withAttribute "Keyword"))+                        <|>+                        ((pRegExpr regex_'5cbglobal'28'3f'3d'5cs'2a'3a'3a'5cs'2a'5cw'2b'29 >>= withAttribute "Keyword"))+                        <|>+                        ((pRegExpr regex_'23region'2e'2a'24 >>= withAttribute "Decimal"))+                        <|>+                        ((pRegExpr regex_'23endregion'2e'2a'24 >>= withAttribute "Decimal"))+                        <|>+                        ((pRegExpr regex_'5cb'5b'5f'5cw'5d'5b'5f'5cw'5cd'5d'2a'28'3f'3d'5b'5cs'5d'2a'5b'28'5d'29 >>= withAttribute "Function"))+                        <|>+                        ((pRegExpr regex_'5b'2e'5d'7b1'2c1'7d >>= withAttribute "Symbol") >>~ pushContext "Member")+                        <|>+                        ((pAnyChar ":!%&()+,-/.*<=>?[]|~^;" >>= withAttribute "Symbol")))+     return (attr, result)++parseRules "String" = +  do (attr, result) <- (((pLineContinue >>= withAttribute "String") >>~ (popContext))+                        <|>+                        ((pHlCStringChar >>= withAttribute "String Char"))+                        <|>+                        ((pDetectChar False '"' >>= withAttribute "String") >>~ (popContext)))+     return (attr, result)++parseRules "Member" = +  do (attr, result) <- (((pRegExpr regex_'5cb'5b'5f'5cw'5d'5b'5f'5cw'5cd'5d'2a'28'3f'3d'5b'5cs'5d'2a'29 >>= withAttribute "Function") >>~ (popContext))+                        <|>+                        ((popContext) >> return ([], "")))+     return (attr, result)++parseRules "Commentar 1" = +  pzero++parseRules "Commentar 2" = +  do (attr, result) <- ((pDetect2Chars False '*' '/' >>= withAttribute "Comment") >>~ (popContext))+     return (attr, result)++parseRules x = fail $ "Unknown context" ++ x

@@ -1,4 +1,4 @@-{- This module was generated from data in the Kate syntax highlighting file css.xml, version 2.01,+{- This module was generated from data in the Kate syntax highlighting file css.xml, version 2.04,    by  Wilbert Berendsen (wilbert@kde.nl) -}  module Text.Highlighting.Kate.Syntax.Css ( highlight, parseExpression, syntaxName, syntaxExtensions ) where@@ -48,31 +48,29 @@ parseSourceLine = manyTill parseExpressionInternal pEndLine  pEndLine = do-  newline <|> (eof >> return '\n')+  lookAhead $ newline <|> (eof >> return '\n')   context <- currentContext   case context of-    "Base" -> return ()-    "FindRuleSets" -> return ()-    "FindValues" -> return ()-    "FindStrings" -> return ()-    "FindComments" -> return ()-    "Media" -> return ()-    "Media2" -> return ()-    "SelAttr" -> return ()-    "SelPseudo" -> (popContext >> return ())-    "Import" -> return ()-    "Comment" -> return ()-    "RuleSet" -> return ()-    "Rule" -> return ()-    "Rule2" -> return ()-    "PropParen" -> return ()-    "PropParen2" -> return ()-    "StringDQ" -> return ()-    "StringSQ" -> return ()-    "InsideString" -> return ()-    _ -> return ()-  lineContents <- lookAhead wholeLine-  updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }+    "Base" -> return () >> pHandleEndLine+    "FindRuleSets" -> return () >> pHandleEndLine+    "FindValues" -> return () >> pHandleEndLine+    "FindStrings" -> return () >> pHandleEndLine+    "FindComments" -> return () >> pHandleEndLine+    "Media" -> return () >> pHandleEndLine+    "Media2" -> return () >> pHandleEndLine+    "SelAttr" -> return () >> pHandleEndLine+    "SelPseudo" -> (popContext) >> pEndLine+    "Import" -> return () >> pHandleEndLine+    "Comment" -> return () >> pHandleEndLine+    "RuleSet" -> return () >> pHandleEndLine+    "Rule" -> return () >> pHandleEndLine+    "Rule2" -> return () >> pHandleEndLine+    "PropParen" -> return () >> pHandleEndLine+    "PropParen2" -> return () >> pHandleEndLine+    "StringDQ" -> return () >> pHandleEndLine+    "StringSQ" -> return () >> pHandleEndLine+    "InsideString" -> return () >> pHandleEndLine+    _ -> pHandleEndLine  withAttribute attr txt = do   when (null txt) $ fail "Parser matched no text"@@ -89,10 +87,10 @@   context <- currentContext   parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes)) -list_properties = Set.fromList $ words $ "azimuth background background-attachment background-color background-image background-position background-repeat border border-bottom border-bottom-color border-bottom-style border-bottom-width border-collapse border-color border-left border-left-color border-left-style border-left-width border-right border-right-color border-right-style border-right-width border-spacing border-style border-top border-top-color border-top-style border-top-width border-width bottom caption-side clear clip color content counter-increment counter-reset cue cue-after cue-before cursor direction display elevation empty-cells float font font-family font-size font-size-adjust font-stretch font-style font-variant font-weight height left letter-spacing line-height list-style list-style-image list-style-keyword list-style-position list-style-type margin margin-bottom margin-left margin-right margin-top marker-offset max-height max-width min-height min-width orphans outline outline-color outline-style outline-width overflow padding padding-bottom padding-left padding-right padding-top page page-break-after page-break-before page-break-inside pause pause-after pause-before pitch pitch-range play-during position quotes richness right size speak speak-header speak-numeral speak-punctuation speech-rate stress table-layout text-align text-decoration text-decoration-color text-indent text-shadow text-transform top unicode-bidi vertical-align visibility voice-family volume white-space widows width word-spacing z-index border-radius box-sizing opacity text-shadow -moz-border-radius -moz-box-flex konq_bgpos_x konq_bgpos_y font-family font-size font-stretch font-style font-variant font-weight unicode-range units-per-em src panose-1 stemv stemh slope cap-height x-height ascent descent widths bbox definition-src baseline centerline mathline topline"-list_types = Set.fromList $ words $ "inherit none hidden dotted dashed solid double groove ridge inset outset xx-small x-small small medium large x-large xx-large smaller larger italic oblique small-caps normal bold bolder lighter light 100 200 300 400 500 600 700 800 900 transparent repeat repeat-x repeat-y no-repeat baseline sub super top text-top middle bottom text-bottom left right center justify konq-center disc circle square box decimal decimal-leading-zero lower-roman upper-roman lower-greek lower-alpha lower-latin upper-alpha upper-latin hebrew armenian georgian cjk-ideographic hiragana katakana hiragana-iroha katakana-iroha inline inline-block block list-item run-in compact marker table inline-table table-row-group table-header-group table-footer-group table-row table-column-group table-column table-cell table-caption auto crosshair default pointer move e-resize ne-resize nw-resize n-resize se-resize sw-resize s-resize w-resize text wait help above absolute always avoid below bidi-override blink both capitalize caption close-quote collapse condensed crop cross embed expanded extra-condensed extra-expanded fixed hand hide higher icon inside invert landscape level line-through loud lower lowercase ltr menu message-box mix narrower no-close-quote no-open-quote nowrap open-quote outside overline portrait pre pre-line pre-wrap relative rtl scroll semi-condensed semi-expanded separate show small-caption static static-position status-bar thick thin ultra-condensed ultra-expanded underline uppercase visible wider break serif sans-serif cursive fantasy monospace border-box content-box -moz-box"-list_colors = Set.fromList $ words $ "aqua black blue fuchsia gray green lime maroon navy olive purple red silver teal white yellow activeborder activecaption appworkspace background buttonface buttonhighlight buttonshadow buttontext captiontext graytext highlight highlighttext inactiveborder inactivecaption inactivecaptiontext infobackground infotext menu menutext scrollbar threeddarkshadow threedface threedhighlight threedlightshadow threedshadow window windowframe windowtext"-list_paren = Set.fromList $ words $ "url attr rect rgb counter counters local format expression"+list_properties = Set.fromList $ words $ "azimuth background background-attachment background-color background-image background-position background-repeat border border-bottom border-bottom-color border-bottom-style border-bottom-width border-collapse border-color border-left border-left-color border-left-style border-left-width border-right border-right-color border-right-style border-right-width border-spacing border-style border-top border-top-color border-top-style border-top-width border-width bottom caption-side clear clip color content counter-increment counter-reset cue cue-after cue-before cursor direction display elevation empty-cells float font font-family font-size font-size-adjust font-stretch font-style font-variant font-weight height left letter-spacing line-height list-style list-style-image list-style-keyword list-style-position list-style-type margin margin-bottom margin-left margin-right margin-top marker-offset max-height max-width min-height min-width orphans outline outline-color outline-style outline-width overflow padding padding-bottom padding-left padding-right padding-top page page-break-after page-break-before page-break-inside pause pause-after pause-before pitch pitch-range play-during position quotes richness right size speak speak-header speak-numeral speak-punctuation speech-rate stress table-layout text-align text-decoration text-decoration-color text-indent text-shadow text-transform top unicode-bidi vertical-align visibility voice-family volume white-space widows width word-spacing z-index border-bottom-image border-bottom-left-image border-bottom-left-radius border-bottom-right-image border-bottom-right-radius border-corner-image border-image border-left-image border-radius border-right-image border-top-image border-top-left-image border-top-left-radius border-top-right-image border-top-right-radius box-shadow box-sizing opacity outline-offset overflow-x overflow-y text-overflow text-shadow -moz-border-bottom-colors -moz-border-left-colors -moz-border-radius -moz-border-right-colors -moz-border-top-colors -moz-box-flex -o-background-size -o-text-overflow -khtml-background-size konq_bgpos_x konq_bgpos_y -webkit-background-size font-family font-size font-stretch font-style font-variant font-weight unicode-range units-per-em src panose-1 stemv stemh slope cap-height x-height ascent descent widths bbox definition-src baseline centerline mathline topline"+list_types = Set.fromList $ words $ "inherit none hidden dotted dashed solid double groove ridge inset outset xx-small x-small small medium large x-large xx-large smaller larger italic oblique small-caps normal bold bolder lighter light 100 200 300 400 500 600 700 800 900 transparent repeat repeat-x repeat-y no-repeat baseline sub super top text-top middle bottom text-bottom left right center justify konq-center disc circle square box decimal decimal-leading-zero lower-roman upper-roman lower-greek lower-alpha lower-latin upper-alpha upper-latin hebrew armenian georgian cjk-ideographic hiragana katakana hiragana-iroha katakana-iroha inline inline-block block list-item run-in compact marker table inline-table table-row-group table-header-group table-footer-group table-row table-column-group table-column table-cell table-caption auto crosshair default pointer move e-resize ne-resize nw-resize n-resize se-resize sw-resize s-resize w-resize text wait help above absolute always avoid below bidi-override blink both capitalize caption clip close-quote collapse condensed crop cross ellipsis ellipsis-word embed expanded extra-condensed extra-expanded fixed hand hide higher icon inside invert landscape level line-through loud lower lowercase ltr menu message-box mix narrower no-close-quote no-open-quote nowrap open-quote outside overline portrait pre pre-line pre-wrap relative rtl scroll semi-condensed semi-expanded separate show small-caption static static-position status-bar thick thin ultra-condensed ultra-expanded underline uppercase visible wider break serif sans-serif cursive fantasy monospace border-box content-box -moz-box"+list_colors = Set.fromList $ words $ "aqua black blue cyan fuchsia gray green lime maroon navy olive purple red silver teal white yellow activeborder activecaption appworkspace background buttonface buttonhighlight buttonshadow buttontext captiontext graytext highlight highlighttext inactiveborder inactivecaption inactivecaptiontext infobackground infotext menu menutext scrollbar threeddarkshadow threedface threedhighlight threedlightshadow threedshadow window windowframe windowtext"+list_paren = Set.fromList $ words $ "url attr rect rgb rgba hsl hsla counter counters local format expression" list_mediatypes = Set.fromList $ words $ "all aural braille embossed handheld print projection screen tty tv" list_pseudoclasses = Set.fromList $ words $ "hover link visited active focus first-child last-child only-child first-of-type last-of-type only-of-type first-letter first-line before after selection root empty target enabled disabled checked indeterminate nth-child nth-last-child nth-of-type nth-last-of-type not" @@ -183,25 +181,25 @@      return (attr, result)  parseRules "Media2" = -  do (attr, result) <- (((pDetectChar False '}' >>= withAttribute "Media") >>~ (popContext >> popContext >> return ()))+  do (attr, result) <- (((pDetectChar False '}' >>= withAttribute "Media") >>~ (popContext >> popContext))                         <|>                         ((parseRules "FindRuleSets")))      return (attr, result)  parseRules "SelAttr" = -  do (attr, result) <- (((pDetectChar False ']' >>= withAttribute "Selector Attr") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetectChar False ']' >>= withAttribute "Selector Attr") >>~ (popContext))                         <|>                         ((parseRules "FindStrings")))      return (attr, result)  parseRules "SelPseudo" = -  do (attr, result) <- (((pKeyword " \n\t.():!+,<=>&*/;?[]^{|}~\\" list_pseudoclasses >>= withAttribute "Selector Pseudo") >>~ (popContext >> return ()))+  do (attr, result) <- (((pKeyword " \n\t.():!+,<=>&*/;?[]^{|}~\\" list_pseudoclasses >>= withAttribute "Selector Pseudo") >>~ (popContext))                         <|>-                        ((popContext >> return ()) >> return ([], "")))+                        ((popContext) >> return ([], "")))      return (attr, result)  parseRules "Import" = -  do (attr, result) <- (((pDetectChar False ';' >>= withAttribute "At Rule") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetectChar False ';' >>= withAttribute "At Rule") >>~ (popContext))                         <|>                         ((pKeyword " \n\t.():!+,<=>&*/;?[]^{|}~\\" list_mediatypes >>= withAttribute "Media"))                         <|>@@ -215,7 +213,7 @@ parseRules "Comment" =    do (attr, result) <- (((pDetectSpaces >>= withAttribute "Comment"))                         <|>-                        ((pDetect2Chars False '*' '/' >>= withAttribute "Comment") >>~ (popContext >> return ()))+                        ((pDetect2Chars False '*' '/' >>= withAttribute "Comment") >>~ (popContext))                         <|>                         ((Text.Highlighting.Kate.Syntax.Alert.parseExpression))                         <|>@@ -223,7 +221,7 @@      return (attr, result)  parseRules "RuleSet" = -  do (attr, result) <- (((pDetectChar False '}' >>= withAttribute "Property") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetectChar False '}' >>= withAttribute "Property") >>~ (popContext))                         <|>                         ((pKeyword " \n\t.():!+,<=>&*/;?[]^{|}~\\" list_properties >>= withAttribute "Property") >>~ pushContext "Rule")                         <|>@@ -241,9 +239,9 @@      return (attr, result)  parseRules "Rule2" = -  do (attr, result) <- (((pDetectChar False ';' >>= withAttribute "Property") >>~ (popContext >> popContext >> return ()))+  do (attr, result) <- (((pDetectChar False ';' >>= withAttribute "Property") >>~ (popContext >> popContext))                         <|>-                        ((pDetectChar False '}' >>= withAttribute "Property") >>~ (popContext >> popContext >> popContext >> return ()))+                        ((pDetectChar False '}' >>= withAttribute "Property") >>~ (popContext >> popContext >> popContext))                         <|>                         ((pKeyword " \n\t.():!+,<=>&*/;?[]^{|}~\\" list_types >>= withAttribute "Value"))                         <|>@@ -271,7 +269,7 @@      return (attr, result)  parseRules "PropParen2" = -  do (attr, result) <- (((pDetectChar False ')' >>= withAttribute "Value") >>~ (popContext >> popContext >> return ()))+  do (attr, result) <- (((pDetectChar False ')' >>= withAttribute "Value") >>~ (popContext >> popContext))                         <|>                         ((parseRules "FindValues"))                         <|>@@ -281,13 +279,13 @@      return (attr, result)  parseRules "StringDQ" = -  do (attr, result) <- (((pDetectChar False '"' >>= withAttribute "String") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetectChar False '"' >>= withAttribute "String") >>~ (popContext))                         <|>                         ((parseRules "InsideString")))      return (attr, result)  parseRules "StringSQ" = -  do (attr, result) <- (((pDetectChar False '\'' >>= withAttribute "String") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetectChar False '\'' >>= withAttribute "String") >>~ (popContext))                         <|>                         ((parseRules "InsideString")))      return (attr, result)

@@ -0,0 +1,106 @@+{- This module was generated from data in the Kate syntax highlighting file cue.xml, version 0.91,+   by   -}++module Text.Highlighting.Kate.Syntax.Cue ( 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 = "CUE Sheet"++-- | Filename extensions for this language.+syntaxExtensions :: String+syntaxExtensions = "*.cue"++-- | 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 = "CUE Sheet" }+  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 [("CUE Sheet",["Normal"])], synStLanguage = "CUE Sheet", synStCurrentLine = "", synStCharsParsedInLine = 0, synStPrevChar = '\n', synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}++parseSourceLine = manyTill parseExpressionInternal pEndLine++pEndLine = do+  lookAhead $ newline <|> (eof >> return '\n')+  context <- currentContext+  case context of+    "Normal" -> return () >> pHandleEndLine+    "String" -> (popContext) >> pEndLine+    "Comment" -> (popContext) >> pEndLine+    _ -> pHandleEndLine++withAttribute attr txt = do+  when (null txt) $ fail "Parser matched no text"+  let labs = attr : maybeToList (lookup attr styles)+  st <- getState+  let oldCharsParsed = synStCharsParsedInLine st+  let prevchar = if null txt then '\n' else last txt+  updateState $ \st -> st { synStCharsParsedInLine = oldCharsParsed + length txt, synStPrevChar = prevchar } +  return (labs, txt)++styles = [("Keyword","kw"),("Decimal","dv"),("String","st"),("Comment","co")]++parseExpressionInternal = do+  context <- currentContext+  parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes))++list_keywords = Set.fromList $ words $ "catalog cdtextfile file flags index isrc performer pregap postgap rem songwriter title track"+list_format = Set.fromList $ words $ "aiff wave mp3 binary mototola"+list_mode = Set.fromList $ words $ "audio cdg cdi mode1 mode2 raw"+list_flags = Set.fromList $ words $ "4ch dcp pre scms"+++defaultAttributes = [("Normal","Normal Text"),("String","String"),("Comment","Comment")]++parseRules "Normal" = +  do (attr, result) <- (((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_keywords >>= withAttribute "Keyword"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_format >>= withAttribute "Format"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_mode >>= withAttribute "Mode"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_flags >>= withAttribute "Flags"))+                        <|>+                        ((pInt >>= withAttribute "Decimal"))+                        <|>+                        ((pDetectChar False '"' >>= withAttribute "String") >>~ pushContext "String")+                        <|>+                        ((pDetectChar False ';' >>= withAttribute "Comment") >>~ pushContext "Comment"))+     return (attr, result)++parseRules "String" = +  do (attr, result) <- (((pLineContinue >>= withAttribute "String"))+                        <|>+                        ((pDetectChar False '"' >>= withAttribute "String") >>~ (popContext)))+     return (attr, result)++parseRules "Comment" = +  pzero++parseRules x = fail $ "Unknown context" ++ x

@@ -1,9 +1,10 @@-{- This module was generated from data in the Kate syntax highlighting file d.xml, version 1.43,-   by  Aziz Köksal (aziz.koeksal@gmail.com), Jari-Matti Mäkelä (jmjm@iki.fi), Simon J Mackenzie (project.katedxml@smackoz.fastmail.fm) -}+{- This module was generated from data in the Kate syntax highlighting file d.xml, version 1.61,+   by  Diggory Hardy (diggory.hardy@gmail.com), Aziz Köksal (aziz.koeksal@gmail.com), Jari-Matti Mäkelä (jmjm@iki.fi), Simon J Mackenzie (project.katedxml@smackoz.fastmail.fm) -}  module Text.Highlighting.Kate.Syntax.D ( highlight, parseExpression, syntaxName, syntaxExtensions ) where import Text.Highlighting.Kate.Definitions import Text.Highlighting.Kate.Common+import qualified Text.Highlighting.Kate.Syntax.Alert import Text.ParserCombinators.Parsec import Control.Monad (when) import Data.Map (fromList)@@ -47,31 +48,49 @@ parseSourceLine = manyTill parseExpressionInternal pEndLine  pEndLine = do-  newline <|> (eof >> return '\n')+  lookAhead $ newline <|> (eof >> return '\n')   context <- currentContext   case context of-    "normal" -> return ()-    "UnicodeShort" -> (popContext >> return ())-    "UnicodeLong" -> (popContext >> return ())-    "HTMLEntity" -> (popContext >> return ())-    "ModuleName" -> return ()-    "Deprecated" -> return ()-    "Linkage" -> (popContext >> return ())-    "Linkage2" -> (popContext >> return ())-    "Version" -> (popContext >> return ())-    "Version2" -> (popContext >> return ())-    "Pragmas" -> (popContext >> return ())-    "RawString" -> return ()-    "BQString" -> return ()-    "HexString" -> return ()-    "CharLiteral" -> (popContext >> return ())-    "String" -> return ()-    "CommentLine" -> (popContext >> return ())-    "CommentBlock" -> return ()-    "CommentNested" -> return ()-    _ -> return ()-  lineContents <- lookAhead wholeLine-  updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }+    "normal" -> return () >> pHandleEndLine+    "StartingLetter" -> (popContext) >> pEndLine+    "Properties" -> return () >> pHandleEndLine+    "NumberLiteral" -> return () >> pHandleEndLine+    "LinePragma" -> (popContext) >> pEndLine+    "UnicodeShort" -> (popContext) >> pEndLine+    "UnicodeLong" -> (popContext) >> pEndLine+    "HTMLEntity" -> (popContext) >> pEndLine+    "ModuleName" -> return () >> pHandleEndLine+    "Linkage" -> return () >> pHandleEndLine+    "Linkage2" -> return () >> pHandleEndLine+    "Version" -> return () >> pHandleEndLine+    "Version2" -> return () >> pHandleEndLine+    "Scope" -> return () >> pHandleEndLine+    "Scope2" -> return () >> pHandleEndLine+    "Pragma" -> return () >> pHandleEndLine+    "Pragma2" -> return () >> pHandleEndLine+    "RawString" -> return () >> pHandleEndLine+    "BQString" -> return () >> pHandleEndLine+    "HexString" -> return () >> pHandleEndLine+    "CharLiteral" -> pushContext "CharLiteralClosing" >> pHandleEndLine+    "CharLiteralClosing" -> (popContext >> popContext) >> pEndLine+    "String" -> return () >> pHandleEndLine+    "CommentRules" -> (popContext) >> pEndLine+    "Region Marker" -> (popContext) >> pEndLine+    "CommentLine" -> (popContext) >> pEndLine+    "CommentBlock" -> return () >> pHandleEndLine+    "CommentNested" -> return () >> pHandleEndLine+    "DdocNormal" -> return () >> pHandleEndLine+    "DdocLine" -> (popContext) >> pEndLine+    "DdocBlock" -> return () >> pHandleEndLine+    "DdocNested" -> return () >> pHandleEndLine+    "DdocNested2" -> return () >> pHandleEndLine+    "DdocMacro" -> return () >> pHandleEndLine+    "DdocMacro2" -> return () >> pHandleEndLine+    "DdocMacro3" -> return () >> pHandleEndLine+    "MacroRules" -> return () >> pHandleEndLine+    "DdocBlockCode" -> return () >> pHandleEndLine+    "DdocNestedCode" -> return () >> pHandleEndLine+    _ -> pHandleEndLine  withAttribute attr txt = do   when (null txt) $ fail "Parser matched no text"@@ -82,266 +101,544 @@   updateState $ \st -> st { synStCharsParsedInLine = oldCharsParsed + length txt, synStPrevChar = prevchar }    return (labs, txt) -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")]+styles = [("Statement","kw"),("Expression","kw"),("Declarator","kw"),("Template","kw"),("Attribute","kw"),("Deprecated","kw"),("Property","dt"),("Type","dt"),("LibrarySymbols","dt"),("UserKeywords","dt"),("Module","kw"),("Pragma","kw"),("Version","kw"),("Linkage","kw"),("Tests","kw"),("Comment","co"),("Region Marker","re"),("Error","er"),("Integer","dv"),("Binary","bn"),("Octal","bn"),("Hex","bn"),("Float","fl"),("EscapeSequence","st"),("String","st"),("Char","ch"),("RawString","st"),("BQString","st"),("HexString","st"),("Macros","ot"),("Ddoc","co"),("DdocSection","kw")]  parseExpressionInternal = do   context <- currentContext   parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes)) -list_keywords = Set.fromList $ words $ "abstract alias align asm auto body break case cast catch class const continue default delegate delete do else enum export false final finally for foreach foreach_reverse function goto if in inout interface invariant is lazy macro mixin new null out override package private protected public ref return scope static struct super switch synchronized template this throw true try typedef typeid typeof union volatile while with"-list_deprecated = Set.fromList $ words $ "deprecated"+list_userkeywords = Set.fromList $ words $ ""+list_statements = Set.fromList $ words $ "asm body break case catch continue default do else finally for foreach foreach_reverse goto if mixin return switch throw try while with synchronized"+list_attributes = Set.fromList $ words $ "abstract align auto const export final inout invariant lazy nothrow override package private protected public pure ref static out scope"+list_expressions = Set.fromList $ words $ "false null super this true typeid assert cast is new delete in delegate function" list_modules = Set.fromList $ words $ "module import"-list_types = Set.fromList $ words $ "void bool byte ubyte short ushort int uint long ulong cent ucent float double real ireal ifloat idouble creal cfloat cdouble char wchar dchar"-list_libsymbols = Set.fromList $ words $ "string wstring dstring size_t ptrdiff_t hash_t Error Exception Object TypeInfo ClassInfo"+list_declarators = Set.fromList $ words $ "alias enum typedef class interface struct union"+list_types = Set.fromList $ words $ "typeof void bool byte ubyte short ushort int uint long ulong cent ucent float double real ireal ifloat idouble creal cfloat cdouble char wchar dchar"+list_templates = Set.fromList $ words $ "macro template"+list_properties = Set.fromList $ words $ "init sizeof alignof mangleof stringof tupleof offsetof max min infinity nan dig epsilon mant_dig max_10_exp max_exp min_10_exp min_exp re im length ptr dup idup reverse sort keys values rehash"+list_libsymbols = Set.fromList $ words $ "size_t ptrdiff_t hash_t Error Exception Object TypeInfo ClassInfo ModuleInfo Interface OffsetTypeInfo TypeInfo_Typedef TypeInfo_Enum TypeInfo_Pointer TypeInfo_Array TypeInfo_StaticArray TypeInfo_AssociativeArray TypeInfo_Function TypeInfo_Delegate TypeInfo_Class TypeInfo_Interface TypeInfo_Struct TypeInfo_Tuple string wstring dstring bit TypeInfo_Const TypeInfo_Invariant" list_linkage = Set.fromList $ words $ "extern" list_ltypes = Set.fromList $ words $ "C D Windows Pascal System"-list_debug = Set.fromList $ words $ "debug"-list_assert = Set.fromList $ words $ "assert"-list_pragma = Set.fromList $ words $ "pragma" list_ptypes = Set.fromList $ words $ "msg lib"-list_version = Set.fromList $ words $ "version"-list_vtypes = Set.fromList $ words $ "DigitalMars X86 AMD64 Windows Win32 Win64 linux LittleEndian BigEndian D_InlineAsm none"+list_scope'5fkeywords = Set.fromList $ words $ "exit success failure"+list_vtypes = Set.fromList $ words $ "DigitalMars X86 X86_64 Windows Win32 Win64 linux LittleEndian BigEndian D_Coverage D_InlineAsm_X86 unittest D_Version2 none all" list_specialtokens = Set.fromList $ words $ "__FILE__ __LINE__ __DATE__ __TIME__ __TIMESTAMP__ __VENDOR__ __VERSION__ __EOF__"-list_unittest = Set.fromList $ words $ "unittest"+list_tests = Set.fromList $ words $ "debug unittest"+list_pragma = Set.fromList $ words $ "pragma"+list_version = Set.fromList $ words $ "version"+list_deprecated = Set.fromList $ words $ "deprecated volatile" -regex_0'5bxX'5d'5b'5fa'2dfA'2dF'5cd'5d'2a'28'5c'2e'5b'5fa'2dfA'2dF'5cd'5d'2a'29'3f'5bpP'5d'5b'2d'2b'5d'3f'5b'5cd'5d'2b'5b'5f'5cd'5d'2a'5bfFL'5d'3fi'3f = compileRegex "0[xX][_a-fA-F\\d]*(\\.[_a-fA-F\\d]*)?[pP][-+]?[\\d]+[_\\d]*[fFL]?i?"-regex_'5b'5cd'5d'5b'5f'5cd'5d'2a'28'5c'2e'28'3f'21'5c'2e'29'5b'5f'5cd'5d'2a'28'5beE'5d'5b'2d'2b'5d'3f'5b'5cd'5d'2b'5b'5f'5cd'5d'2a'29'3f'5bfFL'5d'3fi'3f'7c'5beE'5d'5b'2d'2b'5d'3f'5b'5cd'5d'2b'5b'5f'5cd'5d'2a'5bfFL'5d'3fi'3f'7c'5bfF'5di'3f'7c'5bfFL'5d'3fi'29 = compileRegex "[\\d][_\\d]*(\\.(?!\\.)[_\\d]*([eE][-+]?[\\d]+[_\\d]*)?[fFL]?i?|[eE][-+]?[\\d]+[_\\d]*[fFL]?i?|[fF]i?|[fFL]?i)"-regex_'5c'2e'5b'5cd'5d'5b'5f'5cd'5d'2a'28'5beE'5d'5b'2d'2b'5d'3f'5b'5cd'5d'2b'5b'5f'5cd'5d'2a'29'3f'5bfFL'5d'3fi'3f = compileRegex "\\.[\\d][_\\d]*([eE][-+]?[\\d]+[_\\d]*)?[fFL]?i?"+regex_'5ba'2dzA'2dZ'5f'5d = compileRegex "[a-zA-Z_]"+regex_'5c'2e'5cd'5b'5cd'5f'5d'2a'28'5beE'5d'5b'2d'2b'5d'3f'5cd'5b'5cd'5f'5d'2a'29'3f'5bfFL'5d'3fi'3f = compileRegex "\\.\\d[\\d_]*([eE][-+]?\\d[\\d_]*)?[fFL]?i?"+regex_'5cd = compileRegex "\\d"+regex_'5b'5ea'2dzA'2dZ'5f'5d = compileRegex "[^a-zA-Z_]"+regex_in'5cs'2a'28'3f'3d'5c'7b'29 = compileRegex "in\\s*(?=\\{)"+regex_out'5cs'2a'28'3f'3d'28'5c'28'28'5ba'2dzA'2dZ'5f'5d'5b'5cw'5f'5d'2a'29'3f'5c'29'5cs'2a'29'3f'5c'7b'29 = compileRegex "out\\s*(?=(\\(([a-zA-Z_][\\w_]*)?\\)\\s*)?\\{)"+regex_scope'5cs'2a'28'3f'3d'5c'28'29 = compileRegex "scope\\s*(?=\\()"+regex_import'5cs'2a'28'3f'3d'5c'28'29 = compileRegex "import\\s*(?=\\()"+regex_function'5cs'2a'28'3f'3d'5c'28'29 = compileRegex "function\\s*(?=\\()"+regex_delegate'5cs'2a'28'3f'3d'5c'28'29 = compileRegex "delegate\\s*(?=\\()"+regex_0'5bxX'5d'5b'5cda'2dfA'2dF'5f'5d'2a'28'5c'2e'5b'5cda'2dfA'2dF'5f'5d'2a'29'3f'5bpP'5d'5b'2d'2b'5d'3f'5cd'5b'5cd'5f'5d'2a'5bfFL'5d'3fi'3f = compileRegex "0[xX][\\da-fA-F_]*(\\.[\\da-fA-F_]*)?[pP][-+]?\\d[\\d_]*[fFL]?i?"+regex_'5cd'5b'5f'5cd'5d'2a'28'5c'2e'28'3f'21'5c'2e'29'5b'5f'5cd'5d'2a'28'5beE'5d'5b'2d'2b'5d'3f'5cd'5b'5f'5cd'5d'2a'29'3f'5bfFL'5d'3fi'3f'7c'5beE'5d'5b'2d'2b'5d'3f'5cd'5b'5f'5cd'5d'2a'5bfFL'5d'3fi'3f'7c'5bfF'5di'3f'7c'5bfFL'5d'3fi'29 = compileRegex "\\d[_\\d]*(\\.(?!\\.)[_\\d]*([eE][-+]?\\d[_\\d]*)?[fFL]?i?|[eE][-+]?\\d[_\\d]*[fFL]?i?|[fF]i?|[fFL]?i)" regex_0'5bbB'5d'5f'2a'5b01'5d'5b01'5f'5d'2a'28L'5buU'5d'3f'7c'5buU'5dL'3f'29'3f = compileRegex "0[bB]_*[01][01_]*(L[uU]?|[uU]L?)?"-regex_0'5f'2a'5b0'2d7'5d'5b0'2d7'5f'5d'2a'28L'5buU'5d'3f'7c'5buU'5dL'3f'29'3f = compileRegex "0_*[0-7][0-7_]*(L[uU]?|[uU]L?)?"+regex_0'5b0'2d7'5f'5d'2b'28L'5buU'5d'3f'7c'5buU'5dL'3f'29'3f = compileRegex "0[0-7_]+(L[uU]?|[uU]L?)?" regex_0'5bxX'5d'5f'2a'5b'5cda'2dfA'2dF'5d'5b'5cda'2dfA'2dF'5f'5d'2a'28L'5buU'5d'3f'7c'5buU'5dL'3f'29'3f = compileRegex "0[xX]_*[\\da-fA-F][\\da-fA-F_]*(L[uU]?|[uU]L?)?" regex_'5cd'2b'5b'5cd'5f'5d'2a'28L'5buU'5d'3f'7c'5buU'5dL'3f'29'3f = compileRegex "\\d+[\\d_]*(L[uU]?|[uU]L?)?"+regex_'28'280'28'5b0'2d7'5f'5d'2b'7c'5bbB'5d'5f'2a'5b01'5d'5b01'5f'5d'2a'7c'5bxX'5d'5f'2a'5b'5cda'2dfA'2dF'5d'5b'5cda'2dfA'2dF'5f'5d'2a'29'29'7c'5cd'2b'5b'5cd'5f'5d'2a'29'28L'5buU'5d'3f'7c'5buU'5dL'3f'29'3f = compileRegex "((0([0-7_]+|[bB]_*[01][01_]*|[xX]_*[\\da-fA-F][\\da-fA-F_]*))|\\d+[\\d_]*)(L[uU]?|[uU]L?)?"+regex_'22'5b'5e'22'5d'2a'22 = compileRegex "\"[^\"]*\""+regex_'2e'2b = compileRegex ".+" regex_'5b'5cda'2dfA'2dF'5d'7b4'7d = compileRegex "[\\da-fA-F]{4}" regex_'5b'5cda'2dfA'2dF'5d'7b8'7d = compileRegex "[\\da-fA-F]{8}" regex_'5ba'2dzA'2dZ'5d'5cw'2b'3b = compileRegex "[a-zA-Z]\\w+;"-regex_'5b'5e'5cs'5cw'2e'3a'2c'5d = compileRegex "[^\\s\\w.:,]"-regex_'5b'3b'28'7b'3d'5d = compileRegex "[;({=]"-regex_'5b'5e'29'5d'2b = compileRegex "[^)]+"-regex_'5b'5e'5cn'5d'2b = compileRegex "[^\\n]+"-regex_'5b'5e'29'3b'5d'2b = compileRegex "[^);]+"+regex_'5b'5e'5cs'5cw'2e'3a'2c'3d'5d = compileRegex "[^\\s\\w.:,=]"+regex_'5b'5e'29'5cs'5cn'5d'2b = compileRegex "[^)\\s\\n]+"+regex_'5b'5e'5cs'5cn'5d'2b = compileRegex "[^\\s\\n]+" regex_'5b'5e'5csa'2dfA'2dF'5cd'22'5d'2b = compileRegex "[^\\sa-fA-F\\d\"]+" regex_'5c'5c'28u'5b'5cda'2dfA'2dF'5d'7b4'7d'7cU'5b'5cda'2dfA'2dF'5d'7b8'7d'7c'26'5ba'2dzA'2dZ'5d'5cw'2b'3b'29 = compileRegex "\\\\(u[\\da-fA-F]{4}|U[\\da-fA-F]{8}|&[a-zA-Z]\\w+;)"-regex_'2e'27 = compileRegex ".'"+regex_'5c'5c'2e = compileRegex "\\\\."+regex_'2e = compileRegex "."+regex_'2f'7b3'2c'7d = compileRegex "/{3,}"+regex_'2f'5c'2a'7b2'2c'7d'28'3f'21'2f'29 = compileRegex "/\\*{2,}(?!/)"+regex_'2f'5c'2b'7b2'2c'7d'28'3f'21'2f'29 = compileRegex "/\\+{2,}(?!/)"+regex_'5b'5cw'5f'5d'2b'3a'28'24'7c'5cs'29 = compileRegex "[\\w_]+:($|\\s)"+regex_'5c'2a'2b'2f = compileRegex "\\*+/"+regex_'5b'5e'2d'5d'2d'7b3'2c'7d = compileRegex "[^-]-{3,}"+regex_'2d'7b3'2c'7d'28'24'7c'5cs'29 = compileRegex "-{3,}($|\\s)"+regex_'5c'2b'2b'2f = compileRegex "\\++/" -defaultAttributes = [("normal","Normal Text"),("UnicodeShort","EscapeString"),("UnicodeLong","EscapeString"),("HTMLEntity","EscapeString"),("ModuleName","Module Name"),("Deprecated","Deprecated"),("Linkage","Linkage"),("Linkage2","Linkage"),("Version","Version"),("Version2","Version"),("Pragmas","Pragma"),("RawString","RawString"),("BQString","BQString"),("HexString","HexString"),("CharLiteral","Char"),("String","String"),("CommentLine","Comment"),("CommentBlock","Comment"),("CommentNested","Comment")]+defaultAttributes = [("normal","Normal Text"),("StartingLetter","Normal Text"),("Properties","Normal Text"),("NumberLiteral","Normal Text"),("LinePragma","Pragma"),("UnicodeShort","EscapeSequence"),("UnicodeLong","EscapeSequence"),("HTMLEntity","EscapeSequence"),("ModuleName","Module Name"),("Linkage","Normal Text"),("Linkage2","Normal Text"),("Version","Normal Text"),("Version2","Normal Text"),("Scope","Normal Text"),("Scope2","Normal Text"),("Pragma","Pragma"),("Pragma2","Pragma"),("RawString","RawString"),("BQString","BQString"),("HexString","HexString"),("CharLiteral","Char"),("CharLiteralClosing","Error"),("String","String"),("CommentRules","Normal Text"),("Region Marker","Region Marker"),("CommentLine","Comment"),("CommentBlock","Comment"),("CommentNested","Comment"),("DdocNormal","Normal Text"),("DdocLine","Ddoc"),("DdocBlock","Ddoc"),("DdocNested","Ddoc"),("DdocNested2","Ddoc"),("DdocMacro","Error"),("DdocMacro2","Macro Text"),("DdocMacro3","Macro Text"),("MacroRules","Macro Text"),("DdocBlockCode","DdocCode"),("DdocNestedCode","DdocCode")]  parseRules "normal" = -  do (attr, result) <- (((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_keywords >>= withAttribute "Keyword"))+  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Normal Text"))                         <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_modules >>= withAttribute "Module") >>~ pushContext "ModuleName")+                        ((lookAhead (pRegExpr regex_'5ba'2dzA'2dZ'5f'5d) >> return ([],"") ) >>~ pushContext "StartingLetter")                         <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_types >>= withAttribute "Type"))+                        ((pHlCStringChar >>= withAttribute "EscapeSequence"))                         <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_libsymbols >>= withAttribute "LibrarySymbols"))+                        ((pDetect2Chars False '\\' 'u' >>= withAttribute "EscapeSequence") >>~ pushContext "UnicodeShort")                         <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_linkage >>= withAttribute "Linkage") >>~ pushContext "Linkage")+                        ((pDetect2Chars False '\\' 'U' >>= withAttribute "EscapeSequence") >>~ pushContext "UnicodeLong")                         <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_debug >>= withAttribute "Debug"))+                        ((pDetect2Chars False '\\' '&' >>= withAttribute "EscapeSequence") >>~ pushContext "HTMLEntity")                         <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_assert >>= withAttribute "Assert"))+                        ((pDetectChar False '\'' >>= withAttribute "Char") >>~ pushContext "CharLiteral")                         <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_pragma >>= withAttribute "Pragma") >>~ pushContext "Pragmas")+                        ((pDetectChar False '"' >>= withAttribute "String") >>~ pushContext "String")                         <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_version >>= withAttribute "Version") >>~ pushContext "Version")+                        ((pDetectChar False '`' >>= withAttribute "BQString") >>~ pushContext "BQString")                         <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_unittest >>= withAttribute "Unit Test"))+                        ((pFirstNonSpace >> pString False "//BEGIN" >>= withAttribute "Region Marker") >>~ pushContext "Region Marker")                         <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_specialtokens >>= withAttribute "SpecialTokens"))+                        ((pFirstNonSpace >> pString False "//END" >>= withAttribute "Region Marker") >>~ pushContext "Region Marker")                         <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_deprecated >>= withAttribute "Deprecated") >>~ pushContext "Deprecated")+                        ((parseRules "CommentRules"))                         <|>-                        ((pDetect2Chars False 'r' '"' >>= withAttribute "RawString") >>~ pushContext "RawString")+                        ((pString False "..." >>= withAttribute "Normal Text"))                         <|>-                        ((pDetect2Chars False 'x' '"' >>= withAttribute "HexString") >>~ pushContext "HexString")+                        ((pDetect2Chars False '.' '.' >>= withAttribute "Normal Text"))                         <|>-                        ((pDetectIdentifier >>= withAttribute "Normal Text"))+                        ((pRegExpr regex_'5c'2e'5cd'5b'5cd'5f'5d'2a'28'5beE'5d'5b'2d'2b'5d'3f'5cd'5b'5cd'5f'5d'2a'29'3f'5bfFL'5d'3fi'3f >>= withAttribute "Float"))                         <|>-                        ((pHlCStringChar >>= withAttribute "EscapeString") >>~ (popContext >> return ()))+                        ((pDetectChar False '.' >>= withAttribute "Normal Text") >>~ pushContext "Properties")                         <|>-                        ((pDetect2Chars False '\\' 'u' >>= withAttribute "EscapeString") >>~ pushContext "UnicodeShort")+                        ((lookAhead (pRegExpr regex_'5cd) >> return ([],"") ) >>~ pushContext "NumberLiteral")                         <|>-                        ((pDetect2Chars False '\\' 'U' >>= withAttribute "EscapeString") >>~ pushContext "UnicodeLong")+                        ((pString False "#line" >>= withAttribute "Pragma") >>~ pushContext "LinePragma")                         <|>-                        ((pDetect2Chars False '\\' '&' >>= withAttribute "EscapeString") >>~ pushContext "HTMLEntity")+                        ((pDetectChar False '{' >>= withAttribute "Symbol"))                         <|>-                        ((pDetectChar False '\'' >>= withAttribute "Char") >>~ pushContext "CharLiteral")+                        ((pDetectChar False '}' >>= withAttribute "Symbol"))                         <|>-                        ((pDetectChar False '"' >>= withAttribute "String") >>~ pushContext "String")+                        ((pAnyChar ":!%&()+,-/.*<=>?[]|~^;" >>= withAttribute "Symbol")))+     return (attr, result)++parseRules "StartingLetter" = +  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Normal Text"))                         <|>-                        ((pDetectChar False '`' >>= withAttribute "BQString") >>~ pushContext "BQString")+                        ((lookAhead (pRegExpr regex_'5b'5ea'2dzA'2dZ'5f'5d) >> return ([],"") ) >>~ (popContext))                         <|>-                        ((pDetect2Chars False '/' '/' >>= withAttribute "Comment") >>~ pushContext "CommentLine")+                        ((pRegExpr regex_in'5cs'2a'28'3f'3d'5c'7b'29 >>= withAttribute "Statement"))                         <|>-                        ((pDetect2Chars False '/' '*' >>= withAttribute "Comment") >>~ pushContext "CommentBlock")+                        ((pRegExpr regex_out'5cs'2a'28'3f'3d'28'5c'28'28'5ba'2dzA'2dZ'5f'5d'5b'5cw'5f'5d'2a'29'3f'5c'29'5cs'2a'29'3f'5c'7b'29 >>= withAttribute "Statement"))                         <|>-                        ((pDetect2Chars False '/' '+' >>= withAttribute "Comment") >>~ pushContext "CommentNested")+                        ((pRegExpr regex_scope'5cs'2a'28'3f'3d'5c'28'29 >>= withAttribute "Statement") >>~ pushContext "Scope")                         <|>-                        ((pDetectChar False '{' >>= withAttribute "Normal Text"))+                        ((pRegExpr regex_import'5cs'2a'28'3f'3d'5c'28'29 >>= withAttribute "Expression"))                         <|>-                        ((pDetectChar False '}' >>= withAttribute "Normal Text"))+                        ((pRegExpr regex_function'5cs'2a'28'3f'3d'5c'28'29 >>= withAttribute "Declarator"))                         <|>-                        ((pString False "..." >>= withAttribute "Normal Text") >>~ (popContext >> return ()))+                        ((pRegExpr regex_delegate'5cs'2a'28'3f'3d'5c'28'29 >>= withAttribute "Declarator"))                         <|>-                        ((pDetect2Chars False '.' '.' >>= withAttribute "Normal Text"))+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_statements >>= withAttribute "Statement"))                         <|>-                        ((pRegExpr regex_0'5bxX'5d'5b'5fa'2dfA'2dF'5cd'5d'2a'28'5c'2e'5b'5fa'2dfA'2dF'5cd'5d'2a'29'3f'5bpP'5d'5b'2d'2b'5d'3f'5b'5cd'5d'2b'5b'5f'5cd'5d'2a'5bfFL'5d'3fi'3f >>= withAttribute "Float") >>~ (popContext >> return ()))+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_attributes >>= withAttribute "Attribute"))                         <|>-                        ((pRegExpr regex_'5b'5cd'5d'5b'5f'5cd'5d'2a'28'5c'2e'28'3f'21'5c'2e'29'5b'5f'5cd'5d'2a'28'5beE'5d'5b'2d'2b'5d'3f'5b'5cd'5d'2b'5b'5f'5cd'5d'2a'29'3f'5bfFL'5d'3fi'3f'7c'5beE'5d'5b'2d'2b'5d'3f'5b'5cd'5d'2b'5b'5f'5cd'5d'2a'5bfFL'5d'3fi'3f'7c'5bfF'5di'3f'7c'5bfFL'5d'3fi'29 >>= withAttribute "Float") >>~ (popContext >> return ()))+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_expressions >>= withAttribute "Expression"))                         <|>-                        ((pRegExpr regex_'5c'2e'5b'5cd'5d'5b'5f'5cd'5d'2a'28'5beE'5d'5b'2d'2b'5d'3f'5b'5cd'5d'2b'5b'5f'5cd'5d'2a'29'3f'5bfFL'5d'3fi'3f >>= withAttribute "Float") >>~ (popContext >> return ()))+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_declarators >>= withAttribute "Declarator"))                         <|>-                        ((pRegExpr regex_0'5bbB'5d'5f'2a'5b01'5d'5b01'5f'5d'2a'28L'5buU'5d'3f'7c'5buU'5dL'3f'29'3f >>= withAttribute "Binary") >>~ (popContext >> return ()))+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_templates >>= withAttribute "Template"))                         <|>-                        ((pRegExpr regex_0'5f'2a'5b0'2d7'5d'5b0'2d7'5f'5d'2a'28L'5buU'5d'3f'7c'5buU'5dL'3f'29'3f >>= withAttribute "Octal") >>~ (popContext >> return ()))+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_modules >>= withAttribute "Module") >>~ pushContext "ModuleName")                         <|>-                        ((pRegExpr regex_0'5bxX'5d'5f'2a'5b'5cda'2dfA'2dF'5d'5b'5cda'2dfA'2dF'5f'5d'2a'28L'5buU'5d'3f'7c'5buU'5dL'3f'29'3f >>= withAttribute "Hex") >>~ (popContext >> return ()))+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_types >>= withAttribute "Type"))                         <|>-                        ((pRegExpr regex_'5cd'2b'5b'5cd'5f'5d'2a'28L'5buU'5d'3f'7c'5buU'5dL'3f'29'3f >>= withAttribute "Integer") >>~ (popContext >> return ()))+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_libsymbols >>= withAttribute "LibrarySymbols"))                         <|>-                        ((pString False "#line" >>= withAttribute "Pragma") >>~ (popContext >> return ())))-     return (attr, result)--parseRules "UnicodeShort" = -  do (attr, result) <- ((pRegExpr regex_'5b'5cda'2dfA'2dF'5d'7b4'7d >>= withAttribute "EscapeString") >>~ (popContext >> return ()))+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_linkage >>= withAttribute "Linkage") >>~ pushContext "Linkage")+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_specialtokens >>= withAttribute "SpecialTokens"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_tests >>= withAttribute "Tests"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_pragma >>= withAttribute "Pragma") >>~ pushContext "Pragma")+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_version >>= withAttribute "Version") >>~ pushContext "Version")+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_deprecated >>= withAttribute "Deprecated"))+                        <|>+                        ((pDetect2Chars False 'r' '"' >>= withAttribute "RawString") >>~ pushContext "RawString")+                        <|>+                        ((pDetect2Chars False 'x' '"' >>= withAttribute "HexString") >>~ pushContext "HexString")+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_userkeywords >>= withAttribute "UserKeywords"))+                        <|>+                        ((pDetectIdentifier >>= withAttribute "Normal Text")))      return (attr, result) -parseRules "UnicodeLong" = -  do (attr, result) <- ((pRegExpr regex_'5b'5cda'2dfA'2dF'5d'7b8'7d >>= withAttribute "EscapeString") >>~ (popContext >> return ()))+parseRules "Properties" = +  do (attr, result) <- (((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_properties >>= withAttribute "Property") >>~ (popContext))+                        <|>+                        ((popContext) >> return ([], "")))      return (attr, result) -parseRules "HTMLEntity" = -  do (attr, result) <- (((pRegExpr regex_'5ba'2dzA'2dZ'5d'5cw'2b'3b >>= withAttribute "EscapeString") >>~ (popContext >> return ()))+parseRules "NumberLiteral" = +  do (attr, result) <- (((pRegExpr regex_0'5bxX'5d'5b'5cda'2dfA'2dF'5f'5d'2a'28'5c'2e'5b'5cda'2dfA'2dF'5f'5d'2a'29'3f'5bpP'5d'5b'2d'2b'5d'3f'5cd'5b'5cd'5f'5d'2a'5bfFL'5d'3fi'3f >>= withAttribute "Float") >>~ (popContext))                         <|>-                        ((popContext >> return ()) >> return ([], "")))+                        ((pRegExpr regex_'5cd'5b'5f'5cd'5d'2a'28'5c'2e'28'3f'21'5c'2e'29'5b'5f'5cd'5d'2a'28'5beE'5d'5b'2d'2b'5d'3f'5cd'5b'5f'5cd'5d'2a'29'3f'5bfFL'5d'3fi'3f'7c'5beE'5d'5b'2d'2b'5d'3f'5cd'5b'5f'5cd'5d'2a'5bfFL'5d'3fi'3f'7c'5bfF'5di'3f'7c'5bfFL'5d'3fi'29 >>= withAttribute "Float") >>~ (popContext))+                        <|>+                        ((pRegExpr regex_0'5bbB'5d'5f'2a'5b01'5d'5b01'5f'5d'2a'28L'5buU'5d'3f'7c'5buU'5dL'3f'29'3f >>= withAttribute "Binary") >>~ (popContext))+                        <|>+                        ((pRegExpr regex_0'5b0'2d7'5f'5d'2b'28L'5buU'5d'3f'7c'5buU'5dL'3f'29'3f >>= withAttribute "Octal") >>~ (popContext))+                        <|>+                        ((pRegExpr regex_0'5bxX'5d'5f'2a'5b'5cda'2dfA'2dF'5d'5b'5cda'2dfA'2dF'5f'5d'2a'28L'5buU'5d'3f'7c'5buU'5dL'3f'29'3f >>= withAttribute "Hex") >>~ (popContext))+                        <|>+                        ((pRegExpr regex_'5cd'2b'5b'5cd'5f'5d'2a'28L'5buU'5d'3f'7c'5buU'5dL'3f'29'3f >>= withAttribute "Integer") >>~ (popContext))+                        <|>+                        ((popContext) >> return ([], "")))      return (attr, result) -parseRules "ModuleName" = -  do (attr, result) <- (((pDetect2Chars False '/' '/' >>= withAttribute "Comment") >>~ pushContext "CommentLine")+parseRules "LinePragma" = +  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Pragma"))                         <|>-                        ((pDetect2Chars False '/' '*' >>= withAttribute "Comment") >>~ pushContext "CommentBlock")+                        ((pRegExpr regex_'28'280'28'5b0'2d7'5f'5d'2b'7c'5bbB'5d'5f'2a'5b01'5d'5b01'5f'5d'2a'7c'5bxX'5d'5f'2a'5b'5cda'2dfA'2dF'5d'5b'5cda'2dfA'2dF'5f'5d'2a'29'29'7c'5cd'2b'5b'5cd'5f'5d'2a'29'28L'5buU'5d'3f'7c'5buU'5dL'3f'29'3f >>= withAttribute "Integer"))                         <|>-                        ((pDetect2Chars False '/' '+' >>= withAttribute "Comment") >>~ pushContext "CommentNested")+                        ((pRegExpr regex_'22'5b'5e'22'5d'2a'22 >>= withAttribute "String"))                         <|>-                        ((pRegExpr regex_'5b'5e'5cs'5cw'2e'3a'2c'5d >>= withAttribute "Module Name") >>~ (popContext >> return ())))+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_specialtokens >>= withAttribute "SpecialTokens"))+                        <|>+                        ((parseRules "CommentRules"))+                        <|>+                        ((pRegExpr regex_'2e'2b >>= withAttribute "Error") >>~ (popContext)))      return (attr, result) -parseRules "Deprecated" = -  do (attr, result) <- (((pDetect2Chars False '/' '/' >>= withAttribute "Comment") >>~ pushContext "CommentLine")+parseRules "UnicodeShort" = +  do (attr, result) <- ((pRegExpr regex_'5b'5cda'2dfA'2dF'5d'7b4'7d >>= withAttribute "EscapeSequence") >>~ (popContext))+     return (attr, result)++parseRules "UnicodeLong" = +  do (attr, result) <- ((pRegExpr regex_'5b'5cda'2dfA'2dF'5d'7b8'7d >>= withAttribute "EscapeSequence") >>~ (popContext))+     return (attr, result)++parseRules "HTMLEntity" = +  do (attr, result) <- (((pRegExpr regex_'5ba'2dzA'2dZ'5d'5cw'2b'3b >>= withAttribute "EscapeSequence") >>~ (popContext))                         <|>-                        ((pDetect2Chars False '/' '*' >>= withAttribute "Comment") >>~ pushContext "CommentBlock")+                        ((popContext) >> return ([], "")))+     return (attr, result)++parseRules "ModuleName" = +  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Module Name"))                         <|>-                        ((pDetect2Chars False '/' '+' >>= withAttribute "Comment") >>~ pushContext "CommentNested")+                        ((parseRules "CommentRules"))                         <|>-                        ((pRegExpr regex_'5b'3b'28'7b'3d'5d >>= withAttribute "Normal Text") >>~ (popContext >> return ())))+                        ((lookAhead (pRegExpr regex_'5b'5e'5cs'5cw'2e'3a'2c'3d'5d) >> return ([],"") ) >>~ (popContext)))      return (attr, result)  parseRules "Linkage" = -  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Linkage"))+  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Normal Text"))                         <|>                         ((pDetectChar False '(' >>= withAttribute "Normal Text") >>~ pushContext "Linkage2")                         <|>-                        ((popContext >> return ()) >> return ([], "")))+                        ((parseRules "CommentRules"))+                        <|>+                        ((popContext) >> return ([], "")))      return (attr, result)  parseRules "Linkage2" = -  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Linkage"))+  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Normal Text"))                         <|>-                        ((pString False "C++" >>= withAttribute "Linkage Type") >>~ (popContext >> return ()))+                        ((pString False "C++" >>= withAttribute "Linkage Type") >>~ (popContext >> popContext))                         <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_ltypes >>= withAttribute "Linkage Type") >>~ (popContext >> return ()))+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_ltypes >>= withAttribute "Linkage Type") >>~ (popContext >> popContext))                         <|>-                        ((pRegExpr regex_'5b'5e'29'5d'2b >>= withAttribute "Error") >>~ (popContext >> return ()))+                        ((parseRules "CommentRules"))                         <|>-                        ((popContext >> return ()) >> return ([], "")))+                        ((pDetectChar False ')' >>= withAttribute "Normal Text") >>~ (popContext >> popContext))+                        <|>+                        ((pRegExpr regex_'5b'5e'29'5cs'5cn'5d'2b >>= withAttribute "Error") >>~ (popContext >> popContext)))      return (attr, result)  parseRules "Version" = -  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Version"))+  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Normal Text"))                         <|>                         ((pDetectChar False '=' >>= withAttribute "Normal Text") >>~ pushContext "Version2")                         <|>                         ((pDetectChar False '(' >>= withAttribute "Normal Text") >>~ pushContext "Version2")                         <|>-                        ((pDetectChar False ';' >>= withAttribute "Normal Text") >>~ (popContext >> return ()))+                        ((parseRules "CommentRules"))                         <|>-                        ((pDetectChar False ')' >>= withAttribute "Normal Text") >>~ (popContext >> return ()))+                        ((pRegExpr regex_'5b'5e'5cs'5cn'5d'2b >>= withAttribute "Error") >>~ (popContext)))+     return (attr, result)++parseRules "Version2" = +  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Normal Text"))                         <|>-                        ((pRegExpr regex_'5b'5e'5cn'5d'2b >>= withAttribute "Error") >>~ (popContext >> return ()))+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_vtypes >>= withAttribute "Version Type") >>~ (popContext >> popContext))                         <|>-                        ((popContext >> return ()) >> return ([], "")))+                        ((pDetectIdentifier >>= withAttribute "Normal Text") >>~ (popContext >> popContext))+                        <|>+                        ((pRegExpr regex_'5cd'2b'5b'5cd'5f'5d'2a'28L'5buU'5d'3f'7c'5buU'5dL'3f'29'3f >>= withAttribute "Integer") >>~ (popContext >> popContext))+                        <|>+                        ((parseRules "CommentRules"))+                        <|>+                        ((pDetectChar False ')' >>= withAttribute "Normal Text") >>~ (popContext >> popContext))+                        <|>+                        ((pRegExpr regex_'5b'5e'29'5cs'5cn'5d'2b >>= withAttribute "Error") >>~ (popContext >> popContext)))      return (attr, result) -parseRules "Version2" = -  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Version"))+parseRules "Scope" = +  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Normal Text"))                         <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_vtypes >>= withAttribute "Version Type") >>~ (popContext >> return ()))+                        ((pDetectChar False '(' >>= withAttribute "Normal Text") >>~ pushContext "Scope2")                         <|>-                        ((pDetectIdentifier >>= withAttribute "Normal Text") >>~ (popContext >> return ()))+                        ((parseRules "CommentRules"))                         <|>-                        ((pInt >>= withAttribute "Integer") >>~ (popContext >> return ()))+                        ((popContext) >> return ([], "")))+     return (attr, result)++parseRules "Scope2" = +  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Normal Text"))                         <|>-                        ((pRegExpr regex_'5b'5e'29'3b'5d'2b >>= withAttribute "Error") >>~ (popContext >> return ()))+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_scope'5fkeywords >>= withAttribute "Expression") >>~ (popContext >> popContext))                         <|>-                        ((popContext >> return ()) >> return ([], "")))+                        ((parseRules "CommentRules"))+                        <|>+                        ((pDetectChar False ')' >>= withAttribute "Normal Text") >>~ (popContext >> popContext))+                        <|>+                        ((pRegExpr regex_'5b'5e'29'5cs'5cn'5d'2b >>= withAttribute "Error") >>~ (popContext >> popContext)))      return (attr, result) -parseRules "Pragmas" = -  do (attr, result) <- (((pDetectChar False '(' >>= withAttribute "Normal Text"))+parseRules "Pragma" = +  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Pragma"))                         <|>-                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_ptypes >>= withAttribute "Version Type") >>~ (popContext >> return ()))+                        ((pDetectChar False '(' >>= withAttribute "Normal Text") >>~ pushContext "Pragma2")                         <|>-                        ((pDetectIdentifier >>= withAttribute "Normal Text") >>~ (popContext >> return ())))+                        ((parseRules "CommentRules"))+                        <|>+                        ((pRegExpr regex_'5b'5e'5cs'5cn'5d'2b >>= withAttribute "Error") >>~ (popContext)))      return (attr, result) +parseRules "Pragma2" = +  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Pragma"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_ptypes >>= withAttribute "Version Type") >>~ (popContext >> popContext))+                        <|>+                        ((pDetectIdentifier >>= withAttribute "Normal Text") >>~ (popContext >> popContext))+                        <|>+                        ((parseRules "CommentRules"))+                        <|>+                        ((pDetectChar False ')' >>= withAttribute "Normal Text") >>~ (popContext >> popContext))+                        <|>+                        ((pRegExpr regex_'5b'5e'29'5cs'5cn'5d'2b >>= withAttribute "Error") >>~ (popContext >> popContext)))+     return (attr, result)+ parseRules "RawString" = -  do (attr, result) <- ((pDetectChar False '"' >>= withAttribute "RawString") >>~ (popContext >> return ()))+  do (attr, result) <- ((pDetectChar False '"' >>= withAttribute "RawString") >>~ (popContext))      return (attr, result)  parseRules "BQString" = -  do (attr, result) <- ((pDetectChar False '`' >>= withAttribute "BQString") >>~ (popContext >> return ()))+  do (attr, result) <- ((pDetectChar False '`' >>= withAttribute "BQString") >>~ (popContext))      return (attr, result)  parseRules "HexString" = -  do (attr, result) <- (((pDetectChar False '"' >>= withAttribute "HexString") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetectChar False '"' >>= withAttribute "HexString") >>~ (popContext))                         <|>                         ((pRegExpr regex_'5b'5e'5csa'2dfA'2dF'5cd'22'5d'2b >>= withAttribute "Error")))      return (attr, result)  parseRules "CharLiteral" = -  do (attr, result) <- (((pHlCStringChar >>= withAttribute "EscapeSequence"))+  do (attr, result) <- (((pDetectChar False '\'' >>= withAttribute "Char") >>~ (popContext))                         <|>-                        ((pDetectChar False '\'' >>= withAttribute "Char") >>~ (popContext >> return ()))+                        ((pHlCStringChar >>= withAttribute "EscapeSequence") >>~ pushContext "CharLiteralClosing")                         <|>-                        ((pRegExpr regex_'5c'5c'28u'5b'5cda'2dfA'2dF'5d'7b4'7d'7cU'5b'5cda'2dfA'2dF'5d'7b8'7d'7c'26'5ba'2dzA'2dZ'5d'5cw'2b'3b'29 >>= withAttribute "EscapeSequence"))+                        ((pRegExpr regex_'5c'5c'28u'5b'5cda'2dfA'2dF'5d'7b4'7d'7cU'5b'5cda'2dfA'2dF'5d'7b8'7d'7c'26'5ba'2dzA'2dZ'5d'5cw'2b'3b'29 >>= withAttribute "EscapeSequence") >>~ pushContext "CharLiteralClosing")                         <|>-                        ((pDetectChar False '\'' >>= withAttribute "Char") >>~ (popContext >> return ()))+                        ((pRegExpr regex_'5c'5c'2e >>= withAttribute "Error") >>~ pushContext "CharLiteralClosing")                         <|>-                        ((pRegExpr regex_'2e'27 >>= withAttribute "Char"))+                        ((pRegExpr regex_'2e >>= withAttribute "Char") >>~ pushContext "CharLiteralClosing")                         <|>-                        ((popContext >> return ()) >> return ([], "")))+                        ((popContext) >> return ([], "")))      return (attr, result) +parseRules "CharLiteralClosing" = +  do (attr, result) <- (((pDetectChar False '\'' >>= withAttribute "Char") >>~ (popContext >> popContext))+                        <|>+                        ((popContext >> popContext) >> return ([], "")))+     return (attr, result)+ parseRules "String" = -  do (attr, result) <- (((pDetect2Chars False '\\' '"' >>= withAttribute "String"))+  do (attr, result) <- (((pHlCStringChar >>= withAttribute "EscapeSequence"))                         <|>-                        ((pDetectChar False '"' >>= withAttribute "String") >>~ (popContext >> return ()))+                        ((pDetect2Chars False '"' 'c' >>= withAttribute "String") >>~ (popContext))                         <|>-                        ((pHlCStringChar >>= withAttribute "EscapeSequence"))+                        ((pDetect2Chars False '"' 'w' >>= withAttribute "String") >>~ (popContext))                         <|>-                        ((pRegExpr regex_'5c'5c'28u'5b'5cda'2dfA'2dF'5d'7b4'7d'7cU'5b'5cda'2dfA'2dF'5d'7b8'7d'7c'26'5ba'2dzA'2dZ'5d'5cw'2b'3b'29 >>= withAttribute "EscapeSequence")))+                        ((pDetect2Chars False '"' 'd' >>= withAttribute "String") >>~ (popContext))+                        <|>+                        ((pDetectChar False '"' >>= withAttribute "String") >>~ (popContext))+                        <|>+                        ((pDetect2Chars False '\\' 'u' >>= withAttribute "EscapeSequence") >>~ pushContext "UnicodeShort")+                        <|>+                        ((pDetect2Chars False '\\' 'U' >>= withAttribute "EscapeSequence") >>~ pushContext "UnicodeLong")+                        <|>+                        ((pDetect2Chars False '\\' '&' >>= withAttribute "EscapeSequence") >>~ pushContext "HTMLEntity"))      return (attr, result) -parseRules "CommentLine" = +parseRules "CommentRules" = +  do (attr, result) <- (((parseRules "DdocNormal"))+                        <|>+                        ((pDetect2Chars False '/' '/' >>= withAttribute "Comment") >>~ pushContext "CommentLine")+                        <|>+                        ((pDetect2Chars False '/' '*' >>= withAttribute "Comment") >>~ pushContext "CommentBlock")+                        <|>+                        ((pDetect2Chars False '/' '+' >>= withAttribute "Comment") >>~ pushContext "CommentNested"))+     return (attr, result)++parseRules "Region Marker" =    pzero +parseRules "CommentLine" = +  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Comment"))+                        <|>+                        ((Text.Highlighting.Kate.Syntax.Alert.parseExpression)))+     return (attr, result)+ parseRules "CommentBlock" = -  do (attr, result) <- ((pDetect2Chars False '*' '/' >>= withAttribute "Comment") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Comment"))+                        <|>+                        ((pDetect2Chars False '*' '/' >>= withAttribute "Comment") >>~ (popContext))+                        <|>+                        ((Text.Highlighting.Kate.Syntax.Alert.parseExpression)))      return (attr, result)  parseRules "CommentNested" = -  do (attr, result) <- (((pDetect2Chars False '/' '+' >>= withAttribute "Comment") >>~ pushContext "CommentNested")+  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Comment"))                         <|>-                        ((pDetect2Chars False '+' '/' >>= withAttribute "Comment") >>~ (popContext >> return ())))+                        ((pDetect2Chars False '/' '+' >>= withAttribute "Comment") >>~ pushContext "CommentNested")+                        <|>+                        ((pDetect2Chars False '+' '/' >>= withAttribute "Comment") >>~ (popContext))+                        <|>+                        ((Text.Highlighting.Kate.Syntax.Alert.parseExpression)))+     return (attr, result)++parseRules "DdocNormal" = +  do (attr, result) <- (((pRegExpr regex_'2f'7b3'2c'7d >>= withAttribute "Comment") >>~ pushContext "DdocLine")+                        <|>+                        ((pRegExpr regex_'2f'5c'2a'7b2'2c'7d'28'3f'21'2f'29 >>= withAttribute "Comment") >>~ pushContext "DdocBlock")+                        <|>+                        ((pRegExpr regex_'2f'5c'2b'7b2'2c'7d'28'3f'21'2f'29 >>= withAttribute "Comment") >>~ pushContext "DdocNested"))+     return (attr, result)++parseRules "DdocLine" = +  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Ddoc"))+                        <|>+                        ((pDetectIdentifier >>= withAttribute "Ddoc"))+                        <|>+                        ((pDetect2Chars False '$' '(' >>= withAttribute "Macros") >>~ pushContext "DdocMacro")+                        <|>+                        ((pRegExpr regex_'5b'5cw'5f'5d'2b'3a'28'24'7c'5cs'29 >>= withAttribute "DdocSection"))+                        <|>+                        ((Text.Highlighting.Kate.Syntax.Alert.parseExpression)))+     return (attr, result)++parseRules "DdocBlock" = +  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Ddoc"))+                        <|>+                        ((pDetectIdentifier >>= withAttribute "Ddoc"))+                        <|>+                        ((pRegExpr regex_'5c'2a'2b'2f >>= withAttribute "Comment") >>~ (popContext))+                        <|>+                        ((pFirstNonSpace >> pDetectChar False '*' >>= withAttribute "Comment"))+                        <|>+                        ((pDetect2Chars False '$' '(' >>= withAttribute "Macros") >>~ pushContext "DdocMacro")+                        <|>+                        ((pRegExpr regex_'5b'5cw'5f'5d'2b'3a'28'24'7c'5cs'29 >>= withAttribute "DdocSection"))+                        <|>+                        ((Text.Highlighting.Kate.Syntax.Alert.parseExpression))+                        <|>+                        ((pRegExpr regex_'5b'5e'2d'5d'2d'7b3'2c'7d >>= withAttribute "Ddoc"))+                        <|>+                        ((pRegExpr regex_'2d'7b3'2c'7d'28'24'7c'5cs'29 >>= withAttribute "Comment") >>~ pushContext "DdocBlockCode"))+     return (attr, result)++parseRules "DdocNested" = +  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Ddoc"))+                        <|>+                        ((pDetectIdentifier >>= withAttribute "Ddoc"))+                        <|>+                        ((pDetect2Chars False '/' '+' >>= withAttribute "Ddoc") >>~ pushContext "DdocNested2")+                        <|>+                        ((pRegExpr regex_'5c'2b'2b'2f >>= withAttribute "Comment") >>~ (popContext))+                        <|>+                        ((pFirstNonSpace >> pDetectChar False '+' >>= withAttribute "Comment"))+                        <|>+                        ((pDetect2Chars False '$' '(' >>= withAttribute "Macros") >>~ pushContext "DdocMacro")+                        <|>+                        ((pRegExpr regex_'5b'5cw'5f'5d'2b'3a'28'24'7c'5cs'29 >>= withAttribute "DdocSection"))+                        <|>+                        ((Text.Highlighting.Kate.Syntax.Alert.parseExpression))+                        <|>+                        ((pRegExpr regex_'5b'5e'2d'5d'2d'7b3'2c'7d >>= withAttribute "Ddoc"))+                        <|>+                        ((pRegExpr regex_'2d'7b3'2c'7d'28'24'7c'5cs'29 >>= withAttribute "Comment") >>~ pushContext "DdocNestedCode"))+     return (attr, result)++parseRules "DdocNested2" = +  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Ddoc"))+                        <|>+                        ((pDetectIdentifier >>= withAttribute "Ddoc"))+                        <|>+                        ((pRegExpr regex_'5c'2b'2b'2f >>= withAttribute "Ddoc") >>~ (popContext))+                        <|>+                        ((parseRules "DdocNested")))+     return (attr, result)++parseRules "DdocMacro" = +  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Macro Text"))+                        <|>+                        ((pDetectChar False ')' >>= withAttribute "Macros") >>~ (popContext))+                        <|>+                        ((parseRules "MacroRules"))+                        <|>+                        ((pDetectIdentifier >>= withAttribute "Macros") >>~ pushContext "DdocMacro2"))+     return (attr, result)++parseRules "DdocMacro2" = +  do (attr, result) <- (((pDetectChar False ')' >>= withAttribute "Macros") >>~ (popContext >> popContext))+                        <|>+                        ((parseRules "MacroRules")))+     return (attr, result)++parseRules "DdocMacro3" = +  do (attr, result) <- (((pDetectChar False ')' >>= withAttribute "Macro Text") >>~ (popContext))+                        <|>+                        ((parseRules "MacroRules")))+     return (attr, result)++parseRules "MacroRules" = +  do (attr, result) <- (((pDetect2Chars False '$' '(' >>= withAttribute "Macros") >>~ pushContext "DdocMacro")+                        <|>+                        ((pDetectChar False '(' >>= withAttribute "Macro Text") >>~ pushContext "DdocMacro3")+                        <|>+                        ((pFirstNonSpace >> pDetectChar False '*' >>= withAttribute "Comment")))+     return (attr, result)++parseRules "DdocBlockCode" = +  do (attr, result) <- (((pDetectSpaces >>= withAttribute "DdocCode"))+                        <|>+                        ((pRegExpr regex_'5c'2a'2b'2f >>= withAttribute "Comment") >>~ (popContext >> popContext))+                        <|>+                        ((pFirstNonSpace >> pDetectChar False '*' >>= withAttribute "Comment"))+                        <|>+                        ((pRegExpr regex_'5b'5e'2d'5d'2d'7b3'2c'7d >>= withAttribute "DdocCode"))+                        <|>+                        ((pRegExpr regex_'2d'7b3'2c'7d'28'24'7c'5cs'29 >>= withAttribute "Comment") >>~ (popContext))+                        <|>+                        ((Text.Highlighting.Kate.Syntax.D.parseExpression)))+     return (attr, result)++parseRules "DdocNestedCode" = +  do (attr, result) <- (((pDetectSpaces >>= withAttribute "DdocCode"))+                        <|>+                        ((pRegExpr regex_'5c'2b'2b'2f >>= withAttribute "Comment") >>~ (popContext >> popContext))+                        <|>+                        ((pFirstNonSpace >> pDetectChar False '+' >>= withAttribute "Comment"))+                        <|>+                        ((pRegExpr regex_'5b'5e'2d'5d'2d'7b3'2c'7d >>= withAttribute "DdocCode"))+                        <|>+                        ((pRegExpr regex_'2d'7b3'2c'7d'28'24'7c'5cs'29 >>= withAttribute "Comment") >>~ (popContext))+                        <|>+                        ((Text.Highlighting.Kate.Syntax.D.parseExpression)))      return (attr, result)  parseRules x = fail $ "Unknown context" ++ x

@@ -0,0 +1,94 @@+{- This module was generated from data in the Kate syntax highlighting file desktop.xml, version 1.04,+   by   -}++module Text.Highlighting.Kate.Syntax.Desktop ( 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)++-- | Full name of language.+syntaxName :: String+syntaxName = ".desktop"++-- | Filename extensions for this language.+syntaxExtensions :: String+syntaxExtensions = "*.desktop;*.kdelnk"++-- | 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 = ".desktop" }+  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 [(".desktop",["Normal"])], synStLanguage = ".desktop", synStCurrentLine = "", synStCharsParsedInLine = 0, synStPrevChar = '\n', synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}++parseSourceLine = manyTill parseExpressionInternal pEndLine++pEndLine = do+  lookAhead $ newline <|> (eof >> return '\n')+  context <- currentContext+  case context of+    "Normal" -> return () >> pHandleEndLine+    "Value" -> (popContext) >> pEndLine+    "Comment" -> (popContext) >> pEndLine+    _ -> pHandleEndLine++withAttribute attr txt = do+  when (null txt) $ fail "Parser matched no text"+  let labs = attr : maybeToList (lookup attr styles)+  st <- getState+  let oldCharsParsed = synStCharsParsedInLine st+  let prevchar = if null txt then '\n' else last txt+  updateState $ \st -> st { synStCharsParsedInLine = oldCharsParsed + length txt, synStPrevChar = prevchar } +  return (labs, txt)++styles = [("Section","kw"),("Key","dt"),("Language","dv"),("Comment","co")]++parseExpressionInternal = do+  context <- currentContext+  parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes))+++regex_'5c'5b'2e'2a'5c'5d'24 = compileRegex "\\[.*\\]$"+regex_'5c'5b'2e'2a'5c'5d = compileRegex "\\[.*\\]"++defaultAttributes = [("Normal","Key"),("Value","Normal Text"),("Comment","Comment")]++parseRules "Normal" = +  do (attr, result) <- (((pColumn 0 >> pRegExpr regex_'5c'5b'2e'2a'5c'5d'24 >>= withAttribute "Section"))+                        <|>+                        ((pRegExpr regex_'5c'5b'2e'2a'5c'5d >>= withAttribute "Language") >>~ pushContext "Value")+                        <|>+                        ((pFirstNonSpace >> pDetectChar False '#' >>= withAttribute "Comment") >>~ pushContext "Comment")+                        <|>+                        ((pDetectChar False '=' >>= withAttribute "Normal Text") >>~ pushContext "Value"))+     return (attr, result)++parseRules "Value" = +  pzero++parseRules "Comment" = +  pzero++parseRules x = fail $ "Unknown context" ++ x

@@ -0,0 +1,220 @@+{- This module was generated from data in the Kate syntax highlighting file diff.xml, version 1.11,+   by   -}++module Text.Highlighting.Kate.Syntax.Diff ( 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)++-- | Full name of language.+syntaxName :: String+syntaxName = "Diff"++-- | Filename extensions for this language.+syntaxExtensions :: String+syntaxExtensions = "*.diff;*patch"++-- | 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 = "Diff" }+  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 [("Diff",["Normal"])], synStLanguage = "Diff", synStCurrentLine = "", synStCharsParsedInLine = 0, synStPrevChar = '\n', synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}++parseSourceLine = manyTill parseExpressionInternal pEndLine++pEndLine = do+  lookAhead $ newline <|> (eof >> return '\n')+  context <- currentContext+  case context of+    "Normal" -> return () >> pHandleEndLine+    "FindDiff" -> return () >> pHandleEndLine+    "File" -> return () >> pHandleEndLine+    "Chunk" -> return () >> pHandleEndLine+    "ChunkInFile" -> return () >> pHandleEndLine+    "RFile" -> return () >> pHandleEndLine+    "RChunk" -> return () >> pHandleEndLine+    "RChunkInFile" -> return () >> pHandleEndLine+    "RChunkNew" -> return () >> pHandleEndLine+    "RChunkInFileNew" -> return () >> pHandleEndLine+    "File" -> (popContext) >> pEndLine+    "Removed" -> (popContext) >> pEndLine+    "Added" -> (popContext) >> pEndLine+    "ChangedOld" -> (popContext) >> pEndLine+    "ChangedNew" -> (popContext) >> pEndLine+    _ -> pHandleEndLine++withAttribute attr txt = do+  when (null txt) $ fail "Parser matched no text"+  let labs = attr : maybeToList (lookup attr styles)+  st <- getState+  let oldCharsParsed = synStCharsParsedInLine st+  let prevchar = if null txt then '\n' else last txt+  updateState $ \st -> st { synStCharsParsedInLine = oldCharsParsed + length txt, synStPrevChar = prevchar } +  return (labs, txt)++styles = [("File","kw"),("Header","dt"),("Removed line","st"),("Added line","ot"),("Changed line (old)","st"),("Changed line (new)","ot")]++parseExpressionInternal = do+  context <- currentContext+  parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes))+++regex_'28'5c'40'5c'40'7c'5cd'29'2e'2a'24 = compileRegex "(\\@\\@|\\d).*$"+regex_'5c'2a'2b'24 = compileRegex "\\*+$"+regex_Only_in_'2e'2a'3a'2e'2a'24 = compileRegex "Only in .*:.*$"+regex_diff'2e'2a'24 = compileRegex "diff.*$"+regex_'3d'3d'3d'3d'2e'2a'24 = compileRegex "====.*$"+regex_'28'5c'2a'5c'2a'5c'2a'7c'5c'2d'5c'2d'5c'2d'29'2e'2a'24 = compileRegex "(\\*\\*\\*|\\-\\-\\-).*$"+regex_'5c'2d'5c'2d'5c'2d'2e'2a'24 = compileRegex "\\-\\-\\-.*$"+regex_'28'5c'2b'5c'2b'5c'2b'7c'5c'2d'5c'2d'5c'2d'29'2e'2a'24 = compileRegex "(\\+\\+\\+|\\-\\-\\-).*$"+regex_'28'3d'3d'3d'3d'7c'5c'2a'5c'2a'5c'2a'7c'5c'2d'5c'2d'5c'2d'7cdiff'7cOnly_in_'2e'2a'3a'29'2e'2a'24 = compileRegex "(====|\\*\\*\\*|\\-\\-\\-|diff|Only in .*:).*$"+regex_Index'3a'2e'2a = compileRegex "Index:.*"+regex_'28diff'7cOnly_in_'2e'2a'3a'29'2e'2a'24 = compileRegex "(diff|Only in .*:).*$"+regex_'5c'2a'5c'2a'5c'2a_'2e'2a_'5c'2a'5c'2a'5c'2a'5c'2a'24 = compileRegex "\\*\\*\\* .* \\*\\*\\*\\*$"+regex_'5c'2d'5c'2d'5c'2d_'2e'2a_'5c'2d'5c'2d'5c'2d'5c'2d'24 = compileRegex "\\-\\-\\- .* \\-\\-\\-\\-$"++defaultAttributes = [("Normal","Normal Text"),("FindDiff","Normal Text"),("File","Normal Text"),("Chunk","Normal Text"),("ChunkInFile","Normal Text"),("RFile","Normal Text"),("RChunk","Normal Text"),("RChunkInFile","Normal Text"),("RChunkNew","Normal Text"),("RChunkInFileNew","Normal Text"),("File","File"),("Removed","Removed line"),("Added","Added line"),("ChangedOld","Changed line (old)"),("ChangedNew","Changed line (new)")]++parseRules "Normal" = +  do (attr, result) <- (((pColumn 0 >> pRegExpr regex_'28'5c'40'5c'40'7c'5cd'29'2e'2a'24 >>= withAttribute "Header") >>~ pushContext "Chunk")+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5c'2a'2b'24 >>= withAttribute "Header") >>~ pushContext "RChunk")+                        <|>+                        ((pColumn 0 >> pRegExpr regex_Only_in_'2e'2a'3a'2e'2a'24 >>= withAttribute "File"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_diff'2e'2a'24 >>= withAttribute "File") >>~ pushContext "RFile")+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'3d'3d'3d'3d'2e'2a'24 >>= withAttribute "File"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'28'5c'2a'5c'2a'5c'2a'7c'5c'2d'5c'2d'5c'2d'29'2e'2a'24 >>= withAttribute "File") >>~ pushContext "File")+                        <|>+                        ((parseRules "FindDiff"))+                        <|>+                        ((pColumn 0 >> pDetectChar False '!' >>= withAttribute "Changed line") >>~ pushContext "ChangedOld"))+     return (attr, result)++parseRules "FindDiff" = +  do (attr, result) <- (((pColumn 0 >> pRegExpr regex_'5c'2d'5c'2d'5c'2d'2e'2a'24 >>= withAttribute "File"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'28'5c'2b'5c'2b'5c'2b'7c'5c'2d'5c'2d'5c'2d'29'2e'2a'24 >>= withAttribute "Header"))+                        <|>+                        ((pColumn 0 >> pAnyChar "+>" >>= withAttribute "Added line") >>~ pushContext "Added")+                        <|>+                        ((pColumn 0 >> pAnyChar "-<" >>= withAttribute "Removed line") >>~ pushContext "Removed"))+     return (attr, result)++parseRules "File" = +  do (attr, result) <- (((parseRules "FindDiff"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'28'5c'40'5c'40'7c'5cd'29'2e'2a'24 >>= withAttribute "Header") >>~ pushContext "ChunkInFile")+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5c'2a'2b'24 >>= withAttribute "Header") >>~ pushContext "RChunkInFile")+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'28'3d'3d'3d'3d'7c'5c'2a'5c'2a'5c'2a'7c'5c'2d'5c'2d'5c'2d'7cdiff'7cOnly_in_'2e'2a'3a'29'2e'2a'24 >>= withAttribute "File") >>~ (popContext))+                        <|>+                        ((pColumn 0 >> pDetectChar False '!' >>= withAttribute "Changed line (old)") >>~ pushContext "ChangedOld"))+     return (attr, result)++parseRules "Chunk" = +  do (attr, result) <- (((parseRules "FindDiff"))+                        <|>+                        ((pColumn 0 >> lookAhead (pRegExpr regex_'28'5c'40'5c'40'7c'5cd'29'2e'2a'24) >> return ([],"") ) >>~ (popContext))+                        <|>+                        ((pColumn 0 >> pDetectChar False '!' >>= withAttribute "Changed line (old)") >>~ pushContext "ChangedOld"))+     return (attr, result)++parseRules "ChunkInFile" = +  do (attr, result) <- (((parseRules "FindDiff"))+                        <|>+                        ((pColumn 0 >> lookAhead (pRegExpr regex_'28'5c'40'5c'40'7c'5cd'29'2e'2a'24) >> return ([],"") ) >>~ (popContext))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_Index'3a'2e'2a >>= withAttribute "Normal Text") >>~ (popContext))+                        <|>+                        ((pColumn 0 >> lookAhead (pRegExpr regex_'28'3d'3d'3d'3d'7c'5c'2a'5c'2a'5c'2a'7c'5c'2d'5c'2d'5c'2d'7cdiff'7cOnly_in_'2e'2a'3a'29'2e'2a'24) >> return ([],"") ) >>~ (popContext))+                        <|>+                        ((pColumn 0 >> pDetectChar False '!' >>= withAttribute "Changed line (old)") >>~ pushContext "ChangedOld"))+     return (attr, result)++parseRules "RFile" = +  do (attr, result) <- (((pColumn 0 >> lookAhead (pRegExpr regex_'28diff'7cOnly_in_'2e'2a'3a'29'2e'2a'24) >> return ([],"") ) >>~ (popContext))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'28'3d'3d'3d'3d'7c'5c'2a'5c'2a'5c'2a'7c'5c'2d'5c'2d'5c'2d'7cdiff'7cOnly_in_'2e'2a'3a'29'2e'2a'24 >>= withAttribute "Header"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5c'2a'2b'24 >>= withAttribute "Header") >>~ pushContext "RChunkInFile")+                        <|>+                        ((parseRules "File")))+     return (attr, result)++parseRules "RChunk" = +  do (attr, result) <- (((pColumn 0 >> pRegExpr regex_'5c'2a'5c'2a'5c'2a_'2e'2a_'5c'2a'5c'2a'5c'2a'5c'2a'24 >>= withAttribute "Header"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5c'2d'5c'2d'5c'2d_'2e'2a_'5c'2d'5c'2d'5c'2d'5c'2d'24 >>= withAttribute "Header") >>~ pushContext "RChunkNew")+                        <|>+                        ((parseRules "Chunk")))+     return (attr, result)++parseRules "RChunkInFile" = +  do (attr, result) <- (((pColumn 0 >> pRegExpr regex_'5c'2a'5c'2a'5c'2a_'2e'2a_'5c'2a'5c'2a'5c'2a'5c'2a'24 >>= withAttribute "Header"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5c'2d'5c'2d'5c'2d_'2e'2a_'5c'2d'5c'2d'5c'2d'5c'2d'24 >>= withAttribute "Header") >>~ pushContext "RChunkInFileNew")+                        <|>+                        ((parseRules "ChunkInFile")))+     return (attr, result)++parseRules "RChunkNew" = +  do (attr, result) <- (((pColumn 0 >> lookAhead (pRegExpr regex_'28'5c'40'5c'40'7c'5cd'29'2e'2a'24) >> return ([],"") ) >>~ (popContext >> popContext))+                        <|>+                        ((pColumn 0 >> pDetectChar False '!' >>= withAttribute "Changed line (new)") >>~ pushContext "ChangedNew")+                        <|>+                        ((parseRules "FindDiff")))+     return (attr, result)++parseRules "RChunkInFileNew" = +  do (attr, result) <- (((pColumn 0 >> lookAhead (pRegExpr regex_'28'5c'40'5c'40'7c'5cd'29'2e'2a'24) >> return ([],"") ) >>~ (popContext >> popContext))+                        <|>+                        ((pColumn 0 >> lookAhead (pRegExpr regex_'28'3d'3d'3d'3d'7c'5c'2a'5c'2a'5c'2a'7c'5c'2d'5c'2d'5c'2d'7cdiff'7cOnly_in_'2e'2a'3a'29'2e'2a'24) >> return ([],"") ) >>~ (popContext >> popContext))+                        <|>+                        ((pColumn 0 >> pDetectChar False '!' >>= withAttribute "Changed line (new)") >>~ pushContext "ChangedNew")+                        <|>+                        ((parseRules "FindDiff")))+     return (attr, result)++parseRules "File" = +  pzero++parseRules "Removed" = +  pzero++parseRules "Added" = +  pzero++parseRules "ChangedOld" = +  pzero++parseRules "ChangedNew" = +  pzero++parseRules x = fail $ "Unknown context" ++ x

@@ -50,51 +50,49 @@ parseSourceLine = manyTill parseExpressionInternal pEndLine  pEndLine = do-  newline <|> (eof >> return '\n')+  lookAhead $ newline <|> (eof >> return '\n')   context <- currentContext   case context of-    "Start" -> return ()-    "In Block" -> return ()-    "FindTemplate" -> return ()-    "Template Comment" -> return ()-    "Template Var" -> return ()-    "Template Filter" -> return ()-    "Template Tag" -> return ()-    "Found Block Tag" -> return ()-    "In Block Tag" -> return ()-    "Non Matching Tag" -> return ()-    "In Template Tag" -> return ()-    "Single A-string" -> return ()-    "Single Q-string" -> return ()-    "FindHTML" -> return ()-    "FindEntityRefs" -> return ()-    "FindPEntityRefs" -> return ()-    "FindAttributes" -> return ()-    "FindDTDRules" -> return ()-    "Comment" -> return ()-    "CDATA" -> return ()-    "PI" -> return ()-    "Doctype" -> return ()-    "Doctype Internal Subset" -> return ()-    "Doctype Markupdecl" -> return ()-    "Doctype Markupdecl DQ" -> return ()-    "Doctype Markupdecl SQ" -> return ()-    "El Open" -> return ()-    "El Close" -> return ()-    "El Close 2" -> return ()-    "El Close 3" -> return ()-    "CSS" -> return ()-    "CSS content" -> return ()-    "JS" -> return ()-    "JS content" -> return ()-    "JS comment close" -> (popContext >> return ())-    "Value" -> return ()-    "Value NQ" -> (popContext >> popContext >> return ())-    "Value DQ" -> return ()-    "Value SQ" -> return ()-    _ -> return ()-  lineContents <- lookAhead wholeLine-  updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }+    "Start" -> return () >> pHandleEndLine+    "In Block" -> return () >> pHandleEndLine+    "FindTemplate" -> return () >> pHandleEndLine+    "Template Comment" -> return () >> pHandleEndLine+    "Template Var" -> return () >> pHandleEndLine+    "Template Filter" -> return () >> pHandleEndLine+    "Template Tag" -> return () >> pHandleEndLine+    "Found Block Tag" -> return () >> pHandleEndLine+    "In Block Tag" -> return () >> pHandleEndLine+    "Non Matching Tag" -> return () >> pHandleEndLine+    "In Template Tag" -> return () >> pHandleEndLine+    "Single A-string" -> return () >> pHandleEndLine+    "Single Q-string" -> return () >> pHandleEndLine+    "FindHTML" -> return () >> pHandleEndLine+    "FindEntityRefs" -> return () >> pHandleEndLine+    "FindPEntityRefs" -> return () >> pHandleEndLine+    "FindAttributes" -> return () >> pHandleEndLine+    "FindDTDRules" -> return () >> pHandleEndLine+    "Comment" -> return () >> pHandleEndLine+    "CDATA" -> return () >> pHandleEndLine+    "PI" -> return () >> pHandleEndLine+    "Doctype" -> return () >> pHandleEndLine+    "Doctype Internal Subset" -> return () >> pHandleEndLine+    "Doctype Markupdecl" -> return () >> pHandleEndLine+    "Doctype Markupdecl DQ" -> return () >> pHandleEndLine+    "Doctype Markupdecl SQ" -> return () >> pHandleEndLine+    "El Open" -> return () >> pHandleEndLine+    "El Close" -> return () >> pHandleEndLine+    "El Close 2" -> return () >> pHandleEndLine+    "El Close 3" -> return () >> pHandleEndLine+    "CSS" -> return () >> pHandleEndLine+    "CSS content" -> return () >> pHandleEndLine+    "JS" -> return () >> pHandleEndLine+    "JS content" -> return () >> pHandleEndLine+    "JS comment close" -> (popContext) >> pEndLine+    "Value" -> return () >> pHandleEndLine+    "Value NQ" -> (popContext >> popContext) >> pEndLine+    "Value DQ" -> return () >> pHandleEndLine+    "Value SQ" -> return () >> pHandleEndLine+    _ -> pHandleEndLine  withAttribute attr txt = do   when (null txt) $ fail "Parser matched no text"@@ -154,7 +152,7 @@      return (attr, result)  parseRules "In Block" = -  do (attr, result) <- (((lookAhead (pRegExpr regex_'5c'7b'25'5cs'2aend'5ba'2dz'5d'2b'5cs'2a'25'5c'7d) >> return ([],"") ) >>~ (popContext >> return ()))+  do (attr, result) <- (((lookAhead (pRegExpr regex_'5c'7b'25'5cs'2aend'5ba'2dz'5d'2b'5cs'2a'25'5c'7d) >> return ([],"") ) >>~ (popContext))                         <|>                         ((parseRules "FindTemplate"))                         <|>@@ -170,11 +168,11 @@      return (attr, result)  parseRules "Template Comment" = -  do (attr, result) <- ((pRegExpr regex_'5c'7b'25'5cs'2aendcomment'5cs'2a'25'5c'7d >>= withAttribute "Template Comment") >>~ (popContext >> return ()))+  do (attr, result) <- ((pRegExpr regex_'5c'7b'25'5cs'2aendcomment'5cs'2a'25'5c'7d >>= withAttribute "Template Comment") >>~ (popContext))      return (attr, result)  parseRules "Template Var" = -  do (attr, result) <- (((pDetect2Chars False '}' '}' >>= withAttribute "Template Var") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetect2Chars False '}' '}' >>= withAttribute "Template Var") >>~ (popContext))                         <|>                         ((pDetectChar False '|' >>= withAttribute "Template Filter") >>~ pushContext "Template Filter")                         <|>@@ -186,7 +184,7 @@      return (attr, result)  parseRules "Template Filter" = -  do (attr, result) <- (((pDetect2Chars False '}' '}' >>= withAttribute "Template Var") >>~ (popContext >> popContext >> return ()))+  do (attr, result) <- (((pDetect2Chars False '}' '}' >>= withAttribute "Template Var") >>~ (popContext >> popContext))                         <|>                         ((pDetectChar False '\'' >>= withAttribute "Template String") >>~ pushContext "Single A-string")                         <|>@@ -210,7 +208,7 @@      return (attr, result)  parseRules "In Block Tag" = -  do (attr, result) <- (((pRegExprDynamic "\\{%\\s*end%1\\s*%\\}" >>= withAttribute "Template Tag") >>~ (popContext >> popContext >> popContext >> return ()))+  do (attr, result) <- (((pRegExprDynamic "\\{%\\s*end%1\\s*%\\}" >>= withAttribute "Template Tag") >>~ (popContext >> popContext >> popContext))                         <|>                         ((lookAhead (pRegExpr regex_'5c'7b'25'5cs'2aend'5ba'2dz'5d'2b'5cs'2a'25'5c'7d) >> return ([],"") ) >>~ pushContext "Non Matching Tag")                         <|>@@ -220,13 +218,13 @@      return (attr, result)  parseRules "Non Matching Tag" = -  do (attr, result) <- (((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_endblocktags >>= withAttribute "Mismatched Block Tag") >>~ (popContext >> return ()))+  do (attr, result) <- (((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_endblocktags >>= withAttribute "Mismatched Block Tag") >>~ (popContext))                         <|>-                        ((pDetectIdentifier >>= withAttribute "Template Tag") >>~ (popContext >> return ())))+                        ((pDetectIdentifier >>= withAttribute "Template Tag") >>~ (popContext)))      return (attr, result)  parseRules "In Template Tag" = -  do (attr, result) <- (((pDetect2Chars False '%' '}' >>= withAttribute "Template Tag") >>~ (popContext >> popContext >> return ()))+  do (attr, result) <- (((pDetect2Chars False '%' '}' >>= withAttribute "Template Tag") >>~ (popContext >> popContext))                         <|>                         ((pDetectChar False '\'' >>= withAttribute "Template String") >>~ pushContext "Single A-string")                         <|>@@ -242,13 +240,13 @@ parseRules "Single A-string" =    do (attr, result) <- (((pHlCStringChar >>= withAttribute "Template String"))                         <|>-                        ((pDetectChar False '\'' >>= withAttribute "Template String") >>~ (popContext >> return ())))+                        ((pDetectChar False '\'' >>= withAttribute "Template String") >>~ (popContext)))      return (attr, result)  parseRules "Single Q-string" =    do (attr, result) <- (((pHlCStringChar >>= withAttribute "Template String"))                         <|>-                        ((pDetectChar False '"' >>= withAttribute "Template String") >>~ (popContext >> return ())))+                        ((pDetectChar False '"' >>= withAttribute "Template String") >>~ (popContext)))      return (attr, result)  parseRules "FindHTML" = @@ -324,7 +322,7 @@                         <|>                         ((pDetectIdentifier >>= withAttribute "Comment"))                         <|>-                        ((pString False "-->" >>= withAttribute "Comment") >>~ (popContext >> return ()))+                        ((pString False "-->" >>= withAttribute "Comment") >>~ (popContext))                         <|>                         ((pRegExpr regex_'2d'28'2d'28'3f'21'2d'3e'29'29'2b >>= withAttribute "Error")))      return (attr, result)@@ -334,23 +332,23 @@                         <|>                         ((pDetectIdentifier >>= withAttribute "Normal Text"))                         <|>-                        ((pString False "]]>" >>= withAttribute "CDATA") >>~ (popContext >> return ()))+                        ((pString False "]]>" >>= withAttribute "CDATA") >>~ (popContext))                         <|>                         ((pString False "]]&gt;" >>= withAttribute "EntityRef")))      return (attr, result)  parseRules "PI" = -  do (attr, result) <- ((pDetect2Chars False '?' '>' >>= withAttribute "Processing Instruction") >>~ (popContext >> return ()))+  do (attr, result) <- ((pDetect2Chars False '?' '>' >>= withAttribute "Processing Instruction") >>~ (popContext))      return (attr, result)  parseRules "Doctype" = -  do (attr, result) <- (((pDetectChar False '>' >>= withAttribute "Doctype") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetectChar False '>' >>= withAttribute "Doctype") >>~ (popContext))                         <|>                         ((pDetectChar False '[' >>= withAttribute "Doctype") >>~ pushContext "Doctype Internal Subset"))      return (attr, result)  parseRules "Doctype Internal Subset" = -  do (attr, result) <- (((pDetectChar False ']' >>= withAttribute "Doctype") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetectChar False ']' >>= withAttribute "Doctype") >>~ (popContext))                         <|>                         ((parseRules "FindDTDRules"))                         <|>@@ -362,7 +360,7 @@      return (attr, result)  parseRules "Doctype Markupdecl" = -  do (attr, result) <- (((pDetectChar False '>' >>= withAttribute "Doctype") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetectChar False '>' >>= withAttribute "Doctype") >>~ (popContext))                         <|>                         ((pDetectChar False '"' >>= withAttribute "Value") >>~ pushContext "Doctype Markupdecl DQ")                         <|>@@ -370,21 +368,21 @@      return (attr, result)  parseRules "Doctype Markupdecl DQ" = -  do (attr, result) <- (((pDetectChar False '"' >>= withAttribute "Value") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetectChar False '"' >>= withAttribute "Value") >>~ (popContext))                         <|>                         ((parseRules "FindPEntityRefs")))      return (attr, result)  parseRules "Doctype Markupdecl SQ" = -  do (attr, result) <- (((pDetectChar False '\'' >>= withAttribute "Value") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetectChar False '\'' >>= withAttribute "Value") >>~ (popContext))                         <|>                         ((parseRules "FindPEntityRefs")))      return (attr, result)  parseRules "El Open" = -  do (attr, result) <- (((pDetect2Chars False '/' '>' >>= withAttribute "Element") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetect2Chars False '/' '>' >>= withAttribute "Element") >>~ (popContext))                         <|>-                        ((pDetectChar False '>' >>= withAttribute "Element") >>~ (popContext >> return ()))+                        ((pDetectChar False '>' >>= withAttribute "Element") >>~ (popContext))                         <|>                         ((parseRules "FindAttributes"))                         <|>@@ -394,25 +392,25 @@      return (attr, result)  parseRules "El Close" = -  do (attr, result) <- (((pDetectChar False '>' >>= withAttribute "Element") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetectChar False '>' >>= withAttribute "Element") >>~ (popContext))                         <|>                         ((pRegExpr regex_'5cS >>= withAttribute "Error")))      return (attr, result)  parseRules "El Close 2" = -  do (attr, result) <- (((pDetectChar False '>' >>= withAttribute "Element") >>~ (popContext >> popContext >> popContext >> return ()))+  do (attr, result) <- (((pDetectChar False '>' >>= withAttribute "Element") >>~ (popContext >> popContext >> popContext))                         <|>                         ((pRegExpr regex_'5cS >>= withAttribute "Error")))      return (attr, result)  parseRules "El Close 3" = -  do (attr, result) <- (((pDetectChar False '>' >>= withAttribute "Element") >>~ (popContext >> popContext >> popContext >> popContext >> return ()))+  do (attr, result) <- (((pDetectChar False '>' >>= withAttribute "Element") >>~ (popContext >> popContext >> popContext >> popContext))                         <|>                         ((pRegExpr regex_'5cS >>= withAttribute "Error")))      return (attr, result)  parseRules "CSS" = -  do (attr, result) <- (((pDetect2Chars False '/' '>' >>= withAttribute "Element") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetect2Chars False '/' '>' >>= withAttribute "Element") >>~ (popContext))                         <|>                         ((pDetectChar False '>' >>= withAttribute "Element") >>~ pushContext "CSS content")                         <|>@@ -432,7 +430,7 @@      return (attr, result)  parseRules "JS" = -  do (attr, result) <- (((pDetect2Chars False '/' '>' >>= withAttribute "Element") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetect2Chars False '/' '>' >>= withAttribute "Element") >>~ (popContext))                         <|>                         ((pDetectChar False '>' >>= withAttribute "Element") >>~ pushContext "JS content")                         <|>@@ -480,11 +478,11 @@                         <|>                         ((pRegExpr regex_'5b'5e'2f'3e'3c'22'27'5cs'5d >>= withAttribute "Value"))                         <|>-                        ((popContext >> popContext >> return ()) >> return ([], "")))+                        ((popContext >> popContext) >> return ([], "")))      return (attr, result)  parseRules "Value DQ" = -  do (attr, result) <- (((pDetectChar False '"' >>= withAttribute "Value") >>~ (popContext >> popContext >> return ()))+  do (attr, result) <- (((pDetectChar False '"' >>= withAttribute "Value") >>~ (popContext >> popContext))                         <|>                         ((parseRules "FindTemplate"))                         <|>@@ -492,7 +490,7 @@      return (attr, result)  parseRules "Value SQ" = -  do (attr, result) <- (((pDetectChar False '\'' >>= withAttribute "Value") >>~ (popContext >> popContext >> return ()))+  do (attr, result) <- (((pDetectChar False '\'' >>= withAttribute "Value") >>~ (popContext >> popContext))                         <|>                         ((parseRules "FindTemplate"))                         <|>

@@ -1,4 +1,4 @@-{- This module was generated from data in the Kate syntax highlighting file doxygen.xml, version 1.29,+{- This module was generated from data in the Kate syntax highlighting file doxygen.xml, version 1.31,    by  Dominik Haumann (dhdev@gmx.de) -}  module Text.Highlighting.Kate.Syntax.Doxygen ( highlight, parseExpression, syntaxName, syntaxExtensions ) where@@ -48,37 +48,42 @@ parseSourceLine = manyTill parseExpressionInternal pEndLine  pEndLine = do-  newline <|> (eof >> return '\n')+  lookAhead $ newline <|> (eof >> return '\n')   context <- currentContext   case context of-    "Normal" -> return ()-    "LineComment" -> (popContext >> return ())-    "BlockComment" -> return ()-    "ML_TagWord" -> (popContext >> return ())-    "ML_TagParam" -> (popContext >> return ())-    "ML_TagWordWord" -> (popContext >> return ())-    "ML_Tag2ndWord" -> (popContext >> popContext >> return ())-    "ML_TagString" -> (popContext >> return ())-    "ML_TagWordString" -> (popContext >> return ())-    "ML_htmltag" -> return ()-    "ML_htmlcomment" -> return ()-    "ML_identifiers" -> return ()-    "ML_types1" -> return ()-    "ML_types2" -> return ()-    "SL_TagWord" -> (popContext >> return ())-    "SL_TagParam" -> (popContext >> return ())-    "SL_TagWordWord" -> (popContext >> return ())-    "SL_Tag2ndWord" -> (popContext >> popContext >> return ())-    "SL_TagString" -> (popContext >> return ())-    "SL_TagWordString" -> (popContext >> return ())-    "SL_htmltag" -> (popContext >> return ())-    "SL_htmlcomment" -> (popContext >> return ())-    "SL_identifiers" -> (popContext >> return ())-    "SL_types1" -> (popContext >> return ())-    "SL_types2" -> (popContext >> return ())-    _ -> return ()-  lineContents <- lookAhead wholeLine-  updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }+    "Normal" -> return () >> pHandleEndLine+    "LineComment" -> (popContext) >> pEndLine+    "BlockComment" -> return () >> pHandleEndLine+    "ML_TagWord" -> (popContext) >> pEndLine+    "ML_TagParam" -> (popContext) >> pEndLine+    "ML_TagWordWord" -> (popContext) >> pEndLine+    "ML_Tag2ndWord" -> (popContext >> popContext) >> pEndLine+    "ML_TagString" -> (popContext) >> pEndLine+    "ML_TagWordString" -> (popContext) >> pEndLine+    "ML_htmltag" -> return () >> pHandleEndLine+    "ML_htmlcomment" -> return () >> pHandleEndLine+    "ML_identifiers" -> return () >> pHandleEndLine+    "ML_types1" -> return () >> pHandleEndLine+    "ML_types2" -> return () >> pHandleEndLine+    "SL_TagWord" -> (popContext) >> pEndLine+    "SL_TagParam" -> (popContext) >> pEndLine+    "SL_TagWordWord" -> (popContext) >> pEndLine+    "SL_Tag2ndWord" -> (popContext >> popContext) >> pEndLine+    "SL_TagString" -> (popContext) >> pEndLine+    "SL_TagWordString" -> (popContext) >> pEndLine+    "SL_htmltag" -> (popContext) >> pEndLine+    "SL_htmlcomment" -> (popContext) >> pEndLine+    "SL_identifiers" -> (popContext) >> pEndLine+    "SL_types1" -> (popContext) >> pEndLine+    "SL_types2" -> (popContext) >> pEndLine+    "SL_DetectEnv" -> (popContext) >> pEndLine+    "SL_DetectComment" -> (popContext) >> pEndLine+    "Code" -> return () >> pHandleEndLine+    "Verbatim" -> return () >> pHandleEndLine+    "Formula" -> return () >> pHandleEndLine+    "Msc" -> return () >> pHandleEndLine+    "Dot" -> return () >> pHandleEndLine+    _ -> pHandleEndLine  withAttribute attr txt = do   when (null txt) $ fail "Parser matched no text"@@ -89,18 +94,18 @@   updateState $ \st -> st { synStCharsParsedInLine = oldCharsParsed + length txt, synStPrevChar = prevchar }    return (labs, txt) -styles = [("Tags","kw"),("Word","kw"),("HTML Tag","kw"),("Description","st"),("Comment","co"),("Region","re"),("Identifier","ot"),("HTML Comment","co"),("Types","dt")]+styles = [("Tags","kw"),("Word","kw"),("HTML Tag","kw"),("Description","st"),("Comment","co"),("Region","re"),("Identifier","ot"),("HTML Comment","co"),("Types","dt"),("Code","co"),("Dot Graph","co"),("Formulas","co"),("Message Sequence Chart","co"),("Verbatim","co")]  parseExpressionInternal = do   context <- currentContext   parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes)) -list_TagOnly = Set.fromList $ words $ "\\arg \\attention \\author \\callgraph \\code \\dot \\else \\endcode \\endcond \\enddot \\endhtmlonly \\endif \\endlatexonly \\endlink \\endmanonly \\endverbatim \\endxmlonly \\f[ \\f] \\f$ \\hideinitializer \\htmlonly \\interface \\internal \\invariant \\~ \\@ \\$ \\\\ \\# \\latexonly \\li \\manonly \\n \\nosubgrouping \\note \\only \\post \\pre \\remarks \\return \\returns \\sa \\see \\showinitializer \\since \\test \\todo \\verbatim \\warning \\xmlonly @arg @attention @author @callgraph @code @dot @else @endcode @endcond @enddot @endhtmlonly @endif @endlatexonly @endlink @endmanonly @endverbatim @endxmlonly @f[ @f] @f$ @hideinitializer @htmlonly @interface @internal @invariant @~ @@ @$ @\\ @# @latexonly @li @manonly @n @nosubgrouping @note @only @post @pre @remarks @return @returns @sa @see @showinitializer @since @test @todo @verbatim @warning @xmlonly"-list_TagWord = Set.fromList $ words $ "\\addtogroup \\a \\anchor \\b \\c \\class \\cond \\copydoc \\def \\dontinclude \\dotfile \\e \\elseif \\em \\enum \\example \\exception \\exceptions \\file \\htmlinclude \\if \\ifnot \\include \\link \\namespace \\p \\package \\ref \\relatesalso \\relates \\retval \\throw \\throws \\verbinclude \\version \\xrefitem @addtogroup @a @anchor @b @c @class @cond @copydoc @def @dontinclude @dotfile @e @elseif @em @enum @example @exception @exceptions @file @htmlinclude @if @ifnot @include @link @namespace @p @package @ref @relatesalso @relates @retval @throw @throws @verbinclude @version @xrefitem"-list_TagParam = Set.fromList $ words $ "\\param @param"+list_TagOnly = Set.fromList $ words $ "\\arg \\attention \\author \\callgraph \\callergraph \\details \\dot \\else \\endcond \\enddot \\endhtmlonly \\endif \\endlatexonly \\endlink \\endmanonly \\endmsc \\endverbatim \\endxmlonly \\f[ \\f] \\f$ \\hideinitializer \\htmlonly \\interface \\internal \\invariant \\~ \\@ \\$ \\\\ \\# \\latexonly \\li \\manonly \\msc \\n \\nosubgrouping \\note \\only \\post \\pre \\private \\privatesection \\protected \\protectedsection \\public \\publicsection \\remarks \\return \\returns \\showinitializer \\since \\test \\todo \\verbatim \\warning \\xmlonly @arg @attention @author @callgraph @callergraph @details @dot @else @endcond @enddot @endhtmlonly @endif @endlatexonly @endlink @endmanonly @endmsc @endverbatim @endxmlonly @f[ @f] @f$ @hideinitializer @htmlonly @interface @internal @invariant @~ @@ @$ @\\ @# @latexonly @li @manonly @msc @n @nosubgrouping @note @only @post @pre @pivate @pivatesection @protected @protectedsection @public @publicsection @remarks @return @returns @showinitializer @since @test @todo @verbatim @warning @xmlonly"+list_TagWord = Set.fromList $ words $ "\\addtogroup \\a \\anchor \\b \\c \\class \\cond \\copybrief \\copydetails \\copydoc \\def \\dir \\dontinclude \\dotfile \\e \\elseif \\em \\enum \\example \\exception \\exceptions \\extends \\file \\htmlinclude \\if \\ifnot \\implements \\include \\includelineno \\link \\memberof \\namespace \\p \\package \\property \\protocol \\ref \\relatesalso \\relates \\retval \\throw \\throws \\verbinclude \\version \\xrefitem @addtogroup @a @anchor @b @c @class @cond @copybrief @copydetails @copydoc @def @dir @dontinclude @dotfile @e @elseif @em @enum @example @exception @exceptions @extends @file @htmlinclude @if @ifnot @implements @include @includelineno @link @memberof @namespace @p @package @property @prtocol @ref @relatesalso @relates @retval @throw @throws @verbinclude @version @xrefitem"+list_TagParam = Set.fromList $ words $ "\\param \\tparam @param @tparam" list_TagWordWord = Set.fromList $ words $ "\\image @image"-list_TagWordString = Set.fromList $ words $ "\\defgroup \\page \\paragraph \\section \\struct \\subsection \\subsubsection \\union \\weakgroup @defgroup @page @paragraph @section @struct @subsection @subsubsection @union @weakgroup"-list_TagString = Set.fromList $ words $ "\\addindex \\brief \\bug \\date \\deprecated \\fn \\ingroup \\line \\mainpage \\name \\overload \\par \\short \\skip \\skipline \\typedef \\until \\var @addindex @brief @bug @date @deprecated @fn @ingroup @line @mainpage @name @overload @par @short @skip @skipline @typedef @until @var"+list_TagWordString = Set.fromList $ words $ "\\category \\defgroup \\headerfile \\page \\paragraph \\section \\struct \\subpage \\subsection \\subsubsection \\union \\weakgroup @category @defgroup @headerfile @page @paragraph @section @struct @subpage @subsection @subsubsection @union @weakgroup"+list_TagString = Set.fromList $ words $ "\\addindex \\brief \\bug \\date \\deprecated \\fn \\ingroup \\line \\mainpage \\name \\overload \\par \\sa \\see \\short \\skip \\skipline \\typedef \\until \\var @addindex @brief @bug @date @deprecated @fn @ingroup @line @mainpage @name @overload @par @sa @see @short @skip @skipline @typedef @until @var"  regex_'2f'2f'28'21'7c'28'2f'28'3f'3d'5b'5e'2f'5d'7c'24'29'29'29'3c'3f = compileRegex "//(!|(/(?=[^/]|$)))<?" regex_'2f'5c'2a'28'5c'2a'5b'5e'2a'2f'5d'7c'21'7c'5b'2a'21'5d'3c'7c'5c'2a'24'29 = compileRegex "/\\*(\\*[^*/]|!|[*!]<|\\*$)"@@ -115,8 +120,20 @@ regex_'2e = compileRegex "." regex_'5cs'2a'3d'5cs'2a = compileRegex "\\s*=\\s*" regex_'5cs'2a'23'3f'5ba'2dzA'2dZ0'2d9'5d'2a = compileRegex "\\s*#?[a-zA-Z0-9]*"+regex_'5b'40'5c'5c'5dcode = compileRegex "[@\\\\]code"+regex_'5b'40'5c'5c'5dverbatim = compileRegex "[@\\\\]verbatim"+regex_'5b'40'5c'5c'5df'5c'5b = compileRegex "[@\\\\]f\\["+regex_'5b'40'5c'5c'5dmsc = compileRegex "[@\\\\]msc"+regex_'5b'40'5c'5c'5ddot = compileRegex "[@\\\\]dot"+regex_'5cs'2a'28'5c'2a'2f'29 = compileRegex "\\s*(\\*/)"+regex_'5cs'2a'28'5c'2a'7c'2f'2f'28'21'7c'28'2f'28'3f'3d'5b'5e'2f'5d'7c'24'29'29'29'3c'3f'29 = compileRegex "\\s*(\\*|//(!|(/(?=[^/]|$)))<?)"+regex_'5b'40'5c'5c'5dendcode = compileRegex "[@\\\\]endcode"+regex_'5b'40'5c'5c'5dendverbatim = compileRegex "[@\\\\]endverbatim"+regex_'5b'40'5c'5c'5df'5c'5d = compileRegex "[@\\\\]f\\]"+regex_'5b'40'5c'5c'5dendmsc = compileRegex "[@\\\\]endmsc"+regex_'5b'40'5c'5c'5denddot = compileRegex "[@\\\\]enddot" -defaultAttributes = [("Normal","Normal Text"),("LineComment","Comment"),("BlockComment","Comment"),("ML_TagWord","Comment"),("ML_TagParam","Comment"),("ML_TagWordWord","Comment"),("ML_Tag2ndWord","Comment"),("ML_TagString","Comment"),("ML_TagWordString","Comment"),("ML_htmltag","Identifier"),("ML_htmlcomment","HTML Comment"),("ML_identifiers","Identifier"),("ML_types1","Types"),("ML_types2","Types"),("SL_TagWord","Comment"),("SL_TagParam","Comment"),("SL_TagWordWord","Comment"),("SL_Tag2ndWord","Comment"),("SL_TagString","Comment"),("SL_TagWordString","Comment"),("SL_htmltag","Identifier"),("SL_htmlcomment","HTML Comment"),("SL_identifiers","Identifier"),("SL_types1","Types"),("SL_types2","Types")]+defaultAttributes = [("Normal","Normal Text"),("LineComment","Comment"),("BlockComment","Comment"),("ML_TagWord","Comment"),("ML_TagParam","Comment"),("ML_TagWordWord","Comment"),("ML_Tag2ndWord","Comment"),("ML_TagString","Comment"),("ML_TagWordString","Comment"),("ML_htmltag","Identifier"),("ML_htmlcomment","HTML Comment"),("ML_identifiers","Identifier"),("ML_types1","Types"),("ML_types2","Types"),("SL_TagWord","Comment"),("SL_TagParam","Comment"),("SL_TagWordWord","Comment"),("SL_Tag2ndWord","Comment"),("SL_TagString","Comment"),("SL_TagWordString","Comment"),("SL_htmltag","Identifier"),("SL_htmlcomment","HTML Comment"),("SL_identifiers","Identifier"),("SL_types1","Types"),("SL_types2","Types"),("SL_DetectEnv",""),("SL_DetectComment",""),("Code","Code"),("Verbatim","Verbatim"),("Formula","Formulas"),("Msc","Message Sequence Chart"),("Dot","Dot Graph")]  parseRules "Normal" =    do (attr, result) <- (((pRegExpr regex_'2f'2f'28'21'7c'28'2f'28'3f'3d'5b'5e'2f'5d'7c'24'29'29'29'3c'3f >>= withAttribute "Comment") >>~ pushContext "LineComment")@@ -133,10 +150,14 @@      return (attr, result)  parseRules "LineComment" = -  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Comment"))+  do (attr, result) <- (((pLineContinue >>= withAttribute "Comment"))                         <|>+                        ((pDetectSpaces >>= withAttribute "Comment"))+                        <|>                         ((Text.Highlighting.Kate.Syntax.Alert.parseExpression))                         <|>+                        ((parseRules "SL_DetectEnv"))+                        <|>                         ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}" list_TagOnly >>= withAttribute "Tags"))                         <|>                         ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}" list_TagWord >>= withAttribute "Tags") >>~ pushContext "SL_TagWord")@@ -161,7 +182,7 @@ parseRules "BlockComment" =    do (attr, result) <- (((pDetectSpaces >>= withAttribute "Comment"))                         <|>-                        ((pDetect2Chars False '*' '/' >>= withAttribute "Comment") >>~ (popContext >> return ()))+                        ((pDetect2Chars False '*' '/' >>= withAttribute "Comment") >>~ (popContext))                         <|>                         ((Text.Highlighting.Kate.Syntax.Alert.parseExpression))                         <|>@@ -169,6 +190,8 @@                         <|>                         ((pDetect2Chars False '@' '}' >>= withAttribute "Region"))                         <|>+                        ((parseRules "SL_DetectEnv"))+                        <|>                         ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}" list_TagOnly >>= withAttribute "Tags"))                         <|>                         ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}" list_TagWord >>= withAttribute "Tags") >>~ pushContext "ML_TagWord")@@ -193,13 +216,13 @@      return (attr, result)  parseRules "ML_TagWord" = -  do (attr, result) <- (((lookAhead (pDetect2Chars False '*' '/') >> return ([],"") ) >>~ (popContext >> return ()))+  do (attr, result) <- (((lookAhead (pDetect2Chars False '*' '/') >> return ([],"") ) >>~ (popContext))                         <|>                         ((parseRules "SL_TagWord")))      return (attr, result)  parseRules "ML_TagParam" = -  do (attr, result) <- (((lookAhead (pDetect2Chars False '*' '/') >> return ([],"") ) >>~ (popContext >> return ()))+  do (attr, result) <- (((lookAhead (pDetect2Chars False '*' '/') >> return ([],"") ) >>~ (popContext))                         <|>                         ((pDetectSpaces >>= withAttribute "Comment"))                         <|>@@ -209,13 +232,13 @@                         <|>                         ((pString False "[in,out]" >>= withAttribute "Tags") >>~ pushContext "ML_Tag2ndWord")                         <|>-                        ((pRegExpr regex_'5cS'28'3f'3d'28'5b'5d'5b'2c'3f'3b'28'29'5d'7c'5c'2e'24'7c'5c'2e'3f'5cs'29'29 >>= withAttribute "Word") >>~ (popContext >> return ()))+                        ((pRegExpr regex_'5cS'28'3f'3d'28'5b'5d'5b'2c'3f'3b'28'29'5d'7c'5c'2e'24'7c'5c'2e'3f'5cs'29'29 >>= withAttribute "Word") >>~ (popContext))                         <|>                         ((pRegExpr regex_'5cS >>= withAttribute "Word")))      return (attr, result)  parseRules "ML_TagWordWord" = -  do (attr, result) <- (((lookAhead (pDetect2Chars False '*' '/') >> return ([],"") ) >>~ (popContext >> return ()))+  do (attr, result) <- (((lookAhead (pDetect2Chars False '*' '/') >> return ([],"") ) >>~ (popContext))                         <|>                         ((pDetectSpaces >>= withAttribute "Comment"))                         <|>@@ -225,7 +248,7 @@      return (attr, result)  parseRules "ML_Tag2ndWord" = -  do (attr, result) <- (((lookAhead (pDetect2Chars False '*' '/') >> return ([],"") ) >>~ (popContext >> popContext >> return ()))+  do (attr, result) <- (((lookAhead (pDetect2Chars False '*' '/') >> return ([],"") ) >>~ (popContext >> popContext))                         <|>                         ((parseRules "SL_Tag2ndWord")))      return (attr, result)@@ -233,7 +256,7 @@ parseRules "ML_TagString" =    do (attr, result) <- (((pDetectSpaces >>= withAttribute "Comment"))                         <|>-                        ((lookAhead (pDetect2Chars False '*' '/') >> return ([],"") ) >>~ (popContext >> return ()))+                        ((lookAhead (pDetect2Chars False '*' '/') >> return ([],"") ) >>~ (popContext))                         <|>                         ((pString False "<!--" >>= withAttribute "HTML Comment") >>~ pushContext "ML_htmlcomment")                         <|>@@ -245,33 +268,33 @@      return (attr, result)  parseRules "ML_TagWordString" = -  do (attr, result) <- (((lookAhead (pDetect2Chars False '*' '/') >> return ([],"") ) >>~ (popContext >> return ()))+  do (attr, result) <- (((lookAhead (pDetect2Chars False '*' '/') >> return ([],"") ) >>~ (popContext))                         <|>                         ((parseRules "SL_TagWordString")))      return (attr, result)  parseRules "ML_htmltag" = -  do (attr, result) <- (((lookAhead (pDetect2Chars False '*' '/') >> return ([],"") ) >>~ (popContext >> return ()))+  do (attr, result) <- (((lookAhead (pDetect2Chars False '*' '/') >> return ([],"") ) >>~ (popContext))                         <|>-                        ((pDetect2Chars False '/' '>' >>= withAttribute "HTML Tag") >>~ (popContext >> return ()))+                        ((pDetect2Chars False '/' '>' >>= withAttribute "HTML Tag") >>~ (popContext))                         <|>-                        ((pDetectChar False '>' >>= withAttribute "HTML Tag") >>~ (popContext >> return ()))+                        ((pDetectChar False '>' >>= withAttribute "HTML Tag") >>~ (popContext))                         <|>                         ((pRegExpr regex_'5cs'2a'3d'5cs'2a >>= withAttribute "Identifier") >>~ pushContext "ML_identifiers"))      return (attr, result)  parseRules "ML_htmlcomment" = -  do (attr, result) <- (((lookAhead (pDetect2Chars False '*' '/') >> return ([],"") ) >>~ (popContext >> return ()))+  do (attr, result) <- (((lookAhead (pDetect2Chars False '*' '/') >> return ([],"") ) >>~ (popContext))                         <|>                         ((Text.Highlighting.Kate.Syntax.Alert.parseExpression))                         <|>-                        ((pString False "-->" >>= withAttribute "HTML Comment") >>~ (popContext >> return ())))+                        ((pString False "-->" >>= withAttribute "HTML Comment") >>~ (popContext)))      return (attr, result)  parseRules "ML_identifiers" = -  do (attr, result) <- (((lookAhead (pDetect2Chars False '*' '/') >> return ([],"") ) >>~ (popContext >> return ()))+  do (attr, result) <- (((lookAhead (pDetect2Chars False '*' '/') >> return ([],"") ) >>~ (popContext))                         <|>-                        ((pRegExpr regex_'5cs'2a'23'3f'5ba'2dzA'2dZ0'2d9'5d'2a >>= withAttribute "String") >>~ (popContext >> return ()))+                        ((pRegExpr regex_'5cs'2a'23'3f'5ba'2dzA'2dZ0'2d9'5d'2a >>= withAttribute "String") >>~ (popContext))                         <|>                         ((pDetectChar False '\'' >>= withAttribute "Types") >>~ pushContext "ML_types1")                         <|>@@ -279,23 +302,23 @@      return (attr, result)  parseRules "ML_types1" = -  do (attr, result) <- (((lookAhead (pDetect2Chars False '*' '/') >> return ([],"") ) >>~ (popContext >> return ()))+  do (attr, result) <- (((lookAhead (pDetect2Chars False '*' '/') >> return ([],"") ) >>~ (popContext))                         <|>-                        ((pDetectChar False '\'' >>= withAttribute "Types") >>~ (popContext >> popContext >> return ())))+                        ((pDetectChar False '\'' >>= withAttribute "Types") >>~ (popContext >> popContext)))      return (attr, result)  parseRules "ML_types2" = -  do (attr, result) <- (((lookAhead (pDetect2Chars False '*' '/') >> return ([],"") ) >>~ (popContext >> return ()))+  do (attr, result) <- (((lookAhead (pDetect2Chars False '*' '/') >> return ([],"") ) >>~ (popContext))                         <|>-                        ((pDetectChar False '"' >>= withAttribute "Types") >>~ (popContext >> popContext >> return ())))+                        ((pDetectChar False '"' >>= withAttribute "Types") >>~ (popContext >> popContext)))      return (attr, result)  parseRules "SL_TagWord" =    do (attr, result) <- (((pDetectSpaces >>= withAttribute "Comment"))                         <|>-                        ((lookAhead (pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}" list_TagWord) >> return ([],"") ) >>~ (popContext >> return ()))+                        ((lookAhead (pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}" list_TagWord) >> return ([],"") ) >>~ (popContext))                         <|>-                        ((pRegExpr regex_'5cS'28'3f'3d'28'5b'5d'5b'2c'3f'3b'28'29'5d'7c'5c'2e'24'7c'5c'2e'3f'5cs'29'29 >>= withAttribute "Word") >>~ (popContext >> return ()))+                        ((pRegExpr regex_'5cS'28'3f'3d'28'5b'5d'5b'2c'3f'3b'28'29'5d'7c'5c'2e'24'7c'5c'2e'3f'5cs'29'29 >>= withAttribute "Word") >>~ (popContext))                         <|>                         ((pRegExpr regex_'5cS >>= withAttribute "Word")))      return (attr, result)@@ -309,7 +332,7 @@                         <|>                         ((pString False "[in,out]" >>= withAttribute "Tags") >>~ pushContext "SL_Tag2ndWord")                         <|>-                        ((pRegExpr regex_'5cS'28'3f'3d'28'5b'5d'5b'2c'3f'3b'28'29'5d'7c'5c'2e'24'7c'5c'2e'3f'5cs'29'29 >>= withAttribute "Word") >>~ (popContext >> return ()))+                        ((pRegExpr regex_'5cS'28'3f'3d'28'5b'5d'5b'2c'3f'3b'28'29'5d'7c'5c'2e'24'7c'5c'2e'3f'5cs'29'29 >>= withAttribute "Word") >>~ (popContext))                         <|>                         ((pRegExpr regex_'5cS >>= withAttribute "Word")))      return (attr, result)@@ -325,7 +348,7 @@ parseRules "SL_Tag2ndWord" =    do (attr, result) <- (((pDetectSpaces >>= withAttribute "Comment"))                         <|>-                        ((pRegExpr regex_'5cS'28'3f'3d'28'5b'5d'5b'2c'3f'3b'28'29'5d'7c'5c'2e'24'7c'5c'2e'3f'5cs'29'29 >>= withAttribute "Word") >>~ (popContext >> popContext >> return ()))+                        ((pRegExpr regex_'5cS'28'3f'3d'28'5b'5d'5b'2c'3f'3b'28'29'5d'7c'5c'2e'24'7c'5c'2e'3f'5cs'29'29 >>= withAttribute "Word") >>~ (popContext >> popContext))                         <|>                         ((pRegExpr regex_'5cS >>= withAttribute "Word")))      return (attr, result)@@ -345,15 +368,15 @@ parseRules "SL_TagWordString" =    do (attr, result) <- (((pDetectSpaces >>= withAttribute "Comment"))                         <|>-                        ((pRegExpr regex_'5cS'28'3f'3d'28'5b'5d'5b'2c'3f'3b'28'29'5d'7c'5c'2e'24'7c'5c'2e'3f'5cs'29'29 >>= withAttribute "Word") >>~ (popContext >> return ()))+                        ((pRegExpr regex_'5cS'28'3f'3d'28'5b'5d'5b'2c'3f'3b'28'29'5d'7c'5c'2e'24'7c'5c'2e'3f'5cs'29'29 >>= withAttribute "Word") >>~ (popContext))                         <|>                         ((pRegExpr regex_'5cS >>= withAttribute "Word")))      return (attr, result)  parseRules "SL_htmltag" = -  do (attr, result) <- (((pDetect2Chars False '/' '>' >>= withAttribute "HTML Tag") >>~ (popContext >> return ()))+  do (attr, result) <- (((pDetect2Chars False '/' '>' >>= withAttribute "HTML Tag") >>~ (popContext))                         <|>-                        ((pDetectChar False '>' >>= withAttribute "HTML Tag") >>~ (popContext >> return ()))+                        ((pDetectChar False '>' >>= withAttribute "HTML Tag") >>~ (popContext))                         <|>                         ((pRegExpr regex_'5cs'2a'3d'5cs'2a >>= withAttribute "Identifier") >>~ pushContext "SL_identifiers"))      return (attr, result)@@ -361,11 +384,11 @@ parseRules "SL_htmlcomment" =    do (attr, result) <- (((Text.Highlighting.Kate.Syntax.Alert.parseExpression))                         <|>-                        ((pString False "-->" >>= withAttribute "HTML Comment") >>~ (popContext >> return ())))+                        ((pString False "-->" >>= withAttribute "HTML Comment") >>~ (popContext)))      return (attr, result)  parseRules "SL_identifiers" = -  do (attr, result) <- (((pRegExpr regex_'5cs'2a'23'3f'5ba'2dzA'2dZ0'2d9'5d'2a >>= withAttribute "String") >>~ (popContext >> return ()))+  do (attr, result) <- (((pRegExpr regex_'5cs'2a'23'3f'5ba'2dzA'2dZ0'2d9'5d'2a >>= withAttribute "String") >>~ (popContext))                         <|>                         ((pDetectChar False '\'' >>= withAttribute "Types") >>~ pushContext "SL_types1")                         <|>@@ -373,11 +396,59 @@      return (attr, result)  parseRules "SL_types1" = -  do (attr, result) <- ((pDetectChar False '\'' >>= withAttribute "Types") >>~ (popContext >> popContext >> return ()))+  do (attr, result) <- ((pDetectChar False '\'' >>= withAttribute "Types") >>~ (popContext >> popContext))      return (attr, result)  parseRules "SL_types2" = -  do (attr, result) <- ((pDetectChar False '"' >>= withAttribute "Types") >>~ (popContext >> popContext >> return ()))+  do (attr, result) <- ((pDetectChar False '"' >>= withAttribute "Types") >>~ (popContext >> popContext))+     return (attr, result)++parseRules "SL_DetectEnv" = +  do (attr, result) <- (((pRegExpr regex_'5b'40'5c'5c'5dcode >>= withAttribute "Tags") >>~ pushContext "Code")+                        <|>+                        ((pRegExpr regex_'5b'40'5c'5c'5dverbatim >>= withAttribute "Tags") >>~ pushContext "Verbatim")+                        <|>+                        ((pRegExpr regex_'5b'40'5c'5c'5df'5c'5b >>= withAttribute "Tags") >>~ pushContext "Formula")+                        <|>+                        ((pRegExpr regex_'5b'40'5c'5c'5dmsc >>= withAttribute "Tags") >>~ pushContext "Msc")+                        <|>+                        ((pRegExpr regex_'5b'40'5c'5c'5ddot >>= withAttribute "Tags") >>~ pushContext "Dot"))+     return (attr, result)++parseRules "SL_DetectComment" = +  do (attr, result) <- (((pColumn 0 >> pRegExpr regex_'5cs'2a'28'5c'2a'2f'29 >>= withAttribute "Comment") >>~ (popContext >> popContext))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5cs'2a'28'5c'2a'7c'2f'2f'28'21'7c'28'2f'28'3f'3d'5b'5e'2f'5d'7c'24'29'29'29'3c'3f'29 >>= withAttribute "Comment")))+     return (attr, result)++parseRules "Code" = +  do (attr, result) <- (((parseRules "SL_DetectComment"))+                        <|>+                        ((pRegExpr regex_'5b'40'5c'5c'5dendcode >>= withAttribute "Tags") >>~ (popContext)))+     return (attr, result)++parseRules "Verbatim" = +  do (attr, result) <- (((parseRules "SL_DetectComment"))+                        <|>+                        ((pRegExpr regex_'5b'40'5c'5c'5dendverbatim >>= withAttribute "Tags") >>~ (popContext)))+     return (attr, result)++parseRules "Formula" = +  do (attr, result) <- (((parseRules "SL_DetectComment"))+                        <|>+                        ((pRegExpr regex_'5b'40'5c'5c'5df'5c'5d >>= withAttribute "Tags") >>~ (popContext)))+     return (attr, result)++parseRules "Msc" = +  do (attr, result) <- (((parseRules "SL_DetectComment"))+                        <|>+                        ((pRegExpr regex_'5b'40'5c'5c'5dendmsc >>= withAttribute "Tags") >>~ (popContext)))+     return (attr, result)++parseRules "Dot" = +  do (attr, result) <- (((parseRules "SL_DetectComment"))+                        <|>+                        ((pRegExpr regex_'5b'40'5c'5c'5denddot >>= withAttribute "Tags") >>~ (popContext)))      return (attr, result)  parseRules x = fail $ "Unknown context" ++ x

@@ -0,0 +1,367 @@+{- This module was generated from data in the Kate syntax highlighting file doxygenlua.xml, version 1.01,+   by  Bruno Massa (brmassa@gmail.com) -}++module Text.Highlighting.Kate.Syntax.Doxygenlua ( highlight, parseExpression, syntaxName, syntaxExtensions ) where+import Text.Highlighting.Kate.Definitions+import Text.Highlighting.Kate.Common+import qualified Text.Highlighting.Kate.Syntax.Alert+import Text.ParserCombinators.Parsec+import Control.Monad (when)+import Data.Map (fromList)+import Data.Maybe (fromMaybe, maybeToList)++import qualified Data.Set as Set+-- | Full name of language.+syntaxName :: String+syntaxName = "DoxygenLua"++-- | Filename extensions for this language.+syntaxExtensions :: String+syntaxExtensions = "*.dox;*.doxygen"++-- | 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 = "DoxygenLua" }+  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 [("DoxygenLua",["Normal"])], synStLanguage = "DoxygenLua", synStCurrentLine = "", synStCharsParsedInLine = 0, synStPrevChar = '\n', synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}++parseSourceLine = manyTill parseExpressionInternal pEndLine++pEndLine = do+  lookAhead $ newline <|> (eof >> return '\n')+  context <- currentContext+  case context of+    "Normal" -> return () >> pHandleEndLine+    "LineComment" -> (popContext) >> pEndLine+    "BlockComment" -> return () >> pHandleEndLine+    "ML_TagWord" -> (popContext) >> pEndLine+    "ML_TagParam" -> (popContext) >> pEndLine+    "ML_TagWordWord" -> (popContext) >> pEndLine+    "ML_Tag2ndWord" -> (popContext >> popContext) >> pEndLine+    "ML_TagString" -> (popContext) >> pEndLine+    "ML_TagWordString" -> (popContext) >> pEndLine+    "ML_htmltag" -> return () >> pHandleEndLine+    "ML_htmlcomment" -> return () >> pHandleEndLine+    "ML_identifiers" -> return () >> pHandleEndLine+    "ML_types1" -> return () >> pHandleEndLine+    "ML_types2" -> return () >> pHandleEndLine+    "SL_TagWord" -> (popContext) >> pEndLine+    "SL_TagParam" -> (popContext) >> pEndLine+    "SL_TagWordWord" -> (popContext) >> pEndLine+    "SL_Tag2ndWord" -> (popContext >> popContext) >> pEndLine+    "SL_TagString" -> (popContext) >> pEndLine+    "SL_TagWordString" -> (popContext) >> pEndLine+    "SL_htmltag" -> (popContext) >> pEndLine+    "SL_htmlcomment" -> (popContext) >> pEndLine+    "SL_identifiers" -> (popContext) >> pEndLine+    "SL_types1" -> (popContext) >> pEndLine+    "SL_types2" -> (popContext) >> pEndLine+    _ -> pHandleEndLine++withAttribute attr txt = do+  when (null txt) $ fail "Parser matched no text"+  let labs = attr : maybeToList (lookup attr styles)+  st <- getState+  let oldCharsParsed = synStCharsParsedInLine st+  let prevchar = if null txt then '\n' else last txt+  updateState $ \st -> st { synStCharsParsedInLine = oldCharsParsed + length txt, synStPrevChar = prevchar } +  return (labs, txt)++styles = [("Tags","kw"),("Word","kw"),("HTML Tag","kw"),("Description","st"),("Comment","co"),("Region","re"),("Identifier","ot"),("HTML Comment","co"),("Types","dt")]++parseExpressionInternal = do+  context <- currentContext+  parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes))++list_TagOnly = Set.fromList $ words $ "\\arg \\attention \\author \\callgraph \\code \\dot \\else \\endcode \\endcond \\enddot \\endhtmlonly \\endif \\endlatexonly \\endlink \\endmanonly \\endverbatim \\endxmlonly \\f[ \\f] \\f$ \\hideinitializer \\htmlonly \\interface \\internal \\invariant \\~ \\@ \\$ \\\\ \\# \\latexonly \\li \\manonly \\n \\nosubgrouping \\note \\only \\post \\pre \\remarks \\return \\returns \\sa \\see \\showinitializer \\since \\test \\todo \\verbatim \\warning \\xmlonly @arg @attention @author @callgraph @code @dot @else @endcode @endcond @enddot @endhtmlonly @endif @endlatexonly @endlink @endmanonly @endverbatim @endxmlonly @f[ @f] @f$ @hideinitializer @htmlonly @interface @internal @invariant @~ @@ @$ @\\ @# @latexonly @li @manonly @n @nosubgrouping @note @only @post @pre @remarks @return @returns @sa @see @showinitializer @since @test @todo @verbatim @warning @xmlonly"+list_TagWord = Set.fromList $ words $ "\\addtogroup \\a \\anchor \\b \\c \\class \\cond \\copydoc \\def \\dontinclude \\dotfile \\e \\elseif \\em \\enum \\example \\exception \\exceptions \\file \\htmlinclude \\if \\ifnot \\include \\link \\namespace \\p \\package \\ref \\relatesalso \\relates \\retval \\throw \\throws \\verbinclude \\version \\xrefitem @addtogroup @a @anchor @b @c @class @cond @copydoc @def @dontinclude @dotfile @e @elseif @em @enum @example @exception @exceptions @file @htmlinclude @if @ifnot @include @link @namespace @p @package @ref @relatesalso @relates @retval @throw @throws @verbinclude @version @xrefitem"+list_TagParam = Set.fromList $ words $ "\\param @param"+list_TagWordWord = Set.fromList $ words $ "\\image @image"+list_TagWordString = Set.fromList $ words $ "\\defgroup \\page \\paragraph \\section \\struct \\subsection \\subsubsection \\union \\weakgroup @defgroup @page @paragraph @section @struct @subsection @subsubsection @union @weakgroup"+list_TagString = Set.fromList $ words $ "\\addindex \\brief \\bug \\date \\deprecated \\fn \\ingroup \\line \\mainpage \\name \\overload \\par \\short \\skip \\skipline \\typedef \\until \\var @addindex @brief @bug @date @deprecated @fn @ingroup @line @mainpage @name @overload @par @short @skip @skipline @typedef @until @var"++regex_'3c'5cs'2a'5c'2f'3f'5cs'2a'5ba'2dzA'2dZ'5f'3a'5d'5ba'2dzA'2dZ0'2d9'2e'5f'3a'2d'5d'2a = compileRegex "<\\s*\\/?\\s*[a-zA-Z_:][a-zA-Z0-9._:-]*"+regex_'5c'5c'28'3c'7c'3e'29 = compileRegex "\\\\(<|>)"+regex_'5cS'28'3f'3d'28'5b'5d'5b'2c'3f'3b'28'29'5d'7c'5c'2e'24'7c'5c'2e'3f'5cs'29'29 = compileRegex "\\S(?=([][,?;()]|\\.$|\\.?\\s))"+regex_'5cS = compileRegex "\\S"+regex_'2e = compileRegex "."+regex_'5cs'2a'3d'5cs'2a = compileRegex "\\s*=\\s*"+regex_'5cs'2a'23'3f'5ba'2dzA'2dZ0'2d9'5d'2a = compileRegex "\\s*#?[a-zA-Z0-9]*"++defaultAttributes = [("Normal","Normal Text"),("LineComment","Comment"),("BlockComment","Comment"),("ML_TagWord","Comment"),("ML_TagParam","Comment"),("ML_TagWordWord","Comment"),("ML_Tag2ndWord","Comment"),("ML_TagString","Comment"),("ML_TagWordString","Comment"),("ML_htmltag","Identifier"),("ML_htmlcomment","HTML Comment"),("ML_identifiers","Identifier"),("ML_types1","Types"),("ML_types2","Types"),("SL_TagWord","Comment"),("SL_TagParam","Comment"),("SL_TagWordWord","Comment"),("SL_Tag2ndWord","Comment"),("SL_TagString","Comment"),("SL_TagWordString","Comment"),("SL_htmltag","Identifier"),("SL_htmlcomment","HTML Comment"),("SL_identifiers","Identifier"),("SL_types1","Types"),("SL_types2","Types")]++parseRules "Normal" = +  do (attr, result) <- (((pRegExprDynamic "--\\[(=*)\\[" >>= withAttribute "Comment") >>~ pushContext "BlockComment")+                        <|>+                        ((pString False "--" >>= withAttribute "Comment") >>~ pushContext "LineComment"))+     return (attr, result)++parseRules "LineComment" = +  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Comment"))+                        <|>+                        ((Text.Highlighting.Kate.Syntax.Alert.parseExpression))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}" list_TagOnly >>= withAttribute "Tags"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}" list_TagWord >>= withAttribute "Tags") >>~ pushContext "SL_TagWord")+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}" list_TagParam >>= withAttribute "Tags") >>~ pushContext "SL_TagParam")+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}" list_TagWordWord >>= withAttribute "Tags") >>~ pushContext "SL_TagWordWord")+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}" list_TagString >>= withAttribute "Tags") >>~ pushContext "SL_TagString")+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}" list_TagWordString >>= withAttribute "Tags") >>~ pushContext "SL_TagWordString")+                        <|>+                        ((pDetectIdentifier >>= withAttribute "Comment"))+                        <|>+                        ((pString False "<!--" >>= withAttribute "HTML Comment") >>~ pushContext "SL_htmlcomment")+                        <|>+                        ((pDetect2Chars False '<' '<' >>= withAttribute "Comment"))+                        <|>+                        ((pRegExpr regex_'3c'5cs'2a'5c'2f'3f'5cs'2a'5ba'2dzA'2dZ'5f'3a'5d'5ba'2dzA'2dZ0'2d9'2e'5f'3a'2d'5d'2a >>= withAttribute "HTML Tag") >>~ pushContext "SL_htmltag"))+     return (attr, result)++parseRules "BlockComment" = +  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Comment"))+                        <|>+                        ((pRegExprDynamic "\\]%1\\]" >>= withAttribute "Comment") >>~ (popContext))+                        <|>+                        ((Text.Highlighting.Kate.Syntax.Alert.parseExpression))+                        <|>+                        ((pDetect2Chars False '@' '{' >>= withAttribute "Region"))+                        <|>+                        ((pDetect2Chars False '@' '}' >>= withAttribute "Region"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}" list_TagOnly >>= withAttribute "Tags"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}" list_TagWord >>= withAttribute "Tags") >>~ pushContext "ML_TagWord")+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}" list_TagParam >>= withAttribute "Tags") >>~ pushContext "ML_TagParam")+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}" list_TagWordWord >>= withAttribute "Tags") >>~ pushContext "ML_TagWordWord")+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}" list_TagString >>= withAttribute "Tags") >>~ pushContext "ML_TagString")+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}" list_TagWordString >>= withAttribute "Tags") >>~ pushContext "ML_TagWordString")+                        <|>+                        ((pDetectIdentifier >>= withAttribute "Comment"))+                        <|>+                        ((pRegExpr regex_'5c'5c'28'3c'7c'3e'29 >>= withAttribute "Tags"))+                        <|>+                        ((pDetect2Chars False '<' '<' >>= withAttribute "Comment"))+                        <|>+                        ((pRegExpr regex_'3c'5cs'2a'5c'2f'3f'5cs'2a'5ba'2dzA'2dZ'5f'3a'5d'5ba'2dzA'2dZ0'2d9'2e'5f'3a'2d'5d'2a >>= withAttribute "HTML Tag") >>~ pushContext "ML_htmltag")+                        <|>+                        ((pString False "<!--" >>= withAttribute "HTML Comment") >>~ pushContext "ML_htmlcomment"))+     return (attr, result)++parseRules "ML_TagWord" = +  do (attr, result) <- (((lookAhead (pDetect2Chars False '*' '/') >> return ([],"") ) >>~ (popContext))+                        <|>+                        ((parseRules "SL_TagWord")))+     return (attr, result)++parseRules "ML_TagParam" = +  do (attr, result) <- (((lookAhead (pDetect2Chars False '*' '/') >> return ([],"") ) >>~ (popContext))+                        <|>+                        ((pDetectSpaces >>= withAttribute "Comment"))+                        <|>+                        ((pString False "[in]" >>= withAttribute "Tags") >>~ pushContext "ML_Tag2ndWord")+                        <|>+                        ((pString False "[out]" >>= withAttribute "Tags") >>~ pushContext "ML_Tag2ndWord")+                        <|>+                        ((pString False "[in,out]" >>= withAttribute "Tags") >>~ pushContext "ML_Tag2ndWord")+                        <|>+                        ((pRegExpr regex_'5cS'28'3f'3d'28'5b'5d'5b'2c'3f'3b'28'29'5d'7c'5c'2e'24'7c'5c'2e'3f'5cs'29'29 >>= withAttribute "Word") >>~ (popContext))+                        <|>+                        ((pRegExpr regex_'5cS >>= withAttribute "Word")))+     return (attr, result)++parseRules "ML_TagWordWord" = +  do (attr, result) <- (((lookAhead (pDetect2Chars False '*' '/') >> return ([],"") ) >>~ (popContext))+                        <|>+                        ((pDetectSpaces >>= withAttribute "Comment"))+                        <|>+                        ((pRegExpr regex_'5cS'28'3f'3d'28'5b'5d'5b'2c'3f'3b'28'29'5d'7c'5c'2e'24'7c'5c'2e'3f'5cs'29'29 >>= withAttribute "Word") >>~ pushContext "ML_Tag2ndWord")+                        <|>+                        ((pRegExpr regex_'5cS >>= withAttribute "Word")))+     return (attr, result)++parseRules "ML_Tag2ndWord" = +  do (attr, result) <- (((lookAhead (pDetect2Chars False '*' '/') >> return ([],"") ) >>~ (popContext >> popContext))+                        <|>+                        ((parseRules "SL_Tag2ndWord")))+     return (attr, result)++parseRules "ML_TagString" = +  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Comment"))+                        <|>+                        ((lookAhead (pDetect2Chars False '*' '/') >> return ([],"") ) >>~ (popContext))+                        <|>+                        ((pString False "<!--" >>= withAttribute "HTML Comment") >>~ pushContext "ML_htmlcomment")+                        <|>+                        ((pDetect2Chars False '<' '<' >>= withAttribute "Comment"))+                        <|>+                        ((pRegExpr regex_'3c'5cs'2a'5c'2f'3f'5cs'2a'5ba'2dzA'2dZ'5f'3a'5d'5ba'2dzA'2dZ0'2d9'2e'5f'3a'2d'5d'2a >>= withAttribute "HTML Tag") >>~ pushContext "ML_htmltag")+                        <|>+                        ((pRegExpr regex_'2e >>= withAttribute "Description")))+     return (attr, result)++parseRules "ML_TagWordString" = +  do (attr, result) <- (((lookAhead (pDetect2Chars False '*' '/') >> return ([],"") ) >>~ (popContext))+                        <|>+                        ((parseRules "SL_TagWordString")))+     return (attr, result)++parseRules "ML_htmltag" = +  do (attr, result) <- (((lookAhead (pDetect2Chars False '*' '/') >> return ([],"") ) >>~ (popContext))+                        <|>+                        ((pDetect2Chars False '/' '>' >>= withAttribute "HTML Tag") >>~ (popContext))+                        <|>+                        ((pDetectChar False '>' >>= withAttribute "HTML Tag") >>~ (popContext))+                        <|>+                        ((pRegExpr regex_'5cs'2a'3d'5cs'2a >>= withAttribute "Identifier") >>~ pushContext "ML_identifiers"))+     return (attr, result)++parseRules "ML_htmlcomment" = +  do (attr, result) <- (((lookAhead (pDetect2Chars False '*' '/') >> return ([],"") ) >>~ (popContext))+                        <|>+                        ((Text.Highlighting.Kate.Syntax.Alert.parseExpression))+                        <|>+                        ((pString False "-->" >>= withAttribute "HTML Comment") >>~ (popContext)))+     return (attr, result)++parseRules "ML_identifiers" = +  do (attr, result) <- (((lookAhead (pDetect2Chars False '*' '/') >> return ([],"") ) >>~ (popContext))+                        <|>+                        ((pRegExpr regex_'5cs'2a'23'3f'5ba'2dzA'2dZ0'2d9'5d'2a >>= withAttribute "String") >>~ (popContext))+                        <|>+                        ((pDetectChar False '\'' >>= withAttribute "Types") >>~ pushContext "ML_types1")+                        <|>+                        ((pDetectChar False '"' >>= withAttribute "Types") >>~ pushContext "ML_types2"))+     return (attr, result)++parseRules "ML_types1" = +  do (attr, result) <- (((lookAhead (pDetect2Chars False '*' '/') >> return ([],"") ) >>~ (popContext))+                        <|>+                        ((pDetectChar False '\'' >>= withAttribute "Types") >>~ (popContext >> popContext)))+     return (attr, result)++parseRules "ML_types2" = +  do (attr, result) <- (((lookAhead (pDetect2Chars False '*' '/') >> return ([],"") ) >>~ (popContext))+                        <|>+                        ((pDetectChar False '"' >>= withAttribute "Types") >>~ (popContext >> popContext)))+     return (attr, result)++parseRules "SL_TagWord" = +  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Comment"))+                        <|>+                        ((lookAhead (pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}" list_TagWord) >> return ([],"") ) >>~ (popContext))+                        <|>+                        ((pRegExpr regex_'5cS'28'3f'3d'28'5b'5d'5b'2c'3f'3b'28'29'5d'7c'5c'2e'24'7c'5c'2e'3f'5cs'29'29 >>= withAttribute "Word") >>~ (popContext))+                        <|>+                        ((pRegExpr regex_'5cS >>= withAttribute "Word")))+     return (attr, result)++parseRules "SL_TagParam" = +  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Comment"))+                        <|>+                        ((pString False "[in]" >>= withAttribute "Tags") >>~ pushContext "SL_Tag2ndWord")+                        <|>+                        ((pString False "[out]" >>= withAttribute "Tags") >>~ pushContext "SL_Tag2ndWord")+                        <|>+                        ((pString False "[in,out]" >>= withAttribute "Tags") >>~ pushContext "SL_Tag2ndWord")+                        <|>+                        ((pRegExpr regex_'5cS'28'3f'3d'28'5b'5d'5b'2c'3f'3b'28'29'5d'7c'5c'2e'24'7c'5c'2e'3f'5cs'29'29 >>= withAttribute "Word") >>~ (popContext))+                        <|>+                        ((pRegExpr regex_'5cS >>= withAttribute "Word")))+     return (attr, result)++parseRules "SL_TagWordWord" = +  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Comment"))+                        <|>+                        ((pRegExpr regex_'5cS'28'3f'3d'28'5b'5d'5b'2c'3f'3b'28'29'5d'7c'5c'2e'24'7c'5c'2e'3f'5cs'29'29 >>= withAttribute "Word") >>~ pushContext "SL_Tag2ndWord")+                        <|>+                        ((pRegExpr regex_'5cS >>= withAttribute "Word")))+     return (attr, result)++parseRules "SL_Tag2ndWord" = +  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Comment"))+                        <|>+                        ((pRegExpr regex_'5cS'28'3f'3d'28'5b'5d'5b'2c'3f'3b'28'29'5d'7c'5c'2e'24'7c'5c'2e'3f'5cs'29'29 >>= withAttribute "Word") >>~ (popContext >> popContext))+                        <|>+                        ((pRegExpr regex_'5cS >>= withAttribute "Word")))+     return (attr, result)++parseRules "SL_TagString" = +  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Comment"))+                        <|>+                        ((pString False "<!--" >>= withAttribute "HTML Comment") >>~ pushContext "SL_htmlcomment")+                        <|>+                        ((pDetect2Chars False '<' '<' >>= withAttribute "Comment"))+                        <|>+                        ((pRegExpr regex_'3c'5cs'2a'5c'2f'3f'5cs'2a'5ba'2dzA'2dZ'5f'3a'5d'5ba'2dzA'2dZ0'2d9'2e'5f'3a'2d'5d'2a >>= withAttribute "HTML Tag") >>~ pushContext "SL_htmltag")+                        <|>+                        ((pRegExpr regex_'2e >>= withAttribute "Description")))+     return (attr, result)++parseRules "SL_TagWordString" = +  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Comment"))+                        <|>+                        ((pRegExpr regex_'5cS'28'3f'3d'28'5b'5d'5b'2c'3f'3b'28'29'5d'7c'5c'2e'24'7c'5c'2e'3f'5cs'29'29 >>= withAttribute "Word") >>~ (popContext))+                        <|>+                        ((pRegExpr regex_'5cS >>= withAttribute "Word")))+     return (attr, result)++parseRules "SL_htmltag" = +  do (attr, result) <- (((pDetect2Chars False '/' '>' >>= withAttribute "HTML Tag") >>~ (popContext))+                        <|>+                        ((pDetectChar False '>' >>= withAttribute "HTML Tag") >>~ (popContext))+                        <|>+                        ((pRegExpr regex_'5cs'2a'3d'5cs'2a >>= withAttribute "Identifier") >>~ pushContext "SL_identifiers"))+     return (attr, result)++parseRules "SL_htmlcomment" = +  do (attr, result) <- (((Text.Highlighting.Kate.Syntax.Alert.parseExpression))+                        <|>+                        ((pString False "-->" >>= withAttribute "HTML Comment") >>~ (popContext)))+     return (attr, result)++parseRules "SL_identifiers" = +  do (attr, result) <- (((pRegExpr regex_'5cs'2a'23'3f'5ba'2dzA'2dZ0'2d9'5d'2a >>= withAttribute "String") >>~ (popContext))+                        <|>+                        ((pDetectChar False '\'' >>= withAttribute "Types") >>~ pushContext "SL_types1")+                        <|>+                        ((pDetectChar False '"' >>= withAttribute "Types") >>~ pushContext "SL_types2"))+     return (attr, result)++parseRules "SL_types1" = +  do (attr, result) <- ((pDetectChar False '\'' >>= withAttribute "Types") >>~ (popContext >> popContext))+     return (attr, result)++parseRules "SL_types2" = +  do (attr, result) <- ((pDetectChar False '"' >>= withAttribute "Types") >>~ (popContext >> popContext))+     return (attr, result)++parseRules x = fail $ "Unknown context" ++ x

@@ -48,18 +48,16 @@ parseSourceLine = manyTill parseExpressionInternal pEndLine  pEndLine = do-  newline <|> (eof >> return '\n')+  lookAhead $ newline <|> (eof >> return '\n')   context <- currentContext   case context of-    "Normal" -> return ()-    "Comment" -> return ()-    "PI" -> return ()-    "Declaration" -> return ()-    "String" -> return ()-    "InlineComment" -> (popContext >> return ())-    _ -> return ()-  lineContents <- lookAhead wholeLine-  updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }+    "Normal" -> return () >> pHandleEndLine+    "Comment" -> return () >> pHandleEndLine+    "PI" -> return () >> pHandleEndLine+    "Declaration" -> return () >> pHandleEndLine+    "String" -> return () >> pHandleEndLine+    "InlineComment" -> (popContext) >> pEndLine+    _ -> pHandleEndLine  withAttribute attr txt = do   when (null txt) $ fail "Parser matched no text"@@ -85,7 +83,7 @@ regex_'5cb'5b'5c'2d'5cw'5cd'5c'2e'3a'5f'5d'2b'5cb = compileRegex "\\b[\\-\\w\\d\\.:_]+\\b" regex_'25'5b'5c'2d'5cw'5cd'5c'2e'3a'5f'5d'2b'3b = compileRegex "%[\\-\\w\\d\\.:_]+;" -defaultAttributes = [("Normal","Normal"),("Comment","Comment"),("PI","Normal"),("Declaration","Normal"),("String","String"),("InlineComment","Comment")]+defaultAttributes = [("Normal","Normal"),("Comment","Comment"),("PI","Other"),("Declaration","Other"),("String","String"),("InlineComment","Comment")]  parseRules "Normal" =    do (attr, result) <- (((pDetectSpaces >>= withAttribute "Normal"))@@ -108,7 +106,7 @@ parseRules "Comment" =    do (attr, result) <- (((pDetectSpaces >>= withAttribute "Comment"))                         <|>-                        ((pString False "-->" >>= withAttribute "Comment") >>~ (popContext >> return ()))+                        ((pString False "-->" >>= withAttribute "Comment") >>~ (popContext))                         <|>                         ((Text.Highlighting.Kate.Syntax.Alert.parseExpression))                         <|>@@ -116,7 +114,7 @@      return (attr, result)  parseRules "PI" = -  do (attr, result) <- ((pDetect2Chars False '?' '>' >>= withAttribute "Processing Instruction") >>~ (popContext >> return ()))+  do (attr, result) <- ((pDetect2Chars False '?' '>' >>= withAttribute "Processing Instruction") >>~ (popContext))      return (attr, result)  parseRules "Declaration" = @@ -124,7 +122,7 @@                         <|>                         ((pDetect2Chars False '-' '-' >>= withAttribute "Comment") >>~ pushContext "InlineComment")                         <|>-                        ((pDetectChar False '>' >>= withAttribute "Declaration") >>~ (popContext >> return ()))+                        ((pDetectChar False '>' >>= withAttribute "Declaration") >>~ (popContext))                         <|>                         ((pDetectChar False '"' >>= withAttribute "String") >>~ pushContext "String")                         <|>@@ -148,7 +146,7 @@ parseRules "String" =    do (attr, result) <- (((pDetectSpaces >>= withAttribute "String"))                         <|>-                        ((pDetectChar False '"' >>= withAttribute "String") >>~ (popContext >> return ()))+                        ((pDetectChar False '"' >>= withAttribute "String") >>~ (popContext))                         <|>                         ((pRegExpr regex_'25'5b'5c'2d'5cw'5cd'5c'2e'3a'5f'5d'2b'3b >>= withAttribute "Entity")))      return (attr, result)@@ -156,7 +154,7 @@ parseRules "InlineComment" =    do (attr, result) <- (((pDetectSpaces >>= withAttribute "Comment"))                         <|>-                        ((pDetect2Chars False '-' '-' >>= withAttribute "Comment") >>~ (popContext >> return ()))+                        ((pDetect2Chars False '-' '-' >>= withAttribute "Comment") >>~ (popContext))                         <|>                         ((Text.Highlighting.Kate.Syntax.Alert.parseExpression))                         <|>

@@ -47,15 +47,13 @@ parseSourceLine = manyTill parseExpressionInternal pEndLine  pEndLine = do-  newline <|> (eof >> return '\n')+  lookAhead $ newline <|> (eof >> return '\n')   context <- currentContext   case context of-    "Normal" -> return ()-    "Quoted String" -> (popContext >> return ())-    "Documentation" -> (popContext >> return ())-    _ -> return ()-  lineContents <- lookAhead wholeLine-  updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }+    "Normal" -> return () >> pHandleEndLine+    "Quoted String" -> (popContext) >> pEndLine+    "Documentation" -> (popContext) >> pEndLine+    _ -> pHandleEndLine  withAttribute attr txt = do   when (null txt) $ fail "Parser matched no text"@@ -98,7 +96,7 @@      return (attr, result)  parseRules "Quoted String" = -  do (attr, result) <- ((pDetectChar False '"' >>= withAttribute "String") >>~ (popContext >> return ()))+  do (attr, result) <- ((pDetectChar False '"' >>= withAttribute "String") >>~ (popContext))      return (attr, result)  parseRules "Documentation" = 

@@ -0,0 +1,248 @@+{- This module was generated from data in the Kate syntax highlighting file email.xml, version 1.00,+   by  Carl A Joslin (carl.joslin@joslin.dyndns.org) -}++module Text.Highlighting.Kate.Syntax.Email ( 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)++-- | Full name of language.+syntaxName :: String+syntaxName = "Email"++-- | Filename extensions for this language.+syntaxExtensions :: String+syntaxExtensions = "*.eml"++-- | 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 = "Email" }+  context <- currentContext <|> (pushContext "headder" >> 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 [("Email",["headder"])], synStLanguage = "Email", synStCurrentLine = "", synStCharsParsedInLine = 0, synStPrevChar = '\n', synStCaseSensitive = False, synStKeywordCaseSensitive = False, synStCaptures = []}++parseSourceLine = manyTill parseExpressionInternal pEndLine++pEndLine = do+  lookAhead $ newline <|> (eof >> return '\n')+  context <- currentContext+  case context of+    "headder" -> return () >> pHandleEndLine+    _ -> pHandleEndLine++withAttribute attr txt = do+  when (null txt) $ fail "Parser matched no text"+  let labs = attr : maybeToList (lookup attr styles)+  st <- getState+  let oldCharsParsed = synStCharsParsedInLine st+  let prevchar = if null txt then '\n' else last txt+  updateState $ \st -> st { synStCharsParsedInLine = oldCharsParsed + length txt, synStPrevChar = prevchar } +  return (labs, txt)++styles = [("rfc-main","al"),("string","st"),("base64","re"),("marker","al"),("sign","co")]++parseExpressionInternal = do+  context <- currentContext+  parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes))+++regex_'5bTt'5do'3a'2e'2a'24 = compileRegex "[Tt]o:.*$"+regex_'5bFf'5drom'3a'2e'2a'24 = compileRegex "[Ff]rom:.*$"+regex_'5bCc'5d'5bCc'5d'3a'2e'2a'24 = compileRegex "[Cc][Cc]:.*$"+regex_'5bBb'5d'5bCc'5d'5bCc'5d'3a'2e'2a'24 = compileRegex "[Bb][Cc][Cc]:.*$"+regex_'5bSs'5dubject'3a'2e'2a'24 = compileRegex "[Ss]ubject:.*$"+regex_'5bDd'5date'3a'2e'2a'24 = compileRegex "[Dd]ate:.*$"+regex_'5bSs'5dender'3a = compileRegex "[Ss]ender:"+regex_'5bRr'5deply'2d'5bTt'5do'3a = compileRegex "[Rr]eply-[Tt]o:"+regex_'5bMm'5dessage'2d'5bIi'5d'5bDd'5d'3a = compileRegex "[Mm]essage-[Ii][Dd]:"+regex_'5bIi'5dn'2d'5bRr'5deply'2d'5bTt'5do'3a = compileRegex "[Ii]n-[Rr]eply-[Tt]o:"+regex_'5bRr'5deferences'3a = compileRegex "[Rr]eferences:"+regex_'5bCc'5domments'3a = compileRegex "[Cc]omments:"+regex_'5bKk'5deywors'3a = compileRegex "[Kk]eywors:"+regex_'5bRr'5desent'2d'5bDd'5date'3a = compileRegex "[Rr]esent-[Dd]ate:"+regex_'5bRr'5desent'2d'5bFf'5drom'3a = compileRegex "[Rr]esent-[Ff]rom:"+regex_'5bRr'5desent'2d'5bSs'5dender'3a = compileRegex "[Rr]esent-[Ss]ender:"+regex_'5bRr'5desent'2d'5bTt'5do'3a = compileRegex "[Rr]esent-[Tt]o:"+regex_'5bRr'5desent'2d'5bCc'5d'5bCc'5d'3a = compileRegex "[Rr]esent-[Cc][Cc]:"+regex_'5bRr'5desent'2d'5bBb'5d'5bCc'5d'5bCc'5d'3a = compileRegex "[Rr]esent-[Bb][Cc][Cc]:"+regex_'5bRr'5desent'2d'5bMm'5dessage'2d'5bIi'5d'5bDd'5d'3a = compileRegex "[Rr]esent-[Mm]essage-[Ii][Dd]:"+regex_'5bRr'5desent'2d'5bRr'5deply'2d'5bTt'5do'3a = compileRegex "[Rr]esent-[Rr]eply-[Tt]o:"+regex_'5bRr'5deturn'2d'5bPp'5dath'3a = compileRegex "[Rr]eturn-[Pp]ath:"+regex_'5bRr'5deceived'3a = compileRegex "[Rr]eceived:"+regex_'5bXx'5d'2d'5bMm'5dozilla'2d'5bSs'5dtatus'3a = compileRegex "[Xx]-[Mm]ozilla-[Ss]tatus:"+regex_'5bXx'5d'2d'5bMm'5dozilla'2d'5bSs'5dtatus2'3a = compileRegex "[Xx]-[Mm]ozilla-[Ss]tatus2:"+regex_'5bEe'5dnverlope'2d'5bTt'5do'3a = compileRegex "[Ee]nverlope-[Tt]o:"+regex_'5bDd'5delivery'2d'5bDd'5date'3a = compileRegex "[Dd]elivery-[Dd]ate:"+regex_'5bXx'5d'2d'5bOo'5driginating'2d'5bIi'5d'5bPp'5d'3a = compileRegex "[Xx]-[Oo]riginating-[Ii][Pp]:"+regex_'5bXx'5d'2d'5bOo'5driginating'2d'5bEe'5dmail'3a = compileRegex "[Xx]-[Oo]riginating-[Ee]mail:"+regex_'5bXx'5d'2d'5bSs'5dender'3a = compileRegex "[Xx]-[Ss]ender:"+regex_'5bMm'5dime'2d'5bVv'5dersion'3a = compileRegex "[Mm]ime-[Vv]ersion:"+regex_'5bCc'5dontent'2d'5bTt'5dype'3a = compileRegex "[Cc]ontent-[Tt]ype:"+regex_'5bXx'5d'2d'5bMm'5dailing'2d'5bLl'5dist'3a = compileRegex "[Xx]-[Mm]ailing-[Ll]ist:"+regex_'5bXx'5d'2d'5bLl'5doop'3a = compileRegex "[Xx]-[Ll]oop:"+regex_'5bLl'5dist'2d'5bPp'5dost'3a = compileRegex "[Ll]ist-[Pp]ost:"+regex_'5bLl'5dist'2d'5bHh'5delp'3a = compileRegex "[Ll]ist-[Hh]elp:"+regex_'5bLl'5dist'2d'5bUu'5dnsubscribe'3a = compileRegex "[Ll]ist-[Uu]nsubscribe:"+regex_'5bPp'5drecedence'3a = compileRegex "[Pp]recedence:"+regex_'5bCc'5dontent'2d'5bTt'5dransfer'2d'5bEe'5dncoding'3a = compileRegex "[Cc]ontent-[Tt]ransfer-[Ee]ncoding:"+regex_'5bXx'5d'2d'5bBb'5dulkmail'3a = compileRegex "[Xx]-[Bb]ulkmail:"+regex_'5bCc'5dontent'2d'5bDd'5disposition'3a = compileRegex "[Cc]ontent-[Dd]isposition:"+regex_'5b0'2d9a'2dzA'2dZ'2d'2e'5d'2b'3a = compileRegex "[0-9a-zA-Z-.]+:"+regex_'5ba'2dzA'2dZ0'2d9'2e'5c'2d'5d'2b'5c'40'5ba'2dzA'2dZ0'2d9'2e'5c'2d'5d'2b = compileRegex "[a-zA-Z0-9.\\-]+\\@[a-zA-Z0-9.\\-]+"+regex_'5ba'2dzA'2dZ0'2d9'2e'5c'2d'5d'2a'5cs'2a'3c'5ba'2dzA'2dZ0'2d9'2e'5c'2d'5d'2b'5c'40'5ba'2dzA'2dZ0'2d9'2e'5c'2d'5d'2b'3e = compileRegex "[a-zA-Z0-9.\\-]*\\s*<[a-zA-Z0-9.\\-]+\\@[a-zA-Z0-9.\\-]+>"+regex_'22'5ba'2dzA'2dZ0'2d9'2e_'5c'2d'5d'2b'22'5cs'2a'3c'5ba'2dzA'2dZ0'2d9'2e'5c'2d'5d'2b'5c'40'5ba'2dzA'2dZ0'2d9'2e'5c'2d'5d'2b'3e = compileRegex "\"[a-zA-Z0-9. \\-]+\"\\s*<[a-zA-Z0-9.\\-]+\\@[a-zA-Z0-9.\\-]+>"+regex_'22'2e'2a'22 = compileRegex "\".*\""+regex_'27'2e'2a'27 = compileRegex "'.*'"+regex_'5b'7c'3e'5d'5cs'2a'5b'7c'3e'5d'5cs'2a'5b'7c'3e'5d'5cs'2a'5b'7c'3e'5d'5cs'2a'5b'7c'3e'5d'5cs'2a'5b'7c'3e'5d'2e'2a = compileRegex "[|>]\\s*[|>]\\s*[|>]\\s*[|>]\\s*[|>]\\s*[|>].*"+regex_'5b'7c'3e'5d'5cs'2a'5b'7c'3e'5d'5cs'2a'5b'7c'3e'5d'5cs'2a'5b'7c'3e'5d'5cs'2a'5b'7c'3e'5d'2e'2a = compileRegex "[|>]\\s*[|>]\\s*[|>]\\s*[|>]\\s*[|>].*"+regex_'5b'7c'3e'5d'5cs'2a'5b'7c'3e'5d'5cs'2a'5b'7c'3e'5d'5cs'2a'5b'7c'3e'5d'2e'2a = compileRegex "[|>]\\s*[|>]\\s*[|>]\\s*[|>].*"+regex_'5b'7c'3e'5d'5cs'2a'5b'7c'3e'5d'5cs'2a'5b'7c'3e'5d'2e'2a = compileRegex "[|>]\\s*[|>]\\s*[|>].*"+regex_'5b'7c'3e'5d'5cs'2a'5b'7c'3e'5d'2e'2a = compileRegex "[|>]\\s*[|>].*"+regex_'5b'7c'3e'5d'2e'2a = compileRegex "[|>].*"+regex_'28'5bA'2dZa'2dz0'2d9'2b'2f'5d'5bA'2dZa'2dz0'2d9'2b'2f'5d'5bA'2dZa'2dz0'2d9'2b'2f'5d'5bA'2dZa'2dz0'2d9'2b'2f'5d'29'7b10'2c20'7d'24 = compileRegex "([A-Za-z0-9+/][A-Za-z0-9+/][A-Za-z0-9+/][A-Za-z0-9+/]){10,20}$"+regex_'5bA'2dZa'2dz0'2d9'2b'3d'2f'5d'2b'3d'24 = compileRegex "[A-Za-z0-9+=/]+=$"+regex_'28'2d_'29'3f'2d'2d'28'2d'2d'2e'2a'29'3f = compileRegex "(- )?--(--.*)?"++defaultAttributes = [("headder","Normal Text")]++parseRules "headder" = +  do (attr, result) <- (((pColumn 0 >> pRegExpr regex_'5bTt'5do'3a'2e'2a'24 >>= withAttribute "rfc-main"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bFf'5drom'3a'2e'2a'24 >>= withAttribute "rfc-main"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bCc'5d'5bCc'5d'3a'2e'2a'24 >>= withAttribute "rfc-main"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bBb'5d'5bCc'5d'5bCc'5d'3a'2e'2a'24 >>= withAttribute "rfc-main"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bSs'5dubject'3a'2e'2a'24 >>= withAttribute "rfc-main"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bDd'5date'3a'2e'2a'24 >>= withAttribute "rfc-main"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bSs'5dender'3a >>= withAttribute "rfc"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bRr'5deply'2d'5bTt'5do'3a >>= withAttribute "rfc"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bMm'5dessage'2d'5bIi'5d'5bDd'5d'3a >>= withAttribute "rfc"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bIi'5dn'2d'5bRr'5deply'2d'5bTt'5do'3a >>= withAttribute "rfc"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bRr'5deferences'3a >>= withAttribute "rfc"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bCc'5domments'3a >>= withAttribute "rfc"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bKk'5deywors'3a >>= withAttribute "rfc"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bRr'5desent'2d'5bDd'5date'3a >>= withAttribute "rfc"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bRr'5desent'2d'5bFf'5drom'3a >>= withAttribute "rfc"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bRr'5desent'2d'5bSs'5dender'3a >>= withAttribute "rfc"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bRr'5desent'2d'5bTt'5do'3a >>= withAttribute "rfc"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bRr'5desent'2d'5bCc'5d'5bCc'5d'3a >>= withAttribute "rfc"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bRr'5desent'2d'5bBb'5d'5bCc'5d'5bCc'5d'3a >>= withAttribute "rfc"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bRr'5desent'2d'5bMm'5dessage'2d'5bIi'5d'5bDd'5d'3a >>= withAttribute "rfc"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bRr'5desent'2d'5bRr'5deply'2d'5bTt'5do'3a >>= withAttribute "rfc"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bRr'5deturn'2d'5bPp'5dath'3a >>= withAttribute "rfc"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bRr'5deceived'3a >>= withAttribute "rfc"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bXx'5d'2d'5bMm'5dozilla'2d'5bSs'5dtatus'3a >>= withAttribute "common"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bXx'5d'2d'5bMm'5dozilla'2d'5bSs'5dtatus2'3a >>= withAttribute "common"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bEe'5dnverlope'2d'5bTt'5do'3a >>= withAttribute "common"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bDd'5delivery'2d'5bDd'5date'3a >>= withAttribute "common"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bXx'5d'2d'5bOo'5driginating'2d'5bIi'5d'5bPp'5d'3a >>= withAttribute "common"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bXx'5d'2d'5bOo'5driginating'2d'5bEe'5dmail'3a >>= withAttribute "common"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bXx'5d'2d'5bSs'5dender'3a >>= withAttribute "common"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bMm'5dime'2d'5bVv'5dersion'3a >>= withAttribute "common"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bCc'5dontent'2d'5bTt'5dype'3a >>= withAttribute "common"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bXx'5d'2d'5bMm'5dailing'2d'5bLl'5dist'3a >>= withAttribute "common"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bXx'5d'2d'5bLl'5doop'3a >>= withAttribute "common"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bLl'5dist'2d'5bPp'5dost'3a >>= withAttribute "common"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bLl'5dist'2d'5bHh'5delp'3a >>= withAttribute "common"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bLl'5dist'2d'5bUu'5dnsubscribe'3a >>= withAttribute "common"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bPp'5drecedence'3a >>= withAttribute "common"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bCc'5dontent'2d'5bTt'5dransfer'2d'5bEe'5dncoding'3a >>= withAttribute "common"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bCc'5dontent'2d'5bTt'5dype'3a >>= withAttribute "common"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bXx'5d'2d'5bBb'5dulkmail'3a >>= withAttribute "common"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bPp'5drecedence'3a >>= withAttribute "common"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bCc'5dontent'2d'5bDd'5disposition'3a >>= withAttribute "common"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5b0'2d9a'2dzA'2dZ'2d'2e'5d'2b'3a >>= withAttribute "other"))+                        <|>+                        ((pRegExpr regex_'5ba'2dzA'2dZ0'2d9'2e'5c'2d'5d'2b'5c'40'5ba'2dzA'2dZ0'2d9'2e'5c'2d'5d'2b >>= withAttribute "email"))+                        <|>+                        ((pRegExpr regex_'5ba'2dzA'2dZ0'2d9'2e'5c'2d'5d'2a'5cs'2a'3c'5ba'2dzA'2dZ0'2d9'2e'5c'2d'5d'2b'5c'40'5ba'2dzA'2dZ0'2d9'2e'5c'2d'5d'2b'3e >>= withAttribute "email"))+                        <|>+                        ((pRegExpr regex_'22'5ba'2dzA'2dZ0'2d9'2e_'5c'2d'5d'2b'22'5cs'2a'3c'5ba'2dzA'2dZ0'2d9'2e'5c'2d'5d'2b'5c'40'5ba'2dzA'2dZ0'2d9'2e'5c'2d'5d'2b'3e >>= withAttribute "email"))+                        <|>+                        ((pRegExpr regex_'22'2e'2a'22 >>= withAttribute "string"))+                        <|>+                        ((pRegExpr regex_'27'2e'2a'27 >>= withAttribute "string"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5b'7c'3e'5d'5cs'2a'5b'7c'3e'5d'5cs'2a'5b'7c'3e'5d'5cs'2a'5b'7c'3e'5d'5cs'2a'5b'7c'3e'5d'5cs'2a'5b'7c'3e'5d'2e'2a >>= withAttribute "indent6"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5b'7c'3e'5d'5cs'2a'5b'7c'3e'5d'5cs'2a'5b'7c'3e'5d'5cs'2a'5b'7c'3e'5d'5cs'2a'5b'7c'3e'5d'2e'2a >>= withAttribute "indent5"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5b'7c'3e'5d'5cs'2a'5b'7c'3e'5d'5cs'2a'5b'7c'3e'5d'5cs'2a'5b'7c'3e'5d'2e'2a >>= withAttribute "indent4"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5b'7c'3e'5d'5cs'2a'5b'7c'3e'5d'5cs'2a'5b'7c'3e'5d'2e'2a >>= withAttribute "indent3"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5b'7c'3e'5d'5cs'2a'5b'7c'3e'5d'2e'2a >>= withAttribute "indent2"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5b'7c'3e'5d'2e'2a >>= withAttribute "indent1"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'28'5bA'2dZa'2dz0'2d9'2b'2f'5d'5bA'2dZa'2dz0'2d9'2b'2f'5d'5bA'2dZa'2dz0'2d9'2b'2f'5d'5bA'2dZa'2dz0'2d9'2b'2f'5d'29'7b10'2c20'7d'24 >>= withAttribute "base64"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'5bA'2dZa'2dz0'2d9'2b'3d'2f'5d'2b'3d'24 >>= withAttribute "base64"))+                        <|>+                        ((pColumn 0 >> pRegExpr regex_'28'2d_'29'3f'2d'2d'28'2d'2d'2e'2a'29'3f >>= withAttribute "marker")))+     return (attr, result)++parseRules x = fail $ "Unknown context" ++ x

@@ -48,17 +48,15 @@ parseSourceLine = manyTill parseExpressionInternal pEndLine  pEndLine = do-  newline <|> (eof >> return '\n')+  lookAhead $ newline <|> (eof >> return '\n')   context <- currentContext   case context of-    "Normal Text" -> (popContext >> return ())-    "isfunction" -> (popContext >> return ())-    "atomquote" -> (popContext >> return ())-    "stringquote" -> (popContext >> return ())-    "comment" -> (popContext >> return ())-    _ -> return ()-  lineContents <- lookAhead wholeLine-  updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }+    "Normal Text" -> (popContext) >> pEndLine+    "isfunction" -> (popContext) >> pEndLine+    "atomquote" -> (popContext) >> pEndLine+    "stringquote" -> (popContext) >> pEndLine+    "comment" -> (popContext) >> pEndLine+    _ -> pHandleEndLine  withAttribute attr txt = do   when (null txt) $ fail "Parser matched no text"@@ -112,37 +110,37 @@                         <|>                         ((pDetectChar False '%' >>= withAttribute "Comment") >>~ pushContext "comment")                         <|>-                        ((pRegExpr regex_'5cb'5ba'2dz'5d'5b'5fa'2dz'40'2dZ0'2d9'5d'2a'28'3f'3a'28'3f'3d'5b'5e'5fa'2dz'40'2dZ0'2d9'5d'29'7c'24'29'3a'5cb'5ba'2dz'5d'5b'5fa'2dz'40'2dZ0'2d9'5d'2a'28'3f'3a'28'3f'3d'5b'5e'5fa'2dz'40'2dZ0'2d9'5d'29'7c'24'29 >>= withAttribute "Function") >>~ (popContext >> return ()))+                        ((pRegExpr regex_'5cb'5ba'2dz'5d'5b'5fa'2dz'40'2dZ0'2d9'5d'2a'28'3f'3a'28'3f'3d'5b'5e'5fa'2dz'40'2dZ0'2d9'5d'29'7c'24'29'3a'5cb'5ba'2dz'5d'5b'5fa'2dz'40'2dZ0'2d9'5d'2a'28'3f'3a'28'3f'3d'5b'5e'5fa'2dz'40'2dZ0'2d9'5d'29'7c'24'29 >>= withAttribute "Function") >>~ (popContext))                         <|>                         ((lookAhead (pRegExpr regex_'5cb'5ba'2dz'5d'5b'5fa'2dz'40'2dZ0'2d9'5d'2a'28'3f'3a'28'3f'3d'5b'5e'5fa'2dz'40'2dZ0'2d9'5d'29'7c'24'29'5c'28) >> return ([],"") ) >>~ pushContext "isfunction")                         <|>-                        ((pRegExpr regex_'5cb'5b'5fA'2dZ'5d'5b'5fa'2dz'40'2dZ0'2d9'5d'2a'28'3f'3a'28'3f'3d'5b'5e'5fa'2dz'40'2dZ0'2d9'5d'29'7c'24'29 >>= withAttribute "Variable") >>~ (popContext >> return ()))+                        ((pRegExpr regex_'5cb'5b'5fA'2dZ'5d'5b'5fa'2dz'40'2dZ0'2d9'5d'2a'28'3f'3a'28'3f'3d'5b'5e'5fa'2dz'40'2dZ0'2d9'5d'29'7c'24'29 >>= withAttribute "Variable") >>~ (popContext))                         <|>                         ((pDetectChar False '\'' >>= withAttribute "Atom") >>~ pushContext "atomquote")                         <|>-                        ((pRegExpr regex_'5cb'5ba'2dz'5d'5b'5fa'2dz'40'2dZ0'2d9'5d'2a'28'3f'3a'28'3f'3d'5b'5e'5fa'2dz'40'2dZ0'2d9'5d'29'7c'24'29 >>= withAttribute "Atom") >>~ (popContext >> return ()))+                        ((pRegExpr regex_'5cb'5ba'2dz'5d'5b'5fa'2dz'40'2dZ0'2d9'5d'2a'28'3f'3a'28'3f'3d'5b'5e'5fa'2dz'40'2dZ0'2d9'5d'29'7c'24'29 >>= withAttribute "Atom") >>~ (popContext))                         <|>                         ((pDetectChar False '"' >>= withAttribute "String") >>~ pushContext "stringquote")                         <|>-                        ((pRegExpr regex_'5b0'2d9'5d'2b'5c'2e'5b0'2d9'5d'2b'28'3f'3a'5beE'5d'5b'2b'2d'5d'3f'5b0'2d9'5d'2b'29'3f >>= withAttribute "Float") >>~ (popContext >> return ()))+                        ((pRegExpr regex_'5b0'2d9'5d'2b'5c'2e'5b0'2d9'5d'2b'28'3f'3a'5beE'5d'5b'2b'2d'5d'3f'5b0'2d9'5d'2b'29'3f >>= withAttribute "Float") >>~ (popContext))                         <|>-                        ((pRegExpr regex_'5cd'2b'23'5ba'2dzA'2dZ0'2d9'5d'2b >>= withAttribute "Number") >>~ (popContext >> return ()))+                        ((pRegExpr regex_'5cd'2b'23'5ba'2dzA'2dZ0'2d9'5d'2b >>= withAttribute "Number") >>~ (popContext))                         <|>-                        ((pRegExpr regex_'5c'24'5cS >>= withAttribute "Integer") >>~ (popContext >> return ()))+                        ((pRegExpr regex_'5c'24'5cS >>= withAttribute "Integer") >>~ (popContext))                         <|>-                        ((pRegExpr regex_'5b0'2d9'5d'2b >>= withAttribute "Integer") >>~ (popContext >> return ())))+                        ((pRegExpr regex_'5b0'2d9'5d'2b >>= withAttribute "Integer") >>~ (popContext)))      return (attr, result)  parseRules "isfunction" = -  do (attr, result) <- ((pRegExpr regex_'5cb'5ba'2dz'5d'5b'5fa'2dz'40'2dZ0'2d9'5d'2a'28'3f'3a'28'3f'3d'5b'5e'5fa'2dz'40'2dZ0'2d9'5d'29'7c'24'29 >>= withAttribute "Function") >>~ (popContext >> return ()))+  do (attr, result) <- ((pRegExpr regex_'5cb'5ba'2dz'5d'5b'5fa'2dz'40'2dZ0'2d9'5d'2a'28'3f'3a'28'3f'3d'5b'5e'5fa'2dz'40'2dZ0'2d9'5d'29'7c'24'29 >>= withAttribute "Function") >>~ (popContext))      return (attr, result)  parseRules "atomquote" = -  do (attr, result) <- ((pRegExpr regex_'28'3f'3a'28'3f'3a'5c'5c'27'29'3f'5b'5e'27'5d'2a'29'2a'27 >>= withAttribute "Atom") >>~ (popContext >> return ()))+  do (attr, result) <- ((pRegExpr regex_'28'3f'3a'28'3f'3a'5c'5c'27'29'3f'5b'5e'27'5d'2a'29'2a'27 >>= withAttribute "Atom") >>~ (popContext))      return (attr, result)  parseRules "stringquote" = -  do (attr, result) <- ((pRegExpr regex_'28'3f'3a'28'3f'3a'5c'5c'22'29'3f'5b'5e'22'5d'2a'29'2a'22 >>= withAttribute "String") >>~ (popContext >> return ()))+  do (attr, result) <- ((pRegExpr regex_'28'3f'3a'28'3f'3a'5c'5c'22'29'3f'5b'5e'22'5d'2a'29'2a'22 >>= withAttribute "String") >>~ (popContext))      return (attr, result)  parseRules "comment" = 

@@ -1,4 +1,4 @@-{- This module was generated from data in the Kate syntax highlighting file fortran.xml, version 1.11,+{- This module was generated from data in the Kate syntax highlighting file fortran.xml, version 1.12,    by  Franchin Matteo (fnch@libero.it) -}  module Text.Highlighting.Kate.Syntax.Fortran ( highlight, parseExpression, syntaxName, syntaxExtensions ) where@@ -47,31 +47,30 @@ parseSourceLine = manyTill parseExpressionInternal pEndLine  pEndLine = do-  newline <|> (eof >> return '\n')+  lookAhead $ newline <|> (eof >> return '\n')   context <- currentContext   case context of-    "default" -> return ()-    "find_preprocessor" -> return ()-    "find_op_and_log" -> return ()-    "find_comments" -> return ()-    "find_symbols" -> return ()-    "inside_func_paren" -> return ()-    "find_io_stmnts" -> return ()-    "find_io_paren" -> return ()-    "format_stmnt" -> return ()-    "find_begin_stmnts" -> return ()-    "find_end_stmnts" -> return ()-    "find_decls" -> return ()-    "find_paren" -> (popContext >> return ())-    "find_intrinsics" -> return ()-    "find_numbers" -> return ()-    "find_strings" -> return ()-    "string_1" -> return ()-    "string_2" -> return ()-    "end_of_string" -> return ()-    _ -> return ()-  lineContents <- lookAhead wholeLine-  updateState $ \st -> st { synStCurrentLine = lineContents, synStCharsParsedInLine = 0, synStPrevChar = '\n' }+    "default" -> return () >> pHandleEndLine+    "find_preprocessor" -> return () >> pHandleEndLine+    "find_op_and_log" -> return () >> pHandleEndLine+    "find_comments" -> return () >> pHandleEndLine+    "find_symbols" -> return () >> pHandleEndLine+    "inside_func_paren" -> return () >> pHandleEndLine+    "find_io_stmnts" -> return () >> pHandleEndLine+    "find_io_paren" -> return () >> pHandleEndLine+    "format_stmnt" -> return () >> pHandleEndLine+    "find_begin_stmnts" -> return () >> pHandleEndLine+    "find_end_stmnts" -> return () >> pHandleEndLine+    "find_mid_stmnts" -> return () >> pHandleEndLine+    "find_decls" -> return () >> pHandleEndLine+    "find_paren" -> (popContext) >> pEndLine+    "find_intrinsics" -> return () >> pHandleEndLine+    "find_numbers" -> return () >> pHandleEndLine+    "find_strings" -> return () >> pHandleEndLine+    "string_1" -> return () >> pHandleEndLine+    "string_2" -> return () >> pHandleEndLine+    "end_of_string" -> return () >> pHandleEndLine+    _ -> pHandleEndLine  withAttribute attr txt = do   when (null txt) $ fail "Parser matched no text"@@ -88,7 +87,7 @@   context <- currentContext   parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes)) -list_keywords = Set.fromList $ words $ "allocate break call case common contains continue cycle deallocate default do forall where elsewhere elseif else equivalence exit external for go goto if implicit include interface intrinsic namelist none nullify operator assignment pause procedure pure elemental record recursive result return select selectcase stop then to use only entry while"+list_keywords = Set.fromList $ words $ "allocate break call case common continue cycle deallocate default forall where elsewhere equivalence exit external for go goto if implicit include interface intrinsic namelist none nullify operator assignment pause procedure pure elemental record recursive result return select selectcase stop to use only entry while" list_io'5ffunctions = Set.fromList $ words $ "access backspace close inquire open print read rewind write format" list_io'5fkeywords = Set.fromList $ words $ "unit end err fmt iostat status advance size eor" list_open'5fkeywords = Set.fromList $ words $ "unit iostat err file status access form recl blank position action delim pad"@@ -112,10 +111,17 @@ regex_'5cbend'5cs'2afile'5cb = compileRegex "\\bend\\s*file\\b" regex_'5b0'2d9'5d'2a'2f = compileRegex "[0-9]*/" regex_'5cbmodule'5cs'2bprocedure'5cb = compileRegex "\\bmodule\\s+procedure\\b"-regex_'5cb'28program'7csubroutine'7cfunction'7cmodule'7cblock'5cs'2adata'29'5cb = compileRegex "\\b(program|subroutine|function|module|block\\s*data)\\b"-regex_'5cbend'5cs'2a'28program'7csubroutine'7cfunction'7cmodule'7cblock'5cs'2adata'29'5cb = compileRegex "\\bend\\s*(program|subroutine|function|module|block\\s*data)\\b"-regex_'5cbend'5cs'2a'28do'7cif'7cselect'7cwhere'7cforall'7cinterface'29'5cb = compileRegex "\\bend\\s*(do|if|select|where|forall|interface)\\b"+regex_'5cb'28subroutine'7cfunction'7cblock'5cs'2adata'29'5cb = compileRegex "\\b(subroutine|function|block\\s*data)\\b"+regex_'5cb'28program'7cmodule'7cblock'5cs'2adata'29'5cb = compileRegex "\\b(program|module|block\\s*data)\\b"+regex_'5cb'28then'7cdo'29'5cb = compileRegex "\\b(then|do)\\b"+regex_'5cbend'5cs'2a'28subroutine'7cfunction'7cblock'5cs'2adata'29'5cb = compileRegex "\\bend\\s*(subroutine|function|block\\s*data)\\b"+regex_'5cbend'5cs'2a'28program'7cmodule'29'5cb = compileRegex "\\bend\\s*(program|module)\\b"+regex_'5cbend'5cs'2a'28do'7cif'29'5cb = compileRegex "\\bend\\s*(do|if)\\b"+regex_'5cbend'5cs'2a'28select'7cwhere'7cforall'7cinterface'29'5cb = compileRegex "\\bend\\s*(select|where|forall|interface)\\b"+regex_'5cbelse'5cs'2aif'5cb = compileRegex "\\belse\\s*if\\b" regex_'5cbend'5cb = compileRegex "\\bend\\b"+regex_'5cbelse'5cb = compileRegex "\\belse\\b"+regex_'5cbcontains'5cb = compileRegex "\\bcontains\\b" regex_'5cbinteger'5b'5c'2a'5d'5cd'7b1'2c2'7d = compileRegex "\\binteger[\\*]\\d{1,2}" regex_'5cbreal'5b'5c'2a'5d'5cd'7b1'2c2'7d = compileRegex "\\breal[\\*]\\d{1,2}" regex_'5cbcomplex'5b'5c'2a'5d'5cd'7b1'2c2'7d = compileRegex "\\bcomplex[\\*]\\d{1,2}"@@ -137,7 +143,7 @@ regex_'5b'5e'22'5d'2a'22 = compileRegex "[^\"]*\"" regex_'28'21'2e'2a'29'3f'24 = compileRegex "(!.*)?$" -defaultAttributes = [("default","Normal Text"),("find_preprocessor","Normal Text"),("find_op_and_log","Normal Text"),("find_comments","Normal Text"),("find_symbols","Normal Text"),("inside_func_paren","Normal Text"),("find_io_stmnts","Normal Text"),("find_io_paren","Normal Text"),("format_stmnt","Normal Text"),("find_begin_stmnts","Normal Text"),("find_end_stmnts","Normal Text"),("find_decls","Normal Text"),("find_paren","Data Type"),("find_intrinsics","Normal Text"),("find_numbers","Normal Text"),("find_strings","String"),("string_1","String"),("string_2","String"),("end_of_string","String")]+defaultAttributes = [("default","Normal Text"),("find_preprocessor","Normal Text"),("find_op_and_log","Normal Text"),("find_comments","Normal Text"),("find_symbols","Normal Text"),("inside_func_paren","Normal Text"),("find_io_stmnts","Normal Text"),("find_io_paren","Normal Text"),("format_stmnt","Normal Text"),("find_begin_stmnts","Normal Text"),("find_end_stmnts","Normal Text"),("find_mid_stmnts","Normal Text"),("find_decls","Normal Text"),("find_paren","Data Type"),("find_intrinsics","Normal Text"),("find_numbers","Normal Text"),("find_strings","String"),("string_1","String"),("string_2","String"),("end_of_string","String")]  parseRules "default" =    do (attr, result) <- (((parseRules "find_strings"))@@ -158,9 +164,11 @@                         <|>                         ((parseRules "find_symbols"))                         <|>+                        ((parseRules "find_begin_stmnts"))+                        <|>                         ((parseRules "find_end_stmnts"))                         <|>-                        ((parseRules "find_begin_stmnts")))+                        ((parseRules "find_mid_stmnts")))      return (attr, result)  parseRules "find_preprocessor" = @@ -196,7 +204,7 @@ parseRules "inside_func_paren" =    do (attr, result) <- (((pDetectChar False '(' >>= withAttribute "Normal Text") >>~ pushContext "inside_func_paren")                         <|>-                        ((pDetectChar False ')' >>= withAttribute "Normal Text") >>~ (popContext >> return ()))+                        ((pDetectChar False ')' >>= withAttribute "Normal Text") >>~ (popContext))                         <|>                         ((parseRules "find_strings"))                         <|>@@ -224,7 +232,7 @@                         <|>                         ((pDetectChar False '(' >>= withAttribute "Normal Text") >>~ pushContext "inside_func_paren")                         <|>-                        ((pDetectChar False ')' >>= withAttribute "IO Function") >>~ (popContext >> return ()))+                        ((pDetectChar False ')' >>= withAttribute "IO Function") >>~ (popContext))                         <|>                         ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_io'5fkeywords >>= withAttribute "IO Function"))                         <|>@@ -244,7 +252,7 @@ parseRules "format_stmnt" =    do (attr, result) <- (((pDetectChar False '(' >>= withAttribute "IO Function") >>~ pushContext "format_stmnt")                         <|>-                        ((pDetectChar False ')' >>= withAttribute "IO Function") >>~ (popContext >> return ()))+                        ((pDetectChar False ')' >>= withAttribute "IO Function") >>~ (popContext))                         <|>                         ((pRegExpr regex_'5b0'2d9'5d'2a'2f >>= withAttribute "IO Function"))                         <|>@@ -258,17 +266,33 @@ parseRules "find_begin_stmnts" =    do (attr, result) <- (((pRegExpr regex_'5cbmodule'5cs'2bprocedure'5cb >>= withAttribute "Keyword"))                         <|>-                        ((pRegExpr regex_'5cb'28program'7csubroutine'7cfunction'7cmodule'7cblock'5cs'2adata'29'5cb >>= withAttribute "Keyword")))+                        ((pRegExpr regex_'5cb'28subroutine'7cfunction'7cblock'5cs'2adata'29'5cb >>= withAttribute "Keyword"))+                        <|>+                        ((pRegExpr regex_'5cb'28program'7cmodule'7cblock'5cs'2adata'29'5cb >>= withAttribute "Keyword"))+                        <|>+                        ((pRegExpr regex_'5cb'28then'7cdo'29'5cb >>= withAttribute "Keyword")))      return (attr, result)  parseRules "find_end_stmnts" = -  do (attr, result) <- (((pRegExpr regex_'5cbend'5cs'2a'28program'7csubroutine'7cfunction'7cmodule'7cblock'5cs'2adata'29'5cb >>= withAttribute "Keyword"))+  do (attr, result) <- (((pRegExpr regex_'5cbend'5cs'2a'28subroutine'7cfunction'7cblock'5cs'2adata'29'5cb >>= withAttribute "Keyword"))                         <|>-                        ((pRegExpr regex_'5cbend'5cs'2a'28do'7cif'7cselect'7cwhere'7cforall'7cinterface'29'5cb >>= withAttribute "Keyword"))+                        ((pRegExpr regex_'5cbend'5cs'2a'28program'7cmodule'29'5cb >>= withAttribute "Keyword"))                         <|>+                        ((pRegExpr regex_'5cbend'5cs'2a'28do'7cif'29'5cb >>= withAttribute "Keyword"))+                        <|>+                        ((pRegExpr regex_'5cbend'5cs'2a'28select'7cwhere'7cforall'7cinterface'29'5cb >>= withAttribute "Keyword"))+                        <|>+                        ((pRegExpr regex_'5cbelse'5cs'2aif'5cb >>= withAttribute "Keyword"))+                        <|>                         ((pRegExpr regex_'5cbend'5cb >>= withAttribute "Keyword")))      return (attr, result) +parseRules "find_mid_stmnts" = +  do (attr, result) <- (((pRegExpr regex_'5cbelse'5cb >>= withAttribute "Keyword"))+                        <|>+                        ((pRegExpr regex_'5cbcontains'5cb >>= withAttribute "Keyword")))+     return (attr, result)+ parseRules "find_decls" =    do (attr, result) <- (((pRegExpr regex_'5cbinteger'5b'5c'2a'5d'5cd'7b1'2c2'7d >>= withAttribute "Data Type"))                         <|>@@ -298,7 +322,7 @@ parseRules "find_paren" =    do (attr, result) <- (((pDetectChar False '(' >>= withAttribute "Data Type") >>~ pushContext "find_paren")                         <|>-                        ((pDetectChar False ')' >>= withAttribute "Data Type") >>~ (popContext >> return ())))+                        ((pDetectChar False ')' >>= withAttribute "Data Type") >>~ (popContext)))      return (attr, result)  parseRules "find_intrinsics" = @@ -332,23 +356,23 @@      return (attr, result)  parseRules "string_1" = -  do (attr, result) <- (((pRegExpr regex_'5b'5e'27'5d'2a'27 >>= withAttribute "String") >>~ (popContext >> return ()))+  do (attr, result) <- (((pRegExpr regex_'5b'5e'27'5d'2a'27 >>= withAttribute "String") >>~ (popContext))                         <|>                         ((pRegExpr regex_'26'5cs'2a'24 >>= withAttribute "Keyword") >>~ pushContext "end_of_string")                         <|>                         ((pRegExpr regex_'2e'2a'28'3f'3d'26'5cs'2a'24'29 >>= withAttribute "String") >>~ pushContext "end_of_string")                         <|>-                        ((popContext >> return ()) >> return ([], "")))+                        ((popContext) >> return ([], "")))      return (attr, result)  parseRules "string_2" = -  do (attr, result) <- (((pRegExpr regex_'5b'5e'22'5d'2a'22 >>= withAttribute "String") >>~ (popContext >> return ()))+  do (attr, result) <- (((pRegExpr regex_'5b'5e'22'5d'2a'22 >>= withAttribute "String") >>~ (popContext))                         <|>                         ((pRegExpr regex_'26'5cs'2a'24 >>= withAttribute "Keyword") >>~ pushContext "end_of_string")                         <|>                         ((pRegExpr regex_'2e'2a'28'3f'3d'26'5cs'2a'24'29 >>= withAttribute "String") >>~ pushContext "end_of_string")                         <|>-                        ((popContext >> return ()) >> return ([], "")))+                        ((popContext) >> return ([], "")))      return (attr, result)  parseRules "end_of_string" = @@ -356,11 +380,11 @@                         <|>                         ((pRegExpr regex_'26'5cs'2a'24 >>= withAttribute "Keyword"))                         <|>-                        ((pFirstNonSpace >> pDetectChar False '&' >>= withAttribute "Keyword") >>~ (popContext >> return ()))+                        ((pFirstNonSpace >> pDetectChar False '&' >>= withAttribute "Keyword") >>~ (popContext))                         <|>                         ((pFirstNonSpace >> pRegExpr regex_'28'21'2e'2a'29'3f'24 >>= withAttribute "Comment"))                         <|>-                        ((popContext >> popContext >> return ()) >> return ([], "")))+                        ((popContext >> popContext) >> return ([], "")))      return (attr, result)  parseRules x = fail $ "Unknown context" ++ x

@@ -0,0 +1,143 @@+{- This module was generated from data in the Kate syntax highlighting file fstab.xml, version 1.00,+   by  Diego Iastrubni (elcuco@kde.org) -}++module Text.Highlighting.Kate.Syntax.Fstab ( 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 = "fstab"++-- | Filename extensions for this language.+syntaxExtensions :: String+syntaxExtensions = "fstab;mtab"++-- | 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 = "fstab" }+  context <- currentContext <|> (pushContext "device" >> 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 [("fstab",["device"])], synStLanguage = "fstab", synStCurrentLine = "", synStCharsParsedInLine = 0, synStPrevChar = '\n', synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}++parseSourceLine = manyTill parseExpressionInternal pEndLine++pEndLine = do+  lookAhead $ newline <|> (eof >> return '\n')+  context <- currentContext+  case context of+    "device" -> return () >> pHandleEndLine+    "mount_point" -> pushContext "device" >> pHandleEndLine+    "_type" -> pushContext "device" >> pHandleEndLine+    "type" -> pushContext "device" >> pHandleEndLine+    "options" -> pushContext "device" >> pHandleEndLine+    "dump" -> pushContext "device" >> pHandleEndLine+    "pass" -> pushContext "device" >> pHandleEndLine+    "__error" -> pushContext "device" >> pHandleEndLine+    "error" -> pushContext "device" >> pHandleEndLine+    "comment" -> (popContext) >> pEndLine+    _ -> pHandleEndLine++withAttribute attr txt = do+  when (null txt) $ fail "Parser matched no text"+  let labs = attr : maybeToList (lookup attr styles)+  st <- getState+  let oldCharsParsed = synStCharsParsedInLine st+  let prevchar = if null txt then '\n' else last txt+  updateState $ \st -> st { synStCharsParsedInLine = oldCharsParsed + length txt, synStPrevChar = prevchar } +  return (labs, txt)++styles = [("Device","kw"),("Mount Point","dt"),("Type","fu"),("Options","kw"),("Dump","dv"),("Pass","dv"),("Valid FileSystem","dt"),("Comment","co"),("Error","er")]++parseExpressionInternal = do+  context <- currentContext+  parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes))++list_valid'5ffs = Set.fromList $ words $ "ext2 ext3 fat vfat reiser proc none sysfs ntfs umsdos swap minix iso9660"++regex_'5b'5cs'5d'2a = compileRegex "[\\s]*"+regex_'5b'5cS'5d'2a = compileRegex "[\\S]*"++defaultAttributes = [("device","Device"),("mount_point","Mount Point"),("_type","Normal"),("type","Type"),("options","Options"),("dump","Dump"),("pass","Pass"),("__error","Pass"),("error","Error"),("comment","Comment")]++parseRules "device" = +  do (attr, result) <- (((pFirstNonSpace >> pDetectChar False '#' >>= withAttribute "Device") >>~ pushContext "comment")+                        <|>+                        ((pRegExpr regex_'5b'5cs'5d'2a >>= withAttribute "Device") >>~ pushContext "mount_point"))+     return (attr, result)++parseRules "mount_point" = +  do (attr, result) <- (((pFirstNonSpace >> pDetectChar False '#' >>= withAttribute "Mount Point") >>~ pushContext "comment")+                        <|>+                        ((pRegExpr regex_'5b'5cs'5d'2a >>= withAttribute "Mount Point") >>~ pushContext "_type"))+     return (attr, result)++parseRules "_type" = +  do (attr, result) <- (((pFirstNonSpace >> pDetectChar False '#' >>= withAttribute "Normal") >>~ pushContext "comment")+                        <|>+                        ((pRegExpr regex_'5b'5cS'5d'2a >>= withAttribute "Normal") >>~ pushContext "type"))+     return (attr, result)++parseRules "type" = +  do (attr, result) <- (((pFirstNonSpace >> pDetectChar False '#' >>= withAttribute "Type") >>~ pushContext "comment")+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" Set.empty >>= withAttribute "Valid FileSystem"))+                        <|>+                        ((pRegExpr regex_'5b'5cs'5d'2a >>= withAttribute "Type") >>~ pushContext "options"))+     return (attr, result)++parseRules "options" = +  do (attr, result) <- (((pFirstNonSpace >> pDetectChar False '#' >>= withAttribute "Options") >>~ pushContext "comment")+                        <|>+                        ((pRegExpr regex_'5b'5cs'5d'2a >>= withAttribute "Options") >>~ pushContext "dump"))+     return (attr, result)++parseRules "dump" = +  do (attr, result) <- (((pFirstNonSpace >> pDetectChar False '#' >>= withAttribute "Dump") >>~ pushContext "comment")+                        <|>+                        ((pRegExpr regex_'5b'5cs'5d'2a >>= withAttribute "Dump") >>~ pushContext "pass"))+     return (attr, result)++parseRules "pass" = +  do (attr, result) <- (((pFirstNonSpace >> pDetectChar False '#' >>= withAttribute "Pass") >>~ pushContext "comment")+                        <|>+                        ((pRegExpr regex_'5b'5cs'5d'2a >>= withAttribute "Pass") >>~ pushContext "__error"))+     return (attr, result)++parseRules "__error" = +  do (attr, result) <- (((pDetectChar False '#' >>= withAttribute "Pass") >>~ pushContext "comment")+                        <|>+                        ((pRegExpr regex_'5b'5cS'5d'2a >>= withAttribute "Pass") >>~ pushContext "error"))+     return (attr, result)++parseRules "error" = +  pzero++parseRules "comment" = +  pzero++parseRules x = fail $ "Unknown context" ++ x

@@ -0,0 +1,176 @@+{- This module was generated from data in the Kate syntax highlighting file gap.xml, version 0.2,+   by  Jose Joao Morais -}++module Text.Highlighting.Kate.Syntax.Gap ( 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 = "GAP"++-- | Filename extensions for this language.+syntaxExtensions :: String+syntaxExtensions = "*.gd;*.gi;*.g"++-- | 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 = "GAP" }+  context <- currentContext <|> (pushContext "Top_Level" >> 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 [("GAP",["Top_Level"])], synStLanguage = "GAP", synStCurrentLine = "", synStCharsParsedInLine = 0, synStPrevChar = '\n', synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}++parseSourceLine = manyTill parseExpressionInternal pEndLine++pEndLine = do+  lookAhead $ newline <|> (eof >> return '\n')+  context <- currentContext+  case context of+    "Top_Level" -> return () >> pHandleEndLine+    "Commentary" -> (popContext) >> pEndLine+    "Code_Folding" -> pushContext "Top_Level" >> pHandleEndLine+    "Two Char Operators" -> return () >> pHandleEndLine+    "Strings" -> return () >> pHandleEndLine+    _ -> pHandleEndLine++withAttribute attr txt = do+  when (null txt) $ fail "Parser matched no text"+  let labs = attr : maybeToList (lookup attr styles)+  st <- getState+  let oldCharsParsed = synStCharsParsedInLine st+  let prevchar = if null txt then '\n' else last txt+  updateState $ \st -> st { synStCharsParsedInLine = oldCharsParsed + length txt, synStPrevChar = prevchar } +  return (labs, txt)++styles = [("Builtin Functions","fu"),("Commentary","co"),("Control Statements","kw"),("Function","kw"),("GAP Keywords","kw"),("Incomplete String","ch"),("Logic Operators","kw"),("Math Operators","kw"),("Number","fl"),("String","st")]++parseExpressionInternal = do+  context <- currentContext+  parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes))++list_controlstatements = Set.fromList $ words $ "break continue do elif else then"+list_logicoperators = Set.fromList $ words $ "and fail false not or true"+list_gapkeywords = Set.fromList $ words $ "in local rec return"+list_mathoperators = Set.fromList $ words $ "mod"+list_builtinfunctions = Set.fromList $ words $ "AClosVecLib AClosestVectorCombinationsMatFFEVecFFE AClosestVectorCombinationsMatFFEVecFFECoords AClosestVectorDriver ANFAutomorphism ANonReesCongruenceOfSemigroup APolyProd AbelianGroup AbelianGroupCons AbelianInvariants AbelianInvariantsMultiplier AbelianInvariantsNormalClosureFpGroup AbelianInvariantsNormalClosureFpGroupRrs AbelianInvariantsOfList AbelianInvariantsSubgroupFpGroup AbelianInvariantsSubgroupFpGroupMtc AbelianInvariantsSubgroupFpGroupRrs AbelianNumberField AbelianNumberFieldByReducedGaloisStabilizerInfo AbelianPQuotient AbelianSubfactorAction AbsAndIrredModules AbsInt AbsolutIrreducibleModules AbsoluteIrreducibleModules AbsoluteValue AbstractWordTietzeWord AbstractWordTzWord ActingAlgebra ActingDomain Action ActionAbelianCSPG ActionHomomorphism ActionHomomorphismAttr ActionHomomorphismConstructor ActionKernelExternalSet ActionSubspacesElementaryAbelianGroup ActorOfExternalSet Add AddAbelianRelator AddCoeffs AddCosetInfoStabChain AddDictionary AddEquationsSQ AddGenerator AddGenerators AddGeneratorsExtendSchreierTree AddGeneratorsGenimagesExtendSchreierTree AddHashEntry AddImage AddImageNC AddNaturalHomomorphismsPool AddNormalizingElementPcgs AddPageNumbersToSix AddParagraphNumbersGapDocTree AddRefinement AddRelator AddRootParseTree AddRowVector AddRule AddRuleReduced AddSet AddToListEntries AddVectorLTM AddendumSCTable AdditiveCoset AdditiveElementAsMultiplicativeElement AdditiveElementsAsMultiplicativeElementsFamily AdditiveGroup AdditiveGroupByGenerators AdditiveInverse AdditiveInverseAttr AdditiveInverseImmutable AdditiveInverseMutable AdditiveInverseOp AdditiveInverseSM AdditiveInverseSameMutability AdditiveMagma AdditiveMagmaByGenerators AdditiveMagmaWithInverses AdditiveMagmaWithInversesByGenerators AdditiveMagmaWithZero AdditiveMagmaWithZeroByGenerators AdditiveNeutralElement AdditivelyActingDomain AdjointAssociativeAlgebra AdjointBasis AdjointMatrix AdjointModule AffineAction AffineActionByMatrixGroup AffineActionLayer AffineOperation AffineOperationLayer Agemo AgemoAbove AgemoOp AlgExtElm AlgExtEmbeddedPol AlgExtFactSQFree AlgExtSquareHensel AlgFacUPrep Algebra AlgebraByGenerators AlgebraByStructureConstants AlgebraByStructureConstantsArg AlgebraGeneralMappingByImages AlgebraHomomorphismByImages AlgebraHomomorphismByImagesNC AlgebraWithOne AlgebraWithOneByGenerators AlgebraWithOneGeneralMappingByImages AlgebraWithOneHomomorphismByImages AlgebraWithOneHomomorphismByImagesNC AlgebraicElementsFamilies AlgebraicElementsFamily AlgebraicExtension AlgebraicPolynomialModP AllBlocks AllGroups AllIrreducibleMonicPolynomialCoeffsOfDegree AllIrreducibleMonicPolynomials AllIrreducibleSolvableGroups AllLibTomNames AllModulesSQ AllMonicPolynomialCoeffsOfDegree AllPrimitiveGroups AllSmallGroups AllTransitiveGroups AllowableSubgroup Alpha AlternatingDegree AlternatingGroup AlternatingGroupCons AlternatingSubgroup AntiSymmetricParts Append AppendCollectedList AppendTo ApplicableMethod ApplicableMethodTypes Apply ApplyGeneratorsToPoint ApplyGeneratorsToPointsList ApplyRel ApplySimpleReflection ApplyToNodesParseTree ApproxRational ApproxRootBound ApproximateRoot ApproximateSuborbitsStabilizerPermGroup ArithmeticElementCreator Arrangements ArrangementsA ArrangementsK AsAlgebra AsAlgebraWithOne AsBinaryRelationOnPoints AsBlockMatrix AsCharacterMorphismFunction AsDivisionRing AsDuplicateFreeList AsFLMLOR AsFLMLORWithOne AsField AsFreeLeftModule AsGroup AsGroupGeneralMappingByImages AsInducedPcgs AsLeftIdeal AsLeftMagmaIdeal AsLeftModule AsLeftModuleGeneralMappingByImages AsLieAlgebra AsList AsListOfFreeLeftModule AsListSorted AsMagma AsMagmaIdeal AsMonoid AsNearRing AsPerm AsPlist AsPolynomial AsRightIdeal AsRightMagmaIdeal AsRing AsSSortedList AsSSortedListList AsSSortedListNonstored AsSemigroup AsSemiring AsSemiringWithOne AsSemiringWithOneAndZero AsSemiringWithZero AsSet AsSortedList AsSubFLMLOR AsSubFLMLORWithOne AsSubalgebra AsSubalgebraWithOne AsSubgroup AsSubgroupOfWholeGroupByQuotient AsSubmagma AsSubmonoid AsSubsemigroup AsSubspace AsTransformation AsTransformationNC AsTwoSidedIdeal AsVectorSpace AscendingChain AscendingChainOp Assert AssertionLevel AssignGeneratorVariables AssignNiceMonomorphismAutomorphismGroup AssocBWorLetRepPow AssocWWorLetRepPow AssocWord AssocWordByLetterRep AssociatedPartition AssociatedReesMatrixSemigroupOfDClass AssociatedSemigroup Associates AtlasIrrationality AttributeMethodByNiceMonomorphism AttributeMethodByNiceMonomorphismCollColl AttributeMethodByNiceMonomorphismCollElm AttributeMethodByNiceMonomorphismElmColl AttributeValueNotSet AugmentationIdeal AugmentedCosetTableInWholeGroup AugmentedCosetTableMtc AugmentedCosetTableMtcInWholeGroup AugmentedCosetTableNormalClosure AugmentedCosetTableNormalClosureInWholeGroup AugmentedCosetTableRrs AugmentedCosetTableRrsInWholeGroup AutoloadPackages AutomorphismDomain AutomorphismGroup AutomorphismGroupAbelianGroup AutomorphismGroupElAbGroup AutomorphismGroupFrattFreeGroup AutomorphismGroupPermGroup AutomorphismGroupSolvableGroup AutomorphismRepresentingGroup AutomorphismsOfTable AvoidedLayers BPolyProd BagStats BarPartitions BaseFixedSpace BaseImage BaseIntMat BaseIntersectionIntMats BaseMat BaseMatDestructive BaseOfBasicImageGroup BaseOfElt BaseOfGroup BaseOrthogonalSpaceMat BasePoint BasePointOfSchreierTransversal BaseShortVectors BaseStabChain BaseSteinitzVectors BasicImageEltRepFamily BasicImageGroup BasicImageGroupElement BasicWreathProductOrdering BasicWreathProductOrderingNC Basis BasisForFreeModuleByNiceBasis BasisNC BasisNullspaceModN BasisOfAlgebraModule BasisOfHomCosetAddMatrixGroup BasisOfHomCosetAddMatrixGroupFnc BasisOfMonomialSpace BasisOfSparseRowSpace BasisOfWeightRepSpace BasisVectors BasisVectorsForMatrixAction BasisWithReplacedLeftModule BaumClausenInfo BaumClausenInfoDebug BeauzamyBound BeauzamyBoundGcd Bell Bernoulli BestQuoInt BestSplittingMatrix BetaSet BiAlgebraModule BiAlgebraModuleByGenerators BilinearFormMat BinaryRelationByElements BinaryRelationByListOfImages BinaryRelationByListOfImagesNC BinaryRelationOnPoints BinaryRelationOnPointsNC BinaryRelationTransformation BindGlobal Binomial BlistList BlistStringDecode BlockMatrix BlockStabilizer Blocks BlocksAttr BlocksInfo BlocksOp BlowUpCocycleSQ BlowUpIsomorphism BlownUpMat BlownUpMatrix BlownUpModule BlownUpVector BombieriNorm BooleanFamily BrauerCharacterValue BrauerTable BrauerTableOp BravaisGroup BravaisSubgroups BravaisSupergroups BuildIsomorphismReesMatrixSemigroupWithMap CIUnivPols COAffineBlocks COComplements COComplementsMain CONextCentral CONextCentralizer CONextCocycles CONextComplements CalcDoubleCosets CalcOrder CallFuncList CallFuncTrapError CanComputeIndex CanComputeIsSubset CanComputeSize CanComputeSizeAnySubgroup CanEasilyCompareElements CanEasilyCompareElementsFamily CanEasilyComputePcgs CanEasilySortElements CanEasilySortElementsFamily CanEasilyTestMembership CanFindGeneratorOfCyclicGroup CanFindNilpotentClassTwoElement CanonicalBasis CanonicalElt CanonicalGenerators CanonicalNiceMonomorphism CanonicalPcElement CanonicalPcgs CanonicalPcgsByGeneratorsWithImages CanonicalPcgsWrtFamilyPcgs CanonicalPcgsWrtHomePcgs CanonicalPcgsWrtSpecialPcgs CanonicalRelator CanonicalRepresentativeDeterminatorOfExternalSet CanonicalRepresentativeOfExternalSet CanonicalRightCosetElement CanonicalSubgroupRepresentativePcGroup CartanMatrix CartanSubalgebra Cartesian CasesCSPG CategoriesOfObject CategoryCollections CategoryFamily CayleyGraphDualSemigroup CayleyGraphSemigroup Cell CellNoPoint CellNoPoints Cells Center CenterOfCharacter CentralCharacter CentralIdempotentsOfAlgebra CentralIdempotentsOfSemiring CentralNormalSeriesByPcgs CentralProductOfMatrixGroups CentralRelations CentralStelClEANSNonsolv CentralStepClEANS CentralStepConjugatingElement CentralStepRatClPGroup Centralizer CentralizerInAssociativeGaussianMatrixAlgebra CentralizerInFiniteDimensionalAlgebra CentralizerInGLnZ CentralizerInParent CentralizerModulo CentralizerNormalCSPG CentralizerNormalTransCSPG CentralizerOp CentralizerOrder CentralizerSizeLimitConsiderFunction CentralizerSolvableGroup CentralizerTransSymmCSPG CentralizerWreath Centre CentreFromSCTable CentreOfCharacter CentrePcGroup ChaNuPol ChainHomomorphicImage ChainStatistics ChainSubgroup ChainSubgroupByDirectProduct ChainSubgroupByHomomorphism ChainSubgroupByPSubgroupOfAbelian ChainSubgroupByProjectionFunction ChainSubgroupBySiftFunction ChainSubgroupByStabiliser ChainSubgroupByStabilizer ChainSubgroupByTrivialSubgroup ChainSubgroupQuotient ChangeStabChain ChangeTypeObj ChangedBaseGroup CharTableAlternating CharTableDoubleCoverAlternating CharTableDoubleCoverSymmetric CharTableSymmetric CharTableWeylB CharTableWeylD CharValueDoubleCoverSymmetric CharValueSymmetric CharValueWeylB CharValueWreathSymmetric Character CharacterDegreePool CharacterDegrees CharacterMorphismGroup CharacterMorphismOrbits CharacterNames CharacterParameters CharacterString CharacterTable CharacterTableDirectProduct CharacterTableDisplayPrintLegendDefault CharacterTableDisplayStringEntryDataDefault CharacterTableDisplayStringEntryDefault CharacterTableFactorGroup CharacterTableFromLibrary CharacterTableHeadOfFactorGroupByFusion CharacterTableIsoclinic CharacterTableOfNormalSubgroup CharacterTableQuaternionic CharacterTableRegular CharacterTableWithSortedCharacters CharacterTableWithSortedClasses CharacterTableWreathSymmetric Characteristic CharacteristicPolynomial CharacteristicPolynomialMatrixNC CharsFamily CheckAndCleanGapDocTree CheckAuto CheckCompletionFiles CheckConsistencyOfDefinitions CheckCosetTableFpGroup CheckFixedPoints CheckForHandlingByNiceBasis CheckGlobalName CheckPackageLoading CheckPermChar CheckSchreierTreeInternalConsistency ChevalleyBasis ChiefNormalSeriesByPcgs ChiefSeries ChiefSeriesOfGroup ChiefSeriesThrough ChiefSeriesUnderAction ChineseRem Chomp ChooseNextBasePoint ClassComparison ClassElementLargeGroup ClassElementLattice ClassElementSmallGroup ClassFunction ClassFunctionSameType ClassMultiplicationCoefficient ClassNames ClassNamesTom ClassNumbersElements ClassOrbit ClassParameters ClassPermutation ClassPositionsOfAgemo ClassPositionsOfCentre ClassPositionsOfDerivedSubgroup ClassPositionsOfDirectProductDecompositions ClassPositionsOfElementaryAbelianSeries ClassPositionsOfFittingSubgroup ClassPositionsOfKernel ClassPositionsOfLowerCentralSeries ClassPositionsOfMaximalNormalSubgroups ClassPositionsOfNormalClosure ClassPositionsOfNormalSubgroup ClassPositionsOfNormalSubgroups ClassPositionsOfSolvableResiduum ClassPositionsOfSupersolvableResiduum ClassPositionsOfUpperCentralSeries ClassRepsPermutedTuples ClassRoots ClassStructureCharTable ClassTypesTom ClassesSolvableGroup CleanedTailPcElement ClearCacheStats ClearCentralRelations ClearDefinitionNC ClearPQuotientStatistics ClearProfile CloseMutableBasis CloseNaturalHomomorphismsPool CloseStream ClosedStreamType ClosureAdditiveGroup ClosureAdditiveMagmaDefault ClosureAdditiveMagmaWithInverses ClosureAlgebra ClosureDivisionRing ClosureField ClosureGroup ClosureGroupAddElm ClosureGroupCompare ClosureGroupDefault ClosureGroupIntest ClosureLeftModule ClosureLeftOperatorRing ClosureMagmaDefault ClosureNearAdditiveGroup ClosureNearAdditiveMagmaWithInverses ClosureRandomPermGroup ClosureRing ClosureSemiring ClosureSubgroup ClosureSubgroupNC CntOp CoKernel CoKernelGensIterator CoKernelGensPermHom CoKernelOfAdditiveGeneralMapping CoKernelOfMultiplicativeGeneralMapping CoSuFp Coboundaries CocGroup Cochain CochainSpace CocycleSQ CocycleToRelVector Cocycles CodeGenerators CodePcGroup CodePcgs CoefficientTaylorSeries Coefficients CoefficientsAndMagmaElements CoefficientsFamily CoefficientsMultiadic CoefficientsOfLaurentPolynomial CoefficientsOfUnivariateLaurentPolynomial CoefficientsOfUnivariatePolynomial CoefficientsOfUnivariateRationalFunction CoefficientsOfVector CoefficientsQadic CoefficientsRing CoeffsCyc CoeffsMod CollFamRangeEqFamElms CollFamSourceEqFamElms CollapsedMat CollectPolycyclic CollectUEALatticeElement CollectWord CollectWordOrFail Collected CollectedPartition CollectedWordSQ CollectionsFamily CollectorSQ ColorPrompt ColumnIndexOfReesMatrixSemigroupElement ColumnIndexOfReesZeroMatrixSemigroupElement ColumnsOfReesMatrixSemigroup ColumnsOfReesZeroMatrixSemigroup Combinations CombinationsA CombinationsK CombinatorialCollector CombinatorialCollectorByGenerators CombinatoricSplit Comm CommutGenImgs CommutativeDiagram CommutatorFactorGroup CommutatorLength CommutatorSubgroup Compacted CompanionMat CompareVersionNumbers CompatibleConjugacyClasses CompatibleConjugacyClassesDefault CompatiblePairs CompileFunc ComplementIntMat ComplementSystem Complementclasses ComplementclassesEA ComplementclassesSolvableNC ComplementclassesSolvableWBG CompleteChain CompleteGaloisGroupPElement CompleteOrdersOfRws CompleteSchreierTransversal CompletionBar ComplexConjugate ComplexificationQuat ComponentsOfTuplesFamily ComposedXMLString CompositionMapping CompositionMaps CompositionOfStraightLinePrograms CompositionSeries Compress ComputeTails ComputedAgemos ComputedAscendingChains ComputedBrauerTables ComputedClassFusions ComputedCyclicExtensionsTom ComputedHallSubgroups ComputedIndicators ComputedIsPNilpotents ComputedIsPSolvableCharacterTables ComputedIsPSolvables ComputedOmegas ComputedPCentralSeriess ComputedPCores ComputedPRumps ComputedPowerMaps ComputedPrimeBlockss ComputedSylowComplements ComputedSylowSubgroups ConcatSubos Concatenation Conductor ConfluentRws Congruences ConjugacyClass ConjugacyClassSubgroups ConjugacyClasses ConjugacyClassesByOrbits ConjugacyClassesByRandomSearch ConjugacyClassesFittingFreeGroup ConjugacyClassesForSmallGroup ConjugacyClassesMaximalSubgroups ConjugacyClassesOfNaturalGroup ConjugacyClassesPerfectSubgroups ConjugacyClassesSubgroups ConjugacyClassesSubwreath ConjugacyClassesTry ConjugacyClassesViaRadical ConjugateDominantWeight ConjugateDominantWeightWithWord ConjugateGroup ConjugateMatrixActionToLinearAction ConjugateMatrixGroupToLinearAction ConjugateMatrixGroupToLinearGroup ConjugateStabChain ConjugateSubgroup ConjugateSubgroups ConjugatedModule Conjugates ConjugatingElement ConjugatorAutomorphism ConjugatorAutomorphismNC ConjugatorInnerAutomorphism ConjugatorIsomorphism ConjugatorOfConjugatorIsomorphism ConnectGroupAndCharacterTable ConsiderKernels ConsiderSmallerPowerMaps ConsiderStructureConstants ConsiderTableAutomorphisms ConstantInBaseRingPol ConstantTimeAccessList ConstituentsCompositionMapping ConstituentsOfCharacter ConstituentsPolynomial ContainedCharacters ContainedDecomposables ContainedMaps ContainedPossibleCharacters ContainedPossibleVirtualCharacters ContainedSpecialVectors ContainedTom ContainingTom ContinuedFractionApproximationOfRoot ContinuedFractionExpansionOfRoot ConvertBasicImageGroupElement ConvertToCharacterTable ConvertToCharacterTableNC ConvertToLibTom ConvertToLibraryCharacterTableNC ConvertToMatrixRep ConvertToMatrixRepNC ConvertToNormalFormMonomialElement ConvertToRangeRep ConvertToSiftGroup ConvertToStringRep ConvertToTableOfMarks ConvertToVectorRep ConvertToVectorRepNC ConwayCandidates ConwayPol ConwayPolynomial CopiedAugmentedCosetTable CopyMappingAttributes CopyOptionsDefaults CopyRel CopyStabChain Core CoreInParent CoreOp CorestEval CorrectConjugacyClass CorrespondingGeneratorsByModuloPcgs CorrespondingPermutations CosetLeadersInner CosetLeadersMatFFE CosetNumber CosetRepAsWord CosetTable CosetTableBySubgroup CosetTableDefaultLimit CosetTableDefaultMaxLimit CosetTableFpHom CosetTableFromGensAndRels CosetTableInWholeGroup CosetTableNormalClosure CosetTableNormalClosureInWholeGroup CosetTableOfFpSemigroup CosetTableStandard CoveringTriplesCharacters CrcFile CreateAllCycleStructures CreateCompletionFiles CreateKnuthBendixRewritingSystem CreateOrderingByLtFunction CreateOrderingByLteqFunction CrystGroupDefaultAction CurrentAssertionLevel CycList Cycle CycleByPosOp CycleIndex CycleIndexOp CycleLength CycleLengthOp CycleLengthPermInt CycleLengths CycleLengthsOp CycleOp CyclePermInt CycleStructureClass CycleStructurePerm CycleStructuresGroup Cycles CyclesOp CyclicExtensionsTom CyclicExtensionsTomOp CyclicGroup CyclicGroupCons CyclicTopExtensions CyclotomicField CyclotomicPol CyclotomicPolynomial Cyclotomics CyclotomicsFamily DMYDay DMYhmsSeconds DTCommutator DTConjugate DTMultiply DTPower DTQuotient DTSolution DataObj DataType DayDMY DaysInMonth DaysInYear DeclareAttribute DeclareAttributeKernel DeclareAttributeSuppCT DeclareAutoPackage DeclareAutoreadableVariables DeclareCategory DeclareCategoryCollections DeclareCategoryFamily DeclareCategoryKernel DeclareComponent DeclareConstructor DeclareConstructorKernel DeclareFilter DeclareGlobalFunction DeclareGlobalVariable DeclareHandlingByNiceBasis DeclareInfoClass DeclareOperation DeclareOperationKernel DeclarePackage DeclarePackageAutoDocumentation DeclarePackageDocumentation DeclareProperty DeclarePropertyKernel DeclarePropertySuppCT DeclareRepresentation DeclareRepresentationKernel DeclareSynonym DeclareSynonymAttr DecodeTree DecodedTreeEntry DecomposeEltIntoPElts DecomposeTensorProduct DecomposedFixedPointVector DecomposedRationalClass Decomposition DecompositionInt DecompositionMatrix DecompositionTypes DecompositionTypesOfGroup Decreased DeepThoughtCollector DeepThoughtCollectorByGenerators DefaultField DefaultFieldByGenerators DefaultFieldOfMatrix DefaultFieldOfMatrixGroup DefaultHashLength DefaultPackageBannerString DefaultRing DefaultRingByGenerators DefaultSparseHashRepType DefaultSparseHashWithIKRepType DefaultStabChainOptions DefectApproximation DefineNewGenerators DefiningPcgs DefiningPolynomial DefiningQuotientHomomorphism Degree DegreeAction DegreeFFE DegreeIndeterminate DegreeNaturalHomomorphismsPool DegreeOfBinaryRelation DegreeOfCharacter DegreeOfLaurentPolynomial DegreeOfMatrixGroup DegreeOfTransformation DegreeOfTransformationSemigroup DegreeOfUnivariateLaurentPolynomial DegreeOperation DegreeOverPrimeField DeleteImage Delta DenominatorCyc DenominatorOfModuloPcgs DenominatorOfRationalFunction DenominatorRat DenseHashTable DenseIntKey DepthOfPcElement DepthOfUpperTriangularMatrix DepthSchreierTrees Derangements DerangementsK Derivations Derivative DerivedLength DerivedSeries DerivedSeriesOfGroup DerivedSubgroup DerivedSubgroupTom DerivedSubgroupsTom DerivedSubgroupsTomPossible DerivedSubgroupsTomUnique DescendingListWithElementRemoved DescriptionOfNormalizedUEAElement DescriptionOfRootOfUnity Determinant DeterminantIntMat DeterminantMat DeterminantMatDestructive DeterminantMatDivFree DeterminantOfCharacter DiagonalMat DiagonalOfMat DiagonalSocleAction DiagonalizeIntMat DiagonalizeIntMatNormDriven DiagonalizeMat DictionariesFamily DictionaryByList DictionaryByPosition DictionaryBySort DiffCoc Difference DifferenceBlist DifferenceLists DifferenceOfPcElement DigitsNumber DihedralGenerators DihedralGroup DihedralGroupCons Dimension DimensionOfHighestWeightModule DimensionOfMatrixGroup DimensionOfVectors DimensionsLoewyFactors DimensionsMat DirProdTransversal DirectFactorsOfGroup DirectProduct DirectProductDecompositionsLocal DirectProductInfo DirectProductOp DirectSumDecomposition DirectSumMat DirectSumOfAlgebraModules DirectSumOfAlgebras DirectoriesFamily DirectoriesLibrary DirectoriesPackageLibrary DirectoriesPackagePrograms DirectoriesSystemPrograms Directory DirectoryContents DirectoryCurrent DirectoryTemporary DirectoryType DisableAttributeValueStoring Discriminant Display DisplayCacheStats DisplayCompositionSeries DisplayEggBoxOfDClass DisplayImfInvariants DisplayImfReps DisplayInformationPerfectGroups DisplayOptions DisplayOptionsStack DisplayProfile DisplayRevision DisplaySemigroup DisplayXMLStructure DistVecClosVecLib DistanceVecFFE DistancesDistributionMatFFEVecFFE DistancesDistributionVecFFEsVecFFE DivisionRingByGenerators DivisorsInt DivisorsIntCache DixonInit DixonRecord DixonRepChi DixonRepGHchi DixonSplit DixontinI DnLattice DnLatticeIterative DoAlgebraicExt DoCentralSeriesPcgsIfNilpot DoCheapActionImages DoCheapOperationImages DoClosurePrmGp DoEASLS DoExponentsConjLayerFampcgs DoFactorCosetAction DoGaloisType DoImmutableMatrix DoInducedPcgsByPcSequenceNC DoLogModRho DoLowIndexSubgroupsFpGroup DoMulExt DoNFIM DoNormalClosurePermGroup DoNormalizerSA DoPcgsElementaryAbelianSeries DoPcgsOrbitOp DoPrintUnivariateLaurent DoReadPkg DoRereadPkg DoRightTransversalPc DoShortwordBasepoint DoSnAnGiantTest DoSparseActionHomomorphism DoSparseLinearActionOnFaithfulSubset DoTest DoUnivTestRatfun Domain DomainByGenerators DomainForAction DominantCharacter DominantWeights DoubleCentralizerOrbit DoubleCoset DoubleCosetRepsAndSizes DoubleCosets DoubleCosetsNC DoubleCosetsPcGroup DoubleHashArraySize DoubleHashDictSize DownEnv DualGModule DumpWorkspace DuplicateFreeList DxActiveCols DxCalcAllPowerMaps DxCalcPrimeClasses DxDegreeCandidates DxEigenbase DxFrobSchurInd DxGaloisOrbits DxGeneratePrimeCyclotomic DxIncludeIrreducibles DxIsInSpace DxLiftCharacter DxLinearCharacters DxModProduct DxModularValuePol DxNiceBasis DxPreparation DxRegisterModularChar DxSplitDegree EANormalSeriesByPcgs EAPrimeLayerSQ ERepAssWorInv ERepAssWorProd ERepLettWord Earns Edit EggBoxOfDClass EichlerTransformation Eigenspaces Eigenvalues EigenvaluesChar Eigenvectors ElementByRws ElementOfFpAlgebra ElementOfFpGroup ElementOfFpMonoid ElementOfFpSemigroup ElementOfMagmaRing ElementOrdersPowerMap ElementProperty ElementTestFunction ElementaryAbelianGroup ElementaryAbelianGroupCons ElementaryAbelianSeries ElementaryAbelianSeriesLargeSteps ElementaryAbelianSubseries ElementaryDivisorsMat ElementaryDivisorsMatDestructive Elements ElementsFamily ElementsStabChain EliminatedWord EliminationOrdering ElmDivRingElm ElmTimesRingElm ElmWPObj ElsymsPowersums Embedding EmptyBinaryRelation EmptyMatrix EmptyRBase EmptyRowVector EmptySCTable EmptyStabChain EmptyTuplesFamily EnableAttributeValueStoring End EndoMappingByTransformation EnumerateIndependentAbelianProducts Enumerator EnumeratorByBasis EnumeratorByFunctions EnumeratorByPcgs EnumeratorOfAdditiveMagma EnumeratorOfGroup EnumeratorOfIdeal EnumeratorOfMagma EnumeratorOfMagmaIdeal EnumeratorOfNormedRowVectors EnumeratorOfPrimeField EnumeratorOfRing EnumeratorOfSemigroupIdeal EnumeratorOfSubset EnumeratorOfTrivialAdditiveMagmaWithZero EnumeratorOfTrivialMagmaWithOne EnumeratorOfTuples EnumeratorOfZmodnZ EnumeratorSorted EnvelopingAlgebra EpiPcByModpcgs EpimorphismNilpotentQuotient EpimorphismNilpotentQuotientOp EpimorphismPGroup EpimorphismQuotientSystem EpimorphismSchurCover EqualBoxedObj EquivalenceClassOfElement EquivalenceClassOfElementNC EquivalenceClassRelation EquivalenceClasses EquivalenceRelationByPairs EquivalenceRelationByPairsNC EquivalenceRelationByPartition EquivalenceRelationByPartitionNC EquivalenceRelationByProperty EquivalenceRelationByRelation EquivalenceRelationPartition EquivalenceType Error ErrorCount EspaceBasePoints EuclideanDegree EuclideanQuotient EuclideanRemainder EulerianFunction EulerianFunctionByTom EvalF EvalFpCoc EvalStraightLineProgElm EvalString EvaluateConsistency EvaluateOverlapANA EvaluateOverlapBAN EvaluateOverlapBNA EvaluateOverlapCBA EvaluateRelation EvaluateRelators EvectBasePoints ExactSizeConsiderFunction ExcludeFromAutoload ExcludedOrders Exec ExecuteProcess ExpPcElmSortedFun Exponent ExponentOfPcElement ExponentOfPowering ExponentSumWord ExponentSums ExponentSyllable ExponentsConjugateLayer ExponentsOfCommutator ExponentsOfConjugate ExponentsOfPcElement ExponentsOfPcElementPermGroup ExponentsOfRelativePower ExportToKernelFinished ExtOrbStabDom ExtRepByTailVector ExtRepDenominatorRatFun ExtRepNumeratorRatFun ExtRepOfObj ExtRepPolynomialRatFun ExtendRepresentation ExtendSchreierTransversal ExtendSchreierTransversalShortCube ExtendSchreierTransversalShortTree ExtendSeriesPermGroup ExtendStabChain ExtendToBasis ExtendedGroup ExtendedIntersectionSumPcgs ExtendedPcgs ExtendedT ExtendedVectors Extension ExtensionNC ExtensionOnBlocks ExtensionRepresentatives ExtensionSQ Extensions ExtensionsOfModule ExteriorPower ExteriorPowerOfAlgebraModule ExternalOrbit ExternalOrbitOp ExternalOrbits ExternalOrbitsStabilizers ExternalSet ExternalSetByFilterConstructor ExternalSetByTypeConstructor ExternalSubset ExternalSubsetOp Extract ExtraspecialGroup ExtraspecialGroupCons FFEFamily FFPFactors FFPOrderKnownDividend FFPPowerModCheck FFPUpperBoundOrder FLMLORByGenerators FLMLORFromFFE FLMLORWithOne FLMLORWithOneByGenerators FMRRemoveZero FactorCosetAction FactorCosetOperation FactorFreeAlgebraByRelators FactorFreeGroupByRelators FactorFreeMonoidByRelations FactorFreeSemigroupByRelations FactorGroup FactorGroupFpGroupByRels FactorGroupNC FactorGroupNormalSubgroupClasses FactorGroupTom FactorSemigroup FactorSemigroupByClosure Factorial Factorization Factors FactorsCommonDegreePol FactorsInt FactorsOfDirectProduct FactorsRho FactorsSquarefree FaithfulModule FamElmEqFamRange FamElmEqFamSource FamMapFamSourceFamRange FamRangeEqFamElm FamRangeNotEqFamElm FamSourceEqFamElm FamSourceNotEqFamElm FamSourceRgtEqFamsLft FamiliesOfGeneralMappingsAndRanges FamiliesOfRows FamilyForOrdering FamilyForRewritingSystem FamilyObj FamilyOfFamilies FamilyOfTypes FamilyPcgs FamilyRange FamilySource FamilyType FastExtSQ Fibonacci FibonacciGroup Field FieldByGenerators FieldExtension FieldOfMatrixGroup FieldOfMatrixList FieldOverItselfByGenerators FileDescriptorOfStream FileString Filename FilterSGMLMarkup Filtered FilteredOp FinIndexCyclicSubgroupGenerator FindActionKernel FindBag FindLayer FindNewReps FindNormalCSPG FindOperationKernel FindRegularNormalCSPG FindWindowId Fingerprint FingerprintFF FingerprintLarge FingerprintMedium FingerprintPerm FingerprintSmall FiniteField First FirstOp FittingSubgroup FixcellPoint Fixcells FixcellsCell FixedPointSpace FixpointCellNo FlagsFamily FlagsObj FlagsType Flat FlatBlockMat FlatHashParams FloatsFamily FlushCaches ForAll ForAllOp ForAny ForAnyOp FormatParagraph FormattedString FpAlgebraByGeneralizedCartanMatrix FpElmComparisonMethod FpElmEqualityMethod FpElmKBRWS FpGroupPcGroupSQ FpGroupPresentation FpGrpMonSmgOfFpGrpMonSmgElement FpLieAlgebraByCartanMatrix FpLieAlgebraEnumeration FpMonoidOfElementOfFpMonoid FpOfModules FpSemigroupOfElementOfFpSemigroup FptoSCAMorphismImageElm FrattiniSubgroup FrattinifactorId FrattinifactorSize FreeAlgebra FreeAlgebraConstructor FreeAlgebraOfFpAlgebra FreeAlgebraWithOne FreeAssociativeAlgebra FreeAssociativeAlgebraWithOne FreeGeneratorsOfFpAlgebra FreeGeneratorsOfFpGroup FreeGeneratorsOfFpMonoid FreeGeneratorsOfFpSemigroup FreeGeneratorsOfWholeGroup FreeGroup FreeGroupOfBasicImageGroup FreeGroupOfElt FreeGroupOfFpGroup FreeLeftModule FreeLieAlgebra FreeMagma FreeMagmaRing FreeMagmaWithOne FreeMonoid FreeMonoidNatHomByGeneratorsNC FreeMonoidOfFpMonoid FreeMonoidOfRewritingSystem FreeSemigroup FreeSemigroupNatHomByGeneratorsNC FreeSemigroupOfFpSemigroup FreeSemigroupOfRewritingSystem FreeStructureOfRewritingSystem FrobeniusAutomorphism FrobeniusAutomorphismI FrobeniusCharacterValue FullMatrixAlgebra FullMatrixAlgebraCentralizer FullMatrixFLMLOR FullMatrixLieAlgebra FullMatrixLieFLMLOR FullMatrixModule FullMatrixSpace FullRowModule FullRowSpace FullSparseRowSpace FullTransformationSemigroup FunctionAction FunctionsFamily FusionCharTableTom FusionConjugacyClasses FusionConjugacyClassesOp FusionRationalClassesPSubgroup FusionsAllowedByRestrictions FusionsOfLibTom FusionsToLibTom FusionsTom GAPDocManualLab GAPInfo GInverses GLDegree GLUnderlyingField GModuleByMats GPartitions GPartitionsEasy GPartitionsGreatestEQ GPartitionsGreatestEQHelper GPartitionsGreatestLE GPartitionsGreatestLEEasy GPartitionsNrParts GPartitionsNrPartsHelper GQuotients GaloisConjugates GaloisCyc GaloisDiffResolvent GaloisField GaloisGroup GaloisMat GaloisSetResolvent GaloisStabilizer GaloisType GapInputPcGroup GapInputSCTable GasmanLimits GasmanMessageStatus GasmanStatistics GaussianIntegers GaussianRationals Gcd GcdCoeffs GcdInt GcdOp GcdRepresentation GcdRepresentationOp Gcdex GeneralLinearGroup GeneralLinearGroupCons GeneralMappingByElements GeneralMappingsFamily GeneralOrthogonalGroup GeneralOrthogonalGroupCons GeneralStepClEANS GeneralStepClEANSNonsolv GeneralUnitaryGroup GeneralUnitaryGroupCons GeneralisedEigenspaces GeneralisedEigenvalues GeneralizedEigenspaces GeneralizedEigenvalues GeneralizedPcgs GeneratingPairsOfLeftMagmaCongruence GeneratingPairsOfMagmaCongruence GeneratingPairsOfRightMagmaCongruence GeneratingPairsOfSemigroupCongruence GeneratingSetIsComplete GeneratorNumberOfQuotient GeneratorOfCyclicGroup GeneratorSyllable GeneratorTranslationAugmentedCosetTable GeneratorsCenterPGroup GeneratorsCentrePGroup GeneratorsListTom GeneratorsOfAdditiveGroup GeneratorsOfAdditiveMagma GeneratorsOfAdditiveMagmaWithInverses GeneratorsOfAdditiveMagmaWithZero GeneratorsOfAlgebra GeneratorsOfAlgebraModule GeneratorsOfAlgebraWithOne GeneratorsOfDivisionRing GeneratorsOfDomain GeneratorsOfEquivalenceRelationPartition GeneratorsOfExtASet GeneratorsOfExtLSet GeneratorsOfExtRSet GeneratorsOfExtUSet GeneratorsOfFLMLOR GeneratorsOfFLMLORWithOne GeneratorsOfField GeneratorsOfGroup GeneratorsOfIdeal GeneratorsOfLayer GeneratorsOfLeftIdeal GeneratorsOfLeftMagmaIdeal GeneratorsOfLeftModule GeneratorsOfLeftOperatorAdditiveGroup GeneratorsOfLeftOperatorRing GeneratorsOfLeftOperatorRingWithOne GeneratorsOfLeftVectorSpace GeneratorsOfMagma GeneratorsOfMagmaIdeal GeneratorsOfMagmaWithInverses GeneratorsOfMagmaWithOne GeneratorsOfMonoid GeneratorsOfNearAdditiveGroup GeneratorsOfNearAdditiveMagma GeneratorsOfNearAdditiveMagmaWithInverses GeneratorsOfNearAdditiveMagmaWithZero GeneratorsOfPresentation GeneratorsOfRightIdeal GeneratorsOfRightMagmaIdeal GeneratorsOfRightModule GeneratorsOfRightOperatorAdditiveGroup GeneratorsOfRing GeneratorsOfRingForIdeal GeneratorsOfRingWithOne GeneratorsOfRws GeneratorsOfSemigroup GeneratorsOfSemiring GeneratorsOfSemiringWithOne GeneratorsOfSemiringWithOneAndZero GeneratorsOfSemiringWithZero GeneratorsOfTwoSidedIdeal GeneratorsOfVectorSpace GeneratorsOverIntersection GeneratorsPrimeResidues GeneratorsSmallest GeneratorsSmallestStab GeneratorsSubgroupsTom GenericFindActionKernel GetChars GetCommutatorNC GetConjugateNC GetDefinitionNC GetETag GetElement GetEnt GetFusionMap GetHashEntry GetHashEntryAtLastIndex GetHashEntryIndex GetMax GetNaturalHomomorphismsPool GetNumRight GetPols GetPowerNC GetSTag GetWord GiveNumbersNIndeterminates GlasbyCover GlasbyIntersection GlasbyShift GlasbyStabilizer GlobalPartitionOfClasses Grading GreensDClassOfElement GreensDClasses GreensDRelation GreensHClassOfElement GreensHClasses GreensHRelation GreensJClassOfElement GreensJClasses GreensJRelation GreensLClassOfElement GreensLClasses GreensLRelation GreensRClassOfElement GreensRClasses GreensRRelation GroebnerBasis GroebnerBasisNC Group GroupByGenerators GroupByMultiplicationTable GroupByNiceMonomorphism GroupByPcgs GroupByPrimeResidues GroupByQuotientSystem GroupByRws GroupByRwsNC GroupFromAdditiveGroup GroupGeneralMappingByImages GroupHClassOfGreensDClass GroupHomomorphismByFunction GroupHomomorphismByImages GroupHomomorphismByImagesNC GroupMethodByNiceMonomorphism GroupMethodByNiceMonomorphismCollColl GroupMethodByNiceMonomorphismCollElm GroupMethodByNiceMonomorphismCollOther GroupOfPcgs GroupOnSubgroupsOrbit GroupRing GroupSeriesMethodByNiceMonomorphism GroupSeriesMethodByNiceMonomorphismCollColl GroupSeriesMethodByNiceMonomorphismCollElm GroupSeriesMethodByNiceMonomorphismCollOther GroupStabChain GroupString GroupToAdditiveGroupHomomorphismByFunction GroupWithGenerators HMSMSec HallSubgroup HallSubgroupOp HallSystem HasANonReesCongruenceOfSemigroup HasAbelianFactorGroup HasAbelianInvariants HasAbelianInvariantsOfList HasAbsoluteValue HasActingDomain HasActionHomomorphismAttr HasActionKernelExternalSet HasActorOfExternalSet HasAdditiveElementAsMultiplicativeElement HasAdditiveElementsAsMultiplicativeElementsFamily HasAdditiveInverse HasAdditiveInverseAttr HasAdditiveInverseImmutable HasAdditiveNeutralElement HasAdditivelyActingDomain HasAdjointBasis HasAdjointModule HasAlgebraicElementsFamilies HasAllBlocks HasAlpha HasAlternatingDegree HasAlternatingSubgroup HasAsDuplicateFreeList HasAsGroup HasAsGroupGeneralMappingByImages HasAsLeftModuleGeneralMappingByImages HasAsList HasAsMagma HasAsMonoid HasAsNearRing HasAsPolynomial HasAsRing HasAsSSortedList HasAsSemigroup HasAsSemiring HasAsSemiringWithOne HasAsSemiringWithOneAndZero HasAsSemiringWithZero HasAsSortedList HasAsSubgroupOfWholeGroupByQuotient HasAssociatedReesMatrixSemigroupOfDClass HasAssociatedSemigroup HasAugmentationIdeal HasAugmentedCosetTableMtcInWholeGroup HasAugmentedCosetTableNormalClosureInWholeGroup HasAugmentedCosetTableRrsInWholeGroup HasAutomorphismDomain HasAutomorphismGroup HasAutomorphismsOfTable HasBaseIntMat HasBaseMat HasBaseOfBasicImageGroup HasBaseOfGroup HasBaseOrthogonalSpaceMat HasBasis HasBasisOfHomCosetAddMatrixGroup HasBasisVectors HasBaumClausenInfo HasBilinearFormMat HasBlocksAttr HasBlocksInfo HasBrauerCharacterValue HasBravaisGroup HasBravaisSubgroups HasBravaisSupergroups HasCanEasilyCompareElements HasCanEasilySortElements HasCanFindNilpotentClassTwoElement HasCanonicalBasis HasCanonicalElt HasCanonicalGenerators HasCanonicalNiceMonomorphism HasCanonicalPcgs HasCanonicalPcgsWrtFamilyPcgs HasCanonicalPcgsWrtHomePcgs HasCanonicalPcgsWrtSpecialPcgs HasCanonicalRepresentativeDeterminatorOfExternalSet HasCanonicalRepresentativeOfExternalSet HasCartanMatrix HasCartanSubalgebra HasCayleyGraphDualSemigroup HasCayleyGraphSemigroup HasCenter HasCentralCharacter HasCentralIdempotentsOfSemiring HasCentralNormalSeriesByPcgs HasCentralizerInGLnZ HasCentralizerInParent HasCentre HasCentreOfCharacter HasChainHomomorphicImage HasChainSubgroup HasChainSubgroupQuotient HasCharacterDegrees HasCharacterNames HasCharacterParameters HasCharacteristic HasCharacteristicPolynomial HasChevalleyBasis HasChiefNormalSeriesByPcgs HasChiefSeries HasClassNames HasClassNamesTom HasClassParameters HasClassPermutation HasClassPositionsOfCentre HasClassPositionsOfDerivedSubgroup HasClassPositionsOfDirectProductDecompositions HasClassPositionsOfElementaryAbelianSeries HasClassPositionsOfFittingSubgroup HasClassPositionsOfKernel HasClassPositionsOfLowerCentralSeries HasClassPositionsOfMaximalNormalSubgroups HasClassPositionsOfNormalSubgroups HasClassPositionsOfSolvableResiduum HasClassPositionsOfSupersolvableResiduum HasClassPositionsOfUpperCentralSeries HasClassRoots HasClassTypesTom HasCoKernelOfAdditiveGeneralMapping HasCoKernelOfMultiplicativeGeneralMapping HasCoefficientsAndMagmaElements HasCoefficientsFamily HasCoefficientsOfLaurentPolynomial HasCoefficientsOfUnivariatePolynomial HasCoefficientsOfUnivariateRationalFunction HasCoefficientsRing HasCollectionsFamily HasColumnIndexOfReesMatrixSemigroupElement HasColumnIndexOfReesZeroMatrixSemigroupElement HasColumnsOfReesMatrixSemigroup HasColumnsOfReesZeroMatrixSemigroup HasCommutatorFactorGroup HasCommutatorLength HasComplementSystem HasComplexConjugate HasComponentsOfTuplesFamily HasCompositionSeries HasComputedAgemos HasComputedAscendingChains HasComputedBrauerTables HasComputedClassFusions HasComputedCyclicExtensionsTom HasComputedHallSubgroups HasComputedIndicators HasComputedIsPNilpotents HasComputedIsPSolvableCharacterTables HasComputedIsPSolvables HasComputedOmegas HasComputedPCentralSeriess HasComputedPCores HasComputedPRumps HasComputedPowerMaps HasComputedPrimeBlockss HasComputedSylowComplements HasComputedSylowSubgroups HasConductor HasConfluentRws HasConjugacyClasses HasConjugacyClassesMaximalSubgroups HasConjugacyClassesPerfectSubgroups HasConjugacyClassesSubgroups HasConjugates HasConjugatorInnerAutomorphism HasConjugatorOfConjugatorIsomorphism HasConstantTimeAccessList HasConstituentsOfCharacter HasConvertBasicImageGroupElement HasCoreInParent HasCosetTableFpHom HasCosetTableInWholeGroup HasCosetTableNormalClosureInWholeGroup HasCosetTableOfFpSemigroup HasCycleStructurePerm HasCyclicExtensionsTom HasDecompositionMatrix HasDecompositionTypesOfGroup HasDefaultFieldOfMatrix HasDefaultFieldOfMatrixGroup HasDefectApproximation HasDefiningPcgs HasDefiningPolynomial HasDegreeAction HasDegreeOfBinaryRelation HasDegreeOfCharacter HasDegreeOfLaurentPolynomial HasDegreeOfMatrixGroup HasDegreeOfTransformation HasDegreeOfTransformationSemigroup HasDegreeOperation HasDegreeOverPrimeField HasDelta HasDenominatorOfModuloPcgs HasDenominatorOfRationalFunction HasDepthOfUpperTriangularMatrix HasDerivations HasDerivative HasDerivedLength HasDerivedSeriesOfGroup HasDerivedSubgroup HasDerivedSubgroupsTomPossible HasDerivedSubgroupsTomUnique HasDeterminantMat HasDeterminantOfCharacter HasDihedralGenerators HasDimension HasDimensionOfMatrixGroup HasDimensionOfVectors HasDimensionsLoewyFactors HasDimensionsMat HasDirectFactorsOfGroup HasDirectProductInfo HasDirectSumDecomposition HasDisplayOptions HasDixonRecord HasEANormalSeriesByPcgs HasEarns HasEggBoxOfDClass HasElementTestFunction HasElementaryAbelianFactorGroup HasElementaryAbelianSeries HasElementaryAbelianSeriesLargeSteps HasElementaryAbelianSubseries HasElementsFamily HasEmptyRowVector HasEnumerator HasEnumeratorByBasis HasEnumeratorSorted HasEquivalenceClassRelation HasEquivalenceClasses HasEquivalenceRelationPartition HasExponent HasExponentOfPowering HasExtRepDenominatorRatFun HasExtRepNumeratorRatFun HasExtRepPolynomialRatFun HasExternalOrbits HasExternalOrbitsStabilizers HasExternalSet HasFactorsOfDirectProduct HasFaithfulModule HasFamiliesOfGeneralMappingsAndRanges HasFamilyForOrdering HasFamilyForRewritingSystem HasFamilyPcgs HasFamilyRange HasFamilySource HasFieldOfMatrixGroup HasFittingSubgroup HasFpElmComparisonMethod HasFpElmEqualityMethod HasFpElmKBRWS HasFrattiniSubgroup HasFrattinifactorId HasFrattinifactorSize HasFreeAlgebraOfFpAlgebra HasFreeGeneratorsOfFpAlgebra HasFreeGeneratorsOfFpGroup HasFreeGeneratorsOfFpMonoid HasFreeGeneratorsOfFpSemigroup HasFreeGroupOfBasicImageGroup HasFreeGroupOfFpGroup HasFreeMonoidOfFpMonoid HasFreeMonoidOfRewritingSystem HasFreeSemigroupOfFpSemigroup HasFreeSemigroupOfRewritingSystem HasFrobeniusAutomorphism HasFunctionAction HasFusionConjugacyClassesOp HasFusionsOfLibTom HasFusionsToLibTom HasFusionsTom HasGLDegree HasGLUnderlyingField HasGaloisGroup HasGaloisMat HasGaloisStabilizer HasGaloisType HasGeneralizedPcgs HasGeneratingPairsOfLeftMagmaCongruence HasGeneratingPairsOfMagmaCongruence HasGeneratingPairsOfRightMagmaCongruence HasGeneratingSetIsComplete HasGeneratorOfCyclicGroup HasGeneratorsOfAdditiveGroup HasGeneratorsOfAdditiveMagma HasGeneratorsOfAdditiveMagmaWithInverses HasGeneratorsOfAdditiveMagmaWithZero HasGeneratorsOfAlgebra HasGeneratorsOfAlgebraModule HasGeneratorsOfAlgebraWithOne HasGeneratorsOfDivisionRing HasGeneratorsOfDomain HasGeneratorsOfEquivalenceRelationPartition HasGeneratorsOfExtASet HasGeneratorsOfExtLSet HasGeneratorsOfExtRSet HasGeneratorsOfExtUSet HasGeneratorsOfFLMLOR HasGeneratorsOfFLMLORWithOne HasGeneratorsOfField HasGeneratorsOfGroup HasGeneratorsOfIdeal HasGeneratorsOfLeftIdeal HasGeneratorsOfLeftMagmaIdeal HasGeneratorsOfLeftModule HasGeneratorsOfLeftOperatorAdditiveGroup HasGeneratorsOfLeftOperatorRing HasGeneratorsOfLeftOperatorRingWithOne HasGeneratorsOfLeftVectorSpace HasGeneratorsOfMagma HasGeneratorsOfMagmaIdeal HasGeneratorsOfMagmaWithInverses HasGeneratorsOfMagmaWithOne HasGeneratorsOfMonoid HasGeneratorsOfNearAdditiveGroup HasGeneratorsOfNearAdditiveMagma HasGeneratorsOfNearAdditiveMagmaWithInverses HasGeneratorsOfNearAdditiveMagmaWithZero HasGeneratorsOfRightIdeal HasGeneratorsOfRightMagmaIdeal HasGeneratorsOfRightModule HasGeneratorsOfRightOperatorAdditiveGroup HasGeneratorsOfRing HasGeneratorsOfRingWithOne HasGeneratorsOfRws HasGeneratorsOfSemigroup HasGeneratorsOfSemiring HasGeneratorsOfSemiringWithOne HasGeneratorsOfSemiringWithOneAndZero HasGeneratorsOfSemiringWithZero HasGeneratorsOfTwoSidedIdeal HasGeneratorsOfVectorSpace HasGeneratorsSmallest HasGeneratorsSubgroupsTom HasGlobalPartitionOfClasses HasGrading HasGreensDRelation HasGreensHRelation HasGreensJRelation HasGreensLRelation HasGreensRRelation HasGroupByPcgs HasGroupHClassOfGreensDClass HasGroupOfPcgs HasHallSystem HasHirschLength HasHomCosetFamily HasHomFromFreeOfBasicImageGroup HasHomeEnumerator HasHomePcgs HasIBr HasIdGroup HasIdempotents HasIdempotentsTom HasIdempotentsTomInfo HasIdentificationOfConjugacyClasses HasIdentifier HasIdentity HasIdentityMapping HasImageElt HasImageListOfTransformation HasImageSetOfTransformation HasImagesSmallestGenerators HasImagesSource HasImfRecord HasIndependentGeneratorsOfAbelianGroup HasIndependentGeneratorsOfAbelianMatrixGroup HasIndeterminateName HasIndeterminateNumberOfLaurentPolynomial HasIndeterminateNumberOfUnivariateLaurentPolynomial HasIndeterminateNumberOfUnivariateRationalFunction HasIndeterminateOfUnivariateRationalFunction HasIndeterminatesOfPolynomialRing HasIndexInParent HasIndexInWholeGroup HasIndicesCentralNormalSteps HasIndicesChiefNormalSteps HasIndicesEANormalSteps HasIndicesInvolutaryGenerators HasIndicesNormalSteps HasIndicesOfAdjointBasis HasIndicesPCentralNormalStepsPGroup HasInducedPcgsWrtFamilyPcgs HasInducedPcgsWrtHomePcgs HasInducedPcgsWrtSpecialPcgs HasInfoText HasInjectionZeroMagma HasInnerAutomorphismsAutomorphismGroup HasInt HasInternalRepresentative HasInvariantBilinearForm HasInvariantConjugateSubgroup HasInvariantForm HasInvariantLattice HasInvariantQuadraticForm HasInvariantSesquilinearForm HasInverse HasInverseAttr HasInverseClasses HasInverseGeneralMapping HasInverseImmutable HasIrr HasIrrBaumClausen HasIrrConlon HasIrrDixonSchneider HasIrrFacsPol HasIrreducibleRepresentations HasIsAbelian HasIsAbelianNumberField HasIsAbelianTom HasIsAdditiveGroupGeneralMapping HasIsAdditiveGroupHomomorphism HasIsAdditiveGroupToGroupGeneralMapping HasIsAdditiveGroupToGroupHomomorphism HasIsAdditivelyCommutative HasIsAlgebraGeneralMapping HasIsAlgebraHomomorphism HasIsAlgebraModule HasIsAlgebraWithOneGeneralMapping HasIsAlgebraWithOneHomomorphism HasIsAlternatingGroup HasIsAnticommutative HasIsAntisymmetricBinaryRelation HasIsAssociative HasIsAutomorphismGroup HasIsBasicWreathProductOrdering HasIsBergerCondition HasIsBijective HasIsBravaisGroup HasIsBuiltFromAdditiveMagmaWithInverses HasIsBuiltFromGroup HasIsBuiltFromMagma HasIsBuiltFromMagmaWithInverses HasIsBuiltFromMagmaWithOne HasIsBuiltFromMonoid HasIsBuiltFromSemigroup HasIsCanonicalBasis HasIsCanonicalBasisFullMatrixModule HasIsCanonicalBasisFullRowModule HasIsCanonicalBasisFullSCAlgebra HasIsCanonicalNiceMonomorphism HasIsCanonicalPcgs HasIsCanonicalPcgsWrtSpecialPcgs HasIsChainTypeGroup HasIsCharacter HasIsCharacteristicMatrixPGroup HasIsCommutative HasIsCommutativeFamily HasIsConfluent HasIsConjugatorAutomorphism HasIsConjugatorIsomorphism HasIsConstantRationalFunction HasIsConstantTimeAccessGeneralMapping HasIsCycInt HasIsCyclic HasIsCyclicTom HasIsCyclotomicField HasIsDihedralGroup HasIsDistributive HasIsDivisionRing HasIsDuplicateFree HasIsDuplicateFreeList HasIsElementaryAbelian HasIsEmpty HasIsEndoGeneralMapping HasIsEndoMapping HasIsEquivalenceRelation HasIsFFEMatrixGroupOverLargeSpace HasIsFamilyPcgs HasIsField HasIsFieldHomomorphism HasIsFinite HasIsFiniteDimensional HasIsFiniteOrdersPcgs HasIsFiniteSemigroupGreensRelation HasIsFinitelyGeneratedGroup HasIsFrattiniFree HasIsFreeMonoid HasIsFreeSemigroup HasIsFullFpAlgebra HasIsFullHomModule HasIsFullMatrixModule HasIsFullRowModule HasIsFullSCAlgebra HasIsFullSubgroupGLorSLRespectingBilinearForm HasIsFullSubgroupGLorSLRespectingQuadraticForm HasIsFullSubgroupGLorSLRespectingSesquilinearForm HasIsFullTransformationSemigroup HasIsGL HasIsGeneralLinearGroup HasIsGeneralizedCartanMatrix HasIsGeneratorsOfMagmaWithInverses HasIsGreensClass HasIsGreensDClass HasIsGreensDRelation HasIsGreensHClass HasIsGreensHRelation HasIsGreensJClass HasIsGreensJRelation HasIsGreensLClass HasIsGreensLRelation HasIsGreensRClass HasIsGreensRRelation HasIsGreensRelation HasIsGroupGeneralMapping HasIsGroupHClass HasIsGroupHomomorphism HasIsGroupOfAutomorphisms HasIsGroupOfAutomorphismsFiniteGroup HasIsGroupRing HasIsGroupToAdditiveGroupGeneralMapping HasIsGroupToAdditiveGroupHomomorphism HasIsHandledByNiceMonomorphism HasIsHasseDiagram HasIsHomCosetOfAdditiveElt HasIsHomCosetOfFp HasIsHomCosetOfMatrix HasIsHomCosetOfPerm HasIsHomCosetOfTuple HasIsIdealInParent HasIsIdempotent HasIsImpossible HasIsInducedFromNormalSubgroup HasIsInducedPcgsWrtSpecialPcgs HasIsInjective HasIsInnerAutomorphism HasIsIntegerMatrixGroup HasIsIntegralBasis HasIsIntegralCyclotomic HasIsIntegralRing HasIsIrreducibleCharacter HasIsJacobianRing HasIsLDistributive HasIsLatticeOrderBinaryRelation HasIsLaurentPolynomial HasIsLeftActedOnByDivisionRing HasIsLeftAlgebraModule HasIsLeftIdealInParent HasIsLeftModuleGeneralMapping HasIsLeftModuleHomomorphism HasIsLeftSemigroupCongruence HasIsLeftSemigroupIdeal HasIsLieAbelian HasIsLieAlgebra HasIsLieNilpotent HasIsLieSolvable HasIsLinearlyPrimitive HasIsMagmaHomomorphism HasIsMapping HasIsMatrixModule HasIsMinimalNonmonomial HasIsMonoid HasIsMonomialCharacter HasIsMonomialCharacterTable HasIsMonomialGroup HasIsMonomialMatrix HasIsMonomialNumber HasIsNaturalAlternatingGroup HasIsNaturalGL HasIsNaturalSL HasIsNaturalSymmetricGroup HasIsNearRing HasIsNearRingWithOne HasIsNilpQuotientSystem HasIsNilpotentCharacterTable HasIsNilpotentGroup HasIsNilpotentTom HasIsNonTrivial HasIsNoncharacteristicMatrixPGroup HasIsNormalBasis HasIsNormalForm HasIsNormalInParent HasIsNumberField HasIsNumeratorParentPcgsFamilyPcgs HasIsOne HasIsOrderingOnFamilyOfAssocWords HasIsPGroup HasIsPQuotientSystem HasIsPSL HasIsParentPcgsFamilyPcgs HasIsPartialOrderBinaryRelation HasIsPcgsCentralSeries HasIsPcgsChiefSeries HasIsPcgsElementaryAbelianSeries HasIsPcgsPCentralSeriesPGroup HasIsPerfectCharacterTable HasIsPerfectGroup HasIsPerfectTom HasIsPolycyclicGroup HasIsPolynomial HasIsPositionsList HasIsPreOrderBinaryRelation HasIsPrimeField HasIsPrimeOrdersPcgs HasIsPrimitive HasIsPrimitiveAffine HasIsPrimitiveCharacter HasIsPrimitiveMatrixGroup HasIsPseudoCanonicalBasisFullHomModule HasIsQuasiDihedralGroup HasIsQuasiPrimitive HasIsQuaternionGroup HasIsRDistributive HasIsRationalMatrixGroup HasIsRectangularTable HasIsReduced HasIsReesCongruence HasIsReesCongruenceSemigroup HasIsReesMatrixSemigroup HasIsReesZeroMatrixSemigroup HasIsReflexiveBinaryRelation HasIsRegular HasIsRegularDClass HasIsRegularSemigroup HasIsRelativelySM HasIsRestrictedLieAlgebra HasIsRightAlgebraModule HasIsRightIdealInParent HasIsRightSemigroupCongruence HasIsRightSemigroupIdeal HasIsRing HasIsRingGeneralMapping HasIsRingHomomorphism HasIsRingWithOne HasIsRingWithOneGeneralMapping HasIsRingWithOneHomomorphism HasIsRowModule HasIsSL HasIsSSortedList HasIsSemiEchelonized HasIsSemiRegular HasIsSemigroup HasIsSemigroupCongruence HasIsSemigroupIdeal HasIsSemiring HasIsSemiringWithOne HasIsSemiringWithOneAndZero HasIsSemiringWithZero HasIsShortLexOrdering HasIsSimpleAlgebra HasIsSimpleCharacterTable HasIsSimpleGroup HasIsSimpleSemigroup HasIsSingleValued HasIsSkewFieldFamily HasIsSmallList HasIsSolvableCharacterTable HasIsSolvableGroup HasIsSolvableTom HasIsSortedList HasIsSpecialLinearGroup HasIsSpecialPcgs HasIsSporadicSimpleCharacterTable HasIsSporadicSimpleGroup HasIsStabChainViaChainSubgroup HasIsSubgroupSL HasIsSubmonoidFpMonoid HasIsSubnormallyMonomial HasIsSubsemigroupFpSemigroup HasIsSubsemigroupReesMatrixSemigroup HasIsSubsemigroupReesZeroMatrixSemigroup HasIsSubsetLocallyFiniteGroup HasIsSupersolvableCharacterTable HasIsSupersolvableGroup HasIsSurjective HasIsSymmetricBinaryRelation HasIsSymmetricGroup HasIsTotal HasIsTotalOrdering HasIsTransformationMonoid HasIsTransformationSemigroup HasIsTransitive HasIsTransitiveBinaryRelation HasIsTranslationInvariantOrdering HasIsTrivial HasIsTwoSidedIdealInParent HasIsUFDFamily HasIsUniformMatrixGroup HasIsUnivariatePolynomial HasIsUnivariateRationalFunction HasIsVectorSpaceHomomorphism HasIsVirtualCharacter HasIsWeightLexOrdering HasIsWellFoundedOrdering HasIsWeylGroup HasIsWholeFamily HasIsWreathProductOrdering HasIsZero HasIsZeroGroup HasIsZeroMultiplicationRing HasIsZeroRationalFunction HasIsZeroSimpleSemigroup HasIsZeroSquaredRing HasIsomorphismFpAlgebra HasIsomorphismFpFLMLOR HasIsomorphismFpGroup HasIsomorphismFpMonoid HasIsomorphismFpSemigroup HasIsomorphismMatrixAlgebra HasIsomorphismMatrixFLMLOR HasIsomorphismPcGroup HasIsomorphismPermGroup HasIsomorphismReesMatrixSemigroup HasIsomorphismRefinedPcGroup HasIsomorphismSCAlgebra HasIsomorphismSCFLMLOR HasIsomorphismSimplifiedFpGroup HasIsomorphismSpecialPcGroup HasIsomorphismTransformationSemigroup HasJenningsLieAlgebra HasJenningsSeries HasJordanDecomposition HasKernelOfAdditiveGeneralMapping HasKernelOfCharacter HasKernelOfMultiplicativeGeneralMapping HasKernelOfTransformation HasKillingMatrix HasKnowsHowToDecompose HasLClassOfHClass HasLGFirst HasLGHeads HasLGLayers HasLGLength HasLGTails HasLGWeights HasLargestElementGroup HasLargestMovedPoint HasLargestMovedPointPerm HasLatticeGeneratorsInUEA HasLatticeSubgroups HasLeadCoeffsIGS HasLeftActingAlgebra HasLeftActingDomain HasLeftActingGroup HasLeftActingRingOfIdeal HasLeftDerivations HasLength HasLengthsTom HasLessThanFunction HasLessThanOrEqualFunction HasLetterRepWordsLessFunc HasLevelsOfGenerators HasLeviMalcevDecomposition HasLieAlgebraByDomain HasLieCenter HasLieCentralizerInParent HasLieCentre HasLieDerivedSeries HasLieDerivedSubalgebra HasLieFamily HasLieLowerCentralSeries HasLieNilRadical HasLieNormalizerInParent HasLieObject HasLieSolvableRadical HasLieUpperCentralSeries HasLinearActionBasis HasLinearCharacters HasLinesOfStraightLineProgram HasLongestWeylWordPerm HasLowerCentralSeriesOfGroup HasMagmaGeneratorsOfFamily HasMappingGeneratorsImages HasMappingOfWhichItIsAsGGMBI HasMarksTom HasMatTom HasMatrixByBlockMatrix HasMatrixDimension HasMaximalAbelianQuotient HasMaximalBlocksAttr HasMaximalNormalSubgroups HasMaximalSubgroupClassReps HasMaximalSubgroups HasMaximalSubgroupsLattice HasMaximalSubgroupsTom HasMinimalBlockDimension HasMinimalGeneratingSet HasMinimalNormalSubgroups HasMinimalStabChain HasMinimalSupergroupsLattice HasMinimizedBombieriNorm HasModuleOfExtension HasModulusOfZmodnZObj HasMoebiusTom HasMolienSeriesInfo HasMonoidOfRewritingSystem HasMonomialComparisonFunction HasMonomialExtrepComparisonFun HasMovedPoints HasMultiplicationTable HasMultiplicativeNeutralElement HasMultiplicativeZero HasName HasNameIsomorphismClass HasNamesLibTom HasNamesOfFusionSources HasNaturalCharacter HasNaturalHomomorphismByNormalSubgroupNCInParent HasNaturalHomomorphismsPool HasNegativeRootVectors HasNegativeRoots HasNestingDepthA HasNestingDepthM HasNiceAlgebraMonomorphism HasNiceBasis HasNiceFreeLeftModule HasNiceFreeLeftModuleInfo HasNiceMonomorphism HasNiceNormalFormByExtRepFunction HasNiceObject HasNilpotencyClassOfGroup HasNilpotentClassTwoElement HasNonLieNilpotentElement HasNonNilpotentElement HasNorm HasNormalBase HasNormalClosureInParent HasNormalMaximalSubgroups HasNormalSeriesByPcgs HasNormalSubgroupClassesInfo HasNormalSubgroups HasNormalizerInGLnZ HasNormalizerInGLnZBravaisGroup HasNormalizerInHomePcgs HasNormalizerInParent HasNormalizersTom HasNormedRowVector HasNormedRowVectors HasNormedVectors HasNotifiedFusionsOfLibTom HasNotifiedFusionsToLibTom HasNrConjugacyClasses HasNrInputsOfStraightLineProgram HasNrMovedPoints HasNrMovedPointsPerm HasNrSubsTom HasNrSyllables HasNullAlgebra HasNullspaceIntMat HasNullspaceMat HasNumberGeneratorsOfRws HasNumberSyllables HasNumeratorOfModuloPcgs HasNumeratorOfRationalFunction HasONanScottType HasOccuringVariableIndices HasOmegaAndLowerPCentralSeries HasOmegaSeries HasOne HasOneAttr HasOneImmutable HasOneOfPcgs HasOperatorOfExternalSet HasOrbitGeneratorsOfGroup HasOrbitLengths HasOrbitLengthsDomain HasOrbitStabilizingParentGroup HasOrbits HasOrbitsDomain HasOrder HasOrderingOfRewritingSystem HasOrderingOnGenerators HasOrderingsFamily HasOrdersClassRepresentatives HasOrdersTom HasOrdinaryCharacterTable HasOrthogonalSpaceInFullRowSpace HasPCentralLieAlgebra HasPCentralNormalSeriesByPcgsPGroup HasPClassPGroup HasPSLDegree HasPSLUnderlyingField HasParent HasParentAttr HasParentPcgs HasPartialClosureOfCongruence HasPartialOrderOfHasseDiagram HasPcGroupWithPcgs HasPcSeries HasPcgs HasPcgsCentralSeries HasPcgsChiefSeries HasPcgsElementaryAbelianSeries HasPcgsPCentralSeriesPGroup HasPerfectIdentification HasPerfectResiduum HasPermutationTom HasPositiveRootVectors HasPositiveRoots HasPositiveRootsAsWeights HasPowerS HasPowerSubalgebraSeries HasPreBasis HasPreImagesRange HasPreferredGenerators HasPrefrattiniSubgroup HasPresentation HasPrimaryGeneratorWords HasPrimeField HasPrimePGroup HasPrimePowerComponents HasPrimitiveElement HasPrimitiveIdentification HasPrimitiveRoot HasProjectiveOrder HasPseudoRandomSeed HasPthPowerImages HasQuasiDihedralGenerators HasQuaternionGenerators HasQuotientGroup HasQuotientGroupHom HasQuotientSemigroupCongruence HasQuotientSemigroupHomomorphism HasQuotientSemigroupPreimage HasRClassOfHClass HasRadicalGroup HasRadicalOfAlgebra HasRange HasRankAction HasRankMat HasRankOfTransformation HasRankPGroup HasRat HasRationalClasses HasRationalFunctionsFamily HasRationalizedMat HasRealClasses HasRecNames HasReducedConfluentRewritingSystem HasReesCongruenceOfSemigroupIdeal HasReesZeroMatrixSemigroupElementIsZero HasRefinedPcGroup HasRegularActionHomomorphism HasRelationsOfFpMonoid HasRelationsOfFpSemigroup HasRelativeOrders HasRelatorsOfFpAlgebra HasRelatorsOfFpGroup HasRepresentative HasRepresentativeSmallest HasRepresentativesContainedRightCosets HasRepresentativesMinimalBlocksAttr HasRepresentativesPerfectSubgroups HasRepresentativesSimpleSubgroups HasRespectsAddition HasRespectsAdditiveInverses HasRespectsInverses HasRespectsMultiplication HasRespectsOne HasRespectsScalarMultiplication HasRespectsZero HasRightActingAlgebra HasRightActingDomain HasRightActingGroup HasRightActingRingOfIdeal HasRightDerivations HasRightTransversalInParent HasRootOfDefiningPolynomial HasRootSystem HasRowIndexOfReesMatrixSemigroupElement HasRowIndexOfReesZeroMatrixSemigroupElement HasRowsOfReesMatrixSemigroup HasRowsOfReesZeroMatrixSemigroup HasRules HasSLDegree HasSLUnderlyingField HasSandwichMatrixOfReesMatrixSemigroup HasSandwichMatrixOfReesZeroMatrixSemigroup HasSemiEchelonBasis HasSemiEchelonMat HasSemiEchelonMatTransformation HasSemiSimpleType HasSemidirectFactorsOfGroup HasSemidirectProductInfo HasSemigroupOfRewritingSystem HasSiftFunction HasSiftGroup HasSignPerm HasSimpleSystem HasSimsNo HasSize HasSizesCentralizers HasSizesConjugacyClasses HasSmallGeneratingSet HasSmallestGeneratorPerm HasSmallestMovedPoint HasSmallestMovedPointPerm HasSocle HasSocleComplement HasSocleDimensions HasSocleTypePrimitiveGroup HasSortingPerm HasSource HasSparseCartanMatrix HasSpecialPcgs HasSplittingField HasStabChainImmutable HasStabChainMutable HasStabChainOptions HasStabilizerOfExternalSet HasStandardGeneratorsInfo HasStoredExcludedOrders HasStoredGroebnerBasis HasStraightLineProgElmType HasStraightLineProgramsTom HasString HasStructureConstantsTable HasStructureDescription HasSubdirectProductInfo HasSubfields HasSubnormalSeriesInParent HasSubsTom HasSubspaces HasSubspacesAll HasSuccessors HasSupersolvableResiduum HasSurjectiveActionHomomorphismAttr HasSylowSystem HasSymmetricDegree HasSymmetricParentGroup HasTableOfMarks HasTestMonomial HasTestMonomialQuick HasTestQuasiPrimitive HasTestRelativelySM HasTestSubnormallyMonomial HasTietzeOrigin HasTrace HasTranformsOneIntoZero HasTransformationRepresentation HasTransformsAdditionIntoMultiplication HasTransformsAdditiveInversesIntoInverses HasTransformsInversesIntoAdditiveInverses HasTransformsMultiplicationIntoAddition HasTransformsZeroIntoOne HasTransitiveIdentification HasTransitivity HasTransposedMat HasTransposedMatAttr HasTransposedMatImmutable HasTransposedMatrixGroup HasTransversal HasTriangulizedNullspaceMat HasTrivialCharacter HasTrivialSubFLMLOR HasTrivialSubadditiveMagmaWithZero HasTrivialSubalgebra HasTrivialSubgroup HasTrivialSubmagmaWithOne HasTrivialSubmodule HasTrivialSubmonoid HasTrivialSubnearAdditiveMagmaWithZero HasTrivialSubspace HasTwoClosure HasTzOptions HasTzRules HasUnderlyingCharacterTable HasUnderlyingCharacteristic HasUnderlyingCollection HasUnderlyingElementOfReesMatrixSemigroupElement HasUnderlyingElementOfReesZeroMatrixSemigroupElement HasUnderlyingExternalSet HasUnderlyingFamily HasUnderlyingField HasUnderlyingGeneralMapping HasUnderlyingGroup HasUnderlyingLeftModule HasUnderlyingLieAlgebra HasUnderlyingMagma HasUnderlyingRelation HasUnderlyingSemigroupOfReesMatrixSemigroup HasUnderlyingSemigroupOfReesZeroMatrixSemigroup HasUnderlyingVectorSpace HasUnits HasUniversalEnvelopingAlgebra HasUpperActingDomain HasUpperCentralSeriesOfGroup HasValuesOfClassFunction HasWeightOfGenerators HasWeightsTom HasWeylGroup HasWreathProductInfo HasZClassRepsQClass HasZero HasZeroAttr HasZeroCoefficient HasZeroImmutable HasZuppos HashDictAddDictionary HashFunct HashKeyBag HashKeyEnumerator HashTable HasnpeGL HasnpePSL HasnpeSL HasseDiagramBinaryRelation HeadPcElementByNumber HeadsInfoOfSemiEchelonizedMat HeadsInfoOfSemiEchelonizedMats HenselBound HermiteNormalFormIntegerMat HermiteNormalFormIntegerMatTransform HermiteNormalFormIntegerMatTransforms HeuGcdIntPolsCoeffs HeuGcdIntPolsExtRep HeuristicCancelPolynomialsExtRep HexBlistSetup HexStringBlist HexStringBlistEncode HexStringInt HideGlobalVariables HighestWeightModule HirschLength Hom HomCoset HomCosetFamily HomCosetWithImage HomFromFree HomFromFreeOfBasicImageGroup HomTransversal HomeEnumerator HomePcgs HomomorphicCanonicalPcgs HomomorphicInducedPcgs Homomorphism HomomorphismFactorSemigroup HomomorphismFactorSemigroupByClosure HomomorphismQuotientSemigroup HomomorphismTransformationSemigroup HomomorphismsSeries HumanReadableDefinition IBr IMFList IMFLoad IMFRec IdFunc IdGroup IdSmallGroup Ideal IdealByGenerators IdealByGeneratorsForLieAlgebra IdealNC Idempotents IdempotentsTom IdempotentsTomInfo IdentificationGenericGroup IdentificationOfConjugacyClasses IdentificationPermGroup IdentificationSolvableGroup Identifier IdentifierLetters Identity IdentityBinaryRelation IdentityFromSCTable IdentityMapping IdentityMat IdentityTransformation IdsOfAllGroups IdsOfAllSmallGroups Ignore Image ImageElm ImageElmActionHomomorphism ImageElt ImageGroup ImageInWord ImageKernelBlocksHomomorphism ImageListOfTransformation ImageMat ImageOnAbelianCSPG ImageSetOfTransformation ImageSiftedBaseImage ImageUnderWord Images ImagesElm ImagesListOfBinaryRelation ImagesRepresentative ImagesRepresentativeGMBIByElementsList ImagesSet ImagesSmallestGenerators ImagesSource ImfInvariants ImfMatrixGroup ImfNumberQClasses ImfNumberQQClasses ImfNumberZClasses ImfPositionNumber ImfRecord ImgElmSLP ImgElmSLPNonrecursive ImmediateImplicationsIdentityMapping ImmediateImplicationsZeroMapping Immutable ImmutableBasis ImmutableMatrix ImproveActionDegreeByBlocks ImproveMaps ImproveOperationDegreeByBlocks InParentFOA IncorporateCentralRelations IncreaseCounter IndPcgsWrtSpecFromFamOrHome IndependentGeneratorsAbelianPPermGroup IndependentGeneratorsOfAbelianGroup IndependentGeneratorsOfAbelianMatrixGroup Indeterminate IndeterminateName IndeterminateNumberOfLaurentPolynomial IndeterminateNumberOfUnivariateLaurentPolynomial IndeterminateNumberOfUnivariateRationalFunction IndeterminateOfLaurentPolynomial IndeterminateOfUnivariateRationalFunction Indeterminateness IndeterminatenessInfo IndeterminatesOfPolynomialRing Index IndexCosetTab IndexInParent IndexInWholeGroup IndexNC IndexOp Indicator IndicatorOp IndicesCentralNormalSteps IndicesChiefNormalSteps IndicesEANormalSteps IndicesInvolutaryGenerators IndicesNormalSteps IndicesOfAdjointBasis IndicesPCentralNormalStepsPGroup IndicesStabChain Indirected Induced InducedActionAutGroup InducedActionFactor InducedAutomorphism InducedClassFunction InducedClassFunctions InducedClassFunctionsByFusionMap InducedCyclic InducedGModule InducedLinearAction InducedModule InducedModuleByFieldReduction InducedPcgs InducedPcgsByGenerators InducedPcgsByGeneratorsNC InducedPcgsByGeneratorsWithImages InducedPcgsByPcSequence InducedPcgsByPcSequenceAndGenerators InducedPcgsByPcSequenceNC InducedPcgsWrtFamilyPcgs InducedPcgsWrtHomePcgs InducedPcgsWrtSpecialPcgs InducedRepFpGroup InducedRepresentation InducedRepresentationImagesRepresentative InduciblePairs InductionScheme Inequalities InertiaSubgroup InfiniteListOfGenerators InfiniteListOfNames Inflated Info InfoAction InfoAlgebra InfoAttributes InfoAutGrp InfoBasicImage InfoBckt InfoChain InfoCharacterTable InfoClassFamily InfoClasses InfoCoh InfoCompPairs InfoComplement InfoConfluence InfoCoset InfoData InfoDebug InfoDecision InfoDoPrint InfoExtReps InfoFactor InfoFpGroup InfoGalois InfoGlobal InfoGroebner InfoGroup InfoHash InfoHashTables InfoHomClass InfoIdgroup InfoImf InfoKnuthBendix InfoLattice InfoLevel InfoMatInt InfoMatOrb InfoMatrix InfoMeatAxe InfoMethodSelection InfoMonomial InfoMorph InfoNumtheor InfoOperation InfoOptions InfoOverGr InfoPcGroup InfoPcNormalizer InfoPcSubgroup InfoPerformance InfoPoly InfoPrimeInt InfoQuotientGroup InfoQuotientSystem InfoRSS InfoRandIso InfoSQ InfoSchur InfoSearchTable InfoSpecPcgs InfoTeaching InfoText InfoTiming InfoTom InfoTransversal InfoTuples InfoWarning InfoZLattice InitAbsAndIrredModules InitEpimorphismSQ InitFusion InitPowerMap InitialiseCentralRelations InitializePackagesInfoRecords InitializeSchreierTree Injection InjectionZeroMagma InnerAutomorphism InnerAutomorphismNC InnerAutomorphismsAutomorphismGroup InnerSubdirectProducts InputLogTo InputOutputLocalProcess InputOutputStreamByPtyDefaultType InputTextFile InputTextFileStillOpen InputTextFileType InputTextNone InputTextNoneType InputTextString InputTextStringType InputTextUser Insert InsertElmList InsertTrivialStabilizer InstallAccessToGenerators InstallAtExit InstallAttributeFunction InstallAttributeMethodByGroupGeneralMappingByImages InstallCharReadHookFunc InstallEqMethodForMappingsFromGenerators InstallFactorMaintenance InstallFlushableValue InstallGlobalFunction InstallHandlingByNiceBasis InstallHiddenTrueMethod InstallImmediateMethod InstallIsomorphismMaintenance InstallIsomorphismMaintenanceFunction InstallMethod InstallMonomialOrdering InstallOtherMethod InstallPcgsSeriesFromIndices InstallSubsetMaintenance InstallTrueMethod InstallTrueMethodNewFilter InstallValue InstalledPackageVersion Int IntFFE IntFFESymm IntHexString IntScalarProducts IntVecFFE Integers IntegralizedMat IntegratedStraightLineProgram IntermediateGroup IntermediateSubgroups InternalRepresentative InterpolatedPolynomial IntersectBlist IntersectSet Intersection IntersectionBlist IntersectionNormalClosurePermGroup IntersectionSet IntersectionSumPcgs IntersectionsTom InvariantBilinearForm InvariantElementaryAbelianSeries InvariantForm InvariantLattice InvariantQuadraticForm InvariantSesquilinearForm InvariantSubgroupsElementaryAbelianGroup InvariantSubspaceOrCyclicGroup InvariantSubspaceOrUniformCyclicPGroup Inverse InverseAsWord InverseAttr InverseClasses InverseGeneralMapping InverseImmutable InverseMap InverseMatMod InverseMutable InverseOp InversePcgs InverseRepresentative InverseRepresentativeWord InverseSLPElm InverseSM InverseSameMutability Irr IrrBaumClausen IrrConlon IrrDixonSchneider IrrFacsPol IrredSolGroupList IrredSolJSGens IrreducibleDifferences IrreducibleModules IrreducibleRepresentations IrreducibleRepresentationsByBaumClausen IrreducibleRepresentationsDixon IrreducibleSolvableGroup IrreducibleSolvableGroupMS IsANFAutomorphism IsANFAutomorphismRep IsAbelian IsAbelianNumberField IsAbelianNumberFieldPolynomialRing IsAbelianTom IsActionHomomorphism IsActionHomomorphismAutomGroup IsActionHomomorphismByActors IsActionHomomorphismByBase IsActionHomomorphismSubset IsAdditiveCoset IsAdditiveCosetDefaultRep IsAdditiveElement IsAdditiveElementAsMultiplicativeElementRep IsAdditiveElementCollColl IsAdditiveElementCollCollColl IsAdditiveElementCollection IsAdditiveElementList IsAdditiveElementTable IsAdditiveElementWithInverse IsAdditiveElementWithInverseCollColl IsAdditiveElementWithInverseCollCollColl IsAdditiveElementWithInverseCollection IsAdditiveElementWithInverseList IsAdditiveElementWithInverseTable IsAdditiveElementWithZero IsAdditiveElementWithZeroCollColl IsAdditiveElementWithZeroCollCollColl IsAdditiveElementWithZeroCollection IsAdditiveElementWithZeroList IsAdditiveElementWithZeroTable IsAdditiveGroup IsAdditiveGroupGeneralMapping IsAdditiveGroupHomomorphism IsAdditiveGroupToGroupGeneralMapping IsAdditiveGroupToGroupHomomorphism IsAdditiveMagma IsAdditiveMagmaWithInverses IsAdditiveMagmaWithZero IsAdditivelyCommutative IsAdditivelyCommutativeElement IsAdditivelyCommutativeElementCollColl IsAdditivelyCommutativeElementCollection IsAdditivelyCommutativeElementFamily IsAlgBFRep IsAlgExtRep IsAlgebra IsAlgebraGeneralMapping IsAlgebraGeneralMappingByImagesDefaultRep IsAlgebraHomomorphism IsAlgebraHomomorphismFromFpRep IsAlgebraModule IsAlgebraModuleElement IsAlgebraModuleElementCollection IsAlgebraModuleElementFamily IsAlgebraWithOne IsAlgebraWithOneGeneralMapping IsAlgebraWithOneHomomorphism IsAlgebraicElement IsAlgebraicElementCollColl IsAlgebraicElementCollCollColl IsAlgebraicElementCollection IsAlgebraicElementFamily IsAlgebraicExtension IsAlgebraicExtensionDefaultRep IsAlgebraicExtensionPolynomialRing IsAlphaChar IsAlternatingGroup IsAnticommutative IsAntisymmetricBinaryRelation IsAssocWord IsAssocWordCollection IsAssocWordFamily IsAssocWordWithInverse IsAssocWordWithInverseCollection IsAssocWordWithInverseFamily IsAssocWordWithOne IsAssocWordWithOneCollection IsAssocWordWithOneFamily IsAssociated IsAssociative IsAssociativeAOpDSum IsAssociativeAOpESum IsAssociativeElement IsAssociativeElementCollColl IsAssociativeElementCollection IsAssociativeLOpDProd IsAssociativeLOpEProd IsAssociativeROpDProd IsAssociativeROpEProd IsAssociativeUOpDProd IsAssociativeUOpEProd IsAttributeStoringRep IsAttributeStoringRepFlags IsAutomorphismGroup IsBLetterAssocWordRep IsBLetterWordsFamily IsBasicImageEltRep IsBasicImageEltRepCollection IsBasicImageGroup IsBasicWreathLessThanOrEqual IsBasicWreathProductOrdering IsBasis IsBasisByNiceBasis IsBasisFiniteFieldRep IsBasisOfAlgebraModuleElementSpace IsBasisOfMonomialSpaceRep IsBasisOfSparseRowSpaceRep IsBasisOfWeightRepElementSpace IsBasisWithReplacedLeftModuleRep IsBergerCondition IsBijective IsBinaryRelation IsBinaryRelationDefaultRep IsBinaryRelationOnPointsRep IsBlist IsBlistRep IsBlockMatrixRep IsBlocksHomomorphism IsBlocksOfActionHomomorphism IsBlowUpIsomorphism IsBool IsBound IsBoundElmWPObj IsBoundGlobal IsBracketRep IsBrauerTable IsBravaisGroup IsBuiltFromAdditiveMagmaWithInverses IsBuiltFromGroup IsBuiltFromMagma IsBuiltFromMagmaWithInverses IsBuiltFromMagmaWithOne IsBuiltFromMonoid IsBuiltFromSemigroup IsCanonicalBasis IsCanonicalBasisAbelianNumberFieldRep IsCanonicalBasisAlgebraicExtension IsCanonicalBasisCyclotomicFieldRep IsCanonicalBasisFreeMagmaRingRep IsCanonicalBasisFullMatrixModule IsCanonicalBasisFullRowModule IsCanonicalBasisFullSCAlgebra IsCanonicalBasisGaussianIntegersRep IsCanonicalBasisIntegersRep IsCanonicalBasisRationals IsCanonicalNiceMonomorphism IsCanonicalPcgs IsCanonicalPcgsWrtSpecialPcgs IsCentral IsCentralFromGenerators IsChainTypeGroup IsChar IsCharCollection IsCharacter IsCharacterTable IsCharacterTableInProgress IsCharacteristicMatrixPGroup IsCharacteristicSubgroup IsCheapConwayPolynomial IsClassFunction IsClassFunctionsSpace IsClassFusionOfNormalSubgroup IsClosedStream IsCochain IsCochainCollection IsCochainsSpace IsCocycle IsCoeffsElms IsCollCollsElms IsCollCollsElmsElms IsCollCollsElmsElmsX IsCollLieCollsElms IsCollection IsCollectionFamily IsCollsCollsElms IsCollsCollsElmsX IsCollsCollsElmsXX IsCollsElms IsCollsElmsColls IsCollsElmsElms IsCollsElmsElmsElms IsCollsElmsElmsX IsCollsElmsX IsCollsElmsXElms IsCollsElmsXX IsCollsXElms IsCollsXElmsX IsCombinatorialCollectorRep IsCommutative IsCommutativeElement IsCommutativeElementCollColl IsCommutativeElementCollection IsCommutativeFamily IsCommutativeFromGenerators IsCompatiblePair IsComponentObjectRep IsCompositionMappingRep IsConfluent IsCongruenceClass IsConjugacyClassGroupRep IsConjugacyClassPermGroupRep IsConjugacyClassSubgroupsByStabilizerRep IsConjugacyClassSubgroupsRep IsConjugate IsConjugatorAutomorphism IsConjugatorIsomorphism IsConsistentPolynomial IsConstantRationalFunction IsConstantTimeAccessGeneralMapping IsConstantTimeAccessList IsConstituentHomomorphism IsContainedInSpan IsCopyable IsCyc IsCycInt IsCyclic IsCyclicTom IsCyclotomic IsCyclotomicCollColl IsCyclotomicCollCollColl IsCyclotomicCollection IsCyclotomicField IsCyclotomicMatrixGroup IsDataObjectRep IsDeepThoughtCollectorRep IsDefaultGeneralMappingRep IsDefaultRhsTypeSingleCollector IsDefaultTupleRep IsDenseCoeffVectorRep IsDenseHashRep IsDenseList IsDiagonalMat IsDictionary IsDictionaryDefaultRep IsDigitChar IsDihedralGroup IsDirectSumElement IsDirectSumElementCollection IsDirectSumElementFamily IsDirectSumElementsSpace IsDirectory IsDirectoryPath IsDirectoryRep IsDistributive IsDistributiveLOpDProd IsDistributiveLOpDSum IsDistributiveLOpEProd IsDistributiveLOpESum IsDistributiveROpDProd IsDistributiveROpDSum IsDistributiveROpEProd IsDistributiveROpESum IsDistributiveUOpDProd IsDistributiveUOpDSum IsDistributiveUOpEProd IsDistributiveUOpESum IsDivisionRing IsDocumentedVariable IsDomain IsDoneIterator IsDoubleCoset IsDoubleCosetDefaultRep IsDuplicateFree IsDuplicateFreeCollection IsDuplicateFreeList IsDxLargeGroup IsElementFinitePolycyclicGroup IsElementFinitePolycyclicGroupCollection IsElementOfFpAlgebra IsElementOfFpAlgebraCollection IsElementOfFpAlgebraFamily IsElementOfFpGroup IsElementOfFpGroupCollection IsElementOfFpGroupFamily IsElementOfFpMonoid IsElementOfFpMonoidCollection IsElementOfFpMonoidFamily IsElementOfFpSemigroup IsElementOfFpSemigroupCollection IsElementOfFpSemigroupFamily IsElementOfFreeGroup IsElementOfFreeGroupFamily IsElementOfFreeMagmaRing IsElementOfFreeMagmaRingCollection IsElementOfFreeMagmaRingFamily IsElementOfMagmaRingModuloRelations IsElementOfMagmaRingModuloRelationsCollection IsElementOfMagmaRingModuloRelationsFamily IsElementOfMagmaRingModuloSpanOfZeroFamily IsElementaryAbelian IsElementsFamilyByRws IsElmsCoeffs IsElmsCollColls IsElmsCollCollsX IsElmsCollLieColls IsElmsColls IsElmsCollsX IsElmsCollsXX IsElmsLieColls IsEmbeddingDirectProductPermGroup IsEmbeddingImprimitiveWreathProductPermGroup IsEmbeddingMagmaMagmaRing IsEmbeddingProductActionWreathProductPermGroup IsEmbeddingRingMagmaRing IsEmbeddingWreathProductPermGroup IsEmpty IsEmptyRowVectorRep IsEmptyString IsEndOfStream IsEndoGeneralMapping IsEndoMapping IsEnumeratorByFunctions IsEnumeratorByFunctionsRep IsEnumeratorByPcgsRep IsEqualSet IsEquivalenceClass IsEquivalenceClassDefaultRep IsEquivalenceRelation IsEquivalenceRelationDefaultRep IsEquivalentByFp IsEuclideanRing IsEvenInt IsExecutableFile IsExistingFile IsExtAElement IsExtAElementCollColl IsExtAElementCollection IsExtAElementList IsExtAElementTable IsExtASet IsExtLElement IsExtLElementCollColl IsExtLElementCollection IsExtLElementList IsExtLElementTable IsExtLSet IsExtRElement IsExtRElementCollColl IsExtRElementCollection IsExtRElementList IsExtRElementTable IsExtRSet IsExtUSet IsExtensibleGeneralMapping IsExtensiblePartialMapping IsExternalOrbit IsExternalOrbitByStabilizerRep IsExternalSet IsExternalSetByActorsRep IsExternalSetByOperatorsRep IsExternalSetByPcgs IsExternalSetDefaultRep IsExternalSubset IsFFE IsFFECollColl IsFFECollCollColl IsFFECollection IsFFEFamily IsFFEMatrixGroup IsFFEMatrixGroupOverLargeSpace IsFLMLOR IsFLMLORWithOne IsFamFamFam IsFamFamFamX IsFamFamX IsFamFamXY IsFamLieFam IsFamXFam IsFamXFamY IsFamXYFamZ IsFamily IsFamilyDefaultRep IsFamilyElementOfFreeLieAlgebra IsFamilyOfFamilies IsFamilyOfTypes IsFamilyOverFullCoefficientsFamily IsFamilyPcgs IsField IsFieldControlledByGaloisGroup IsFieldElementsSpace IsFieldHomomorphism IsFilter IsFinite IsFiniteBasisDefault IsFiniteDimensional IsFiniteFieldPolynomialRing IsFiniteOrderElement IsFiniteOrderElementCollColl IsFiniteOrderElementCollection IsFiniteOrdersPcgs IsFiniteSemigroupGreensRelation IsFinitelyGeneratedGroup IsFixedStabilizer IsFlatHashTable IsFlexibleGeneralMapping IsFlexiblePartialMapping IsFpAlgebraElementsSpace IsFpGroup IsFpMonoid IsFpSemigroup IsFptoSCAMorphism IsFrattiniFree IsFreeGroup IsFreeLeftModule IsFreeMagma IsFreeMagmaRing IsFreeMagmaRingWithOne IsFreeMonoid IsFreeSemigroup IsFrobeniusAutomorphism IsFromFpGroupGeneralMapping IsFromFpGroupGeneralMappingByImages IsFromFpGroupHomomorphism IsFromFpGroupHomomorphismByImages IsFromFpGroupStdGensGeneralMappingByImages IsFromFpGroupStdGensHomomorphismByImages IsFullFpAlgebra IsFullHomModule IsFullMatrixModule IsFullRowModule IsFullSCAlgebra IsFullSubgroupGLorSLRespectingBilinearForm IsFullSubgroupGLorSLRespectingQuadraticForm IsFullSubgroupGLorSLRespectingSesquilinearForm IsFullTransformationSemigroup IsFunction IsGL IsGaussInt IsGaussRat IsGaussianIntegers IsGaussianMatrixSpace IsGaussianRationals IsGaussianRowSpace IsGaussianSpace IsGeneralLinearGroup IsGeneralMapping IsGeneralMappingCollection IsGeneralMappingFamily IsGeneralPcgs IsGeneralizedCartanMatrix IsGeneralizedDomain IsGeneralizedRowVector IsGeneratorsOfMagmaWithInverses IsGenericCharacterTableRep IsGenericFiniteSpace IsGreensClass IsGreensDClass IsGreensDRelation IsGreensHClass IsGreensHRelation IsGreensJClass IsGreensJRelation IsGreensLClass IsGreensLRelation IsGreensLessThanOrEqual IsGreensRClass IsGreensRRelation IsGreensRelation IsGroup IsGroupGeneralMapping IsGroupGeneralMappingByAsGroupGeneralMappingByImages IsGroupGeneralMappingByImages IsGroupGeneralMappingByPcgs IsGroupHClass IsGroupHomomorphism IsGroupOfAutomorphisms IsGroupOfAutomorphismsFiniteGroup IsGroupOfFamily IsGroupRing IsGroupToAdditiveGroupGeneralMapping IsGroupToAdditiveGroupHomomorphism IsHandledByNiceBasis IsHandledByNiceMonomorphism IsHash IsHashTable IsHasseDiagram IsHomCoset IsHomCosetCollection IsHomCosetOfAdditiveElt IsHomCosetOfFp IsHomCosetOfMatrix IsHomCosetOfPerm IsHomCosetOfTuple IsHomCosetToAdditiveElt IsHomCosetToAdditiveEltCollection IsHomCosetToAdditiveEltRep IsHomCosetToFp IsHomCosetToFpCollection IsHomCosetToFpRep IsHomCosetToMatrix IsHomCosetToMatrixCollection IsHomCosetToMatrixRep IsHomCosetToObjectRep IsHomCosetToPerm IsHomCosetToPermCollection IsHomCosetToPermRep IsHomCosetToTuple IsHomCosetToTupleCollection IsHomCosetToTupleRep IsHomQuotientGroup IsHomogeneousList IsIdeal IsIdealInParent IsIdealOp IsIdempotent IsIdenticalObj IsIdenticalObjFamiliesColObjObj IsIdenticalObjFamiliesColObjObjObj IsIdenticalObjFamiliesColXXXObj IsIdenticalObjFamiliesColXXXXXXObj IsIdenticalObjFamiliesRwsObj IsIdenticalObjFamiliesRwsObjObj IsIdenticalObjFamiliesRwsObjXXX IsIdenticalObjObjObjX IsIdenticalObjObjXObj IsImfMatrixGroup IsImpossible IsInBasicOrbit IsInCenter IsInCentre IsInChain IsIncomparableUnder IsInducedFromNormalSubgroup IsInducedPcgs IsInducedPcgsRep IsInducedPcgsWrtSpecialPcgs IsInfBitsAssocWord IsInfBitsFamily IsInfiniteListOfGeneratorsRep IsInfiniteListOfNamesRep IsInfinity IsInfoClass IsInfoClassCollection IsInfoClassListRep IsInfoSelector IsInjective IsInnerAutomorphism IsInputOutputStream IsInputOutputStreamByPtyRep IsInputStream IsInputTextFileRep IsInputTextNone IsInputTextNoneRep IsInputTextStream IsInputTextStringRep IsInt IsIntegerMatrixGroup IsIntegers IsIntegralBasis IsIntegralCyclotomic IsIntegralRing IsInternalRep IsInternallyConsistent IsInverseGeneralMappingRep IsIrreducible IsIrreducibleCharacter IsIrreducibleRingElement IsIterator IsIteratorByFunctions IsIteratorByFunctionsRep IsJacobianElement IsJacobianElementCollColl IsJacobianElementCollection IsJacobianRing IsKernelPcWord IsKnuthBendixRewritingSystem IsKnuthBendixRewritingSystemRep IsLDistributive IsLatticeOrderBinaryRelation IsLatticeSubgroupsRep IsLaurentPolynomial IsLaurentPolynomialDefaultRep IsLaurentPolynomialsFamily IsLaurentPolynomialsFamilyElement IsLeftActedOnByDivisionRing IsLeftActedOnByRing IsLeftActedOnBySuperset IsLeftAlgebraModule IsLeftAlgebraModuleElement IsLeftAlgebraModuleElementCollection IsLeftIdeal IsLeftIdealFromGenerators IsLeftIdealInParent IsLeftIdealOp IsLeftMagmaCongruence IsLeftMagmaIdeal IsLeftModule IsLeftModuleGeneralMapping IsLeftModuleHomomorphism IsLeftOperatorAdditiveGroup IsLeftOperatorRing IsLeftOperatorRingWithOne IsLeftSemigroupCongruence IsLeftSemigroupIdeal IsLeftVectorSpace IsLessThanOrEqualUnder IsLessThanUnder IsLetterAssocWordRep IsLetterWordsFamily IsLexicographicallyLess IsLibTomRep IsLibraryCharacterTableRep IsLieAbelian IsLieAlgebra IsLieEmbeddingRep IsLieFamFam IsLieMatrix IsLieNilpotent IsLieNilpotentElement IsLieObject IsLieObjectCollection IsLieObjectsModule IsLieSolvable IsLinearActionHomomorphism IsLinearGeneralMappingByImagesDefaultRep IsLinearMapping IsLinearMappingByMatrixDefaultRep IsLinearMappingsModule IsLinearlyIndependent IsLinearlyPrimitive IsList IsListDefault IsListDictionary IsListHashTable IsListLookupDictionary IsListOrCollection IsLockedRepresentationVector IsLookupDictionary IsLowerAlphaChar IsLowerTriangularMat IsMagma IsMagmaByMultiplicationTableObj IsMagmaCollsMagmaRingColls IsMagmaCongruence IsMagmaHomomorphism IsMagmaIdeal IsMagmaRingModuloRelations IsMagmaRingModuloSpanOfZero IsMagmaRingObjDefaultRep IsMagmaRingsMagmas IsMagmaRingsRings IsMagmaWithInverses IsMagmaWithInversesIfNonzero IsMagmaWithMultiplicativeZeroAdjoinedElementRep IsMagmaWithOne IsMagmasMagmaRings IsMapping IsMappingByFunctionRep IsMappingByFunctionWithInverseRep IsMatchingSublist IsMatrix IsMatrixCollection IsMatrixFLMLOR IsMatrixGroup IsMatrixModule IsMatrixSpace IsMemberPcSeriesPermGroup IsMinimalNonmonomial IsModuloPcgs IsModuloPcgsFpGroupRep IsModuloPcgsPermGroupRep IsModuloPcgsRep IsModuloTailPcgsByListRep IsModuloTailPcgsRep IsModulusRep IsMonoid IsMonomial IsMonomialCharacter IsMonomialCharacterTable IsMonomialElement IsMonomialElementCollection IsMonomialElementFamily IsMonomialElementRep IsMonomialGroup IsMonomialMatrix IsMonomialNumber IsMonomialOrdering IsMonomialOrderingDefaultRep IsMultiplicativeElement IsMultiplicativeElementCollColl IsMultiplicativeElementCollCollColl IsMultiplicativeElementCollection IsMultiplicativeElementList IsMultiplicativeElementTable IsMultiplicativeElementWithInverse IsMultiplicativeElementWithInverseByPolycyclicCollector IsMultiplicativeElementWithInverseByPolycyclicCollectorCollection IsMultiplicativeElementWithInverseByRws IsMultiplicativeElementWithInverseCollColl IsMultiplicativeElementWithInverseCollCollColl IsMultiplicativeElementWithInverseCollection IsMultiplicativeElementWithInverseList IsMultiplicativeElementWithInverseTable IsMultiplicativeElementWithOne IsMultiplicativeElementWithOneCollColl IsMultiplicativeElementWithOneCollCollColl IsMultiplicativeElementWithOneCollection IsMultiplicativeElementWithOneList IsMultiplicativeElementWithOneTable IsMultiplicativeElementWithZero IsMultiplicativeElementWithZeroCollection IsMultiplicativeGeneralizedRowVector IsMultiplicativeZero IsMutable IsMutableBasis IsMutableBasisByImmutableBasisRep IsMutableBasisOfGaussianMatrixSpaceRep IsMutableBasisOfGaussianRowSpaceRep IsMutableBasisViaNiceMutableBasisRep IsMutableBasisViaUnderlyingMutableBasisRep IsNBitsPcWordRep IsNameOfNoninstalledTableOfMarks IsNaturalAlternatingGroup IsNaturalGL IsNaturalGLnZ IsNaturalHomomorphismPcGroupRep IsNaturalSL IsNaturalSLnZ IsNaturalSymmetricGroup IsNearAdditiveElement IsNearAdditiveElementCollColl IsNearAdditiveElementCollCollColl IsNearAdditiveElementCollection IsNearAdditiveElementList IsNearAdditiveElementTable IsNearAdditiveElementWithInverse IsNearAdditiveElementWithInverseCollColl IsNearAdditiveElementWithInverseCollCollColl IsNearAdditiveElementWithInverseCollection IsNearAdditiveElementWithInverseList IsNearAdditiveElementWithInverseTable IsNearAdditiveElementWithZero IsNearAdditiveElementWithZeroCollColl IsNearAdditiveElementWithZeroCollCollColl IsNearAdditiveElementWithZeroCollection IsNearAdditiveElementWithZeroList IsNearAdditiveElementWithZeroTable IsNearAdditiveGroup IsNearAdditiveMagma IsNearAdditiveMagmaWithInverses IsNearAdditiveMagmaWithZero IsNearRing IsNearRingElement IsNearRingElementCollColl IsNearRingElementCollCollColl IsNearRingElementCollection IsNearRingElementFamily IsNearRingElementList IsNearRingElementTable IsNearRingElementWithInverse IsNearRingElementWithInverseCollColl IsNearRingElementWithInverseCollCollColl IsNearRingElementWithInverseCollection IsNearRingElementWithInverseList IsNearRingElementWithInverseTable IsNearRingElementWithOne IsNearRingElementWithOneCollColl IsNearRingElementWithOneCollCollColl IsNearRingElementWithOneCollection IsNearRingElementWithOneList IsNearRingElementWithOneTable IsNearRingWithOne IsNearlyCharacterTable IsNegInt IsNegRat IsNiceMonomorphism IsNilpQuotientSystem IsNilpotent IsNilpotentCharacterTable IsNilpotentElement IsNilpotentGroup IsNilpotentTom IsNoImmediateMethodsObject IsNonGaussianMatrixSpace IsNonGaussianRowSpace IsNonSPGeneralMapping IsNonSPMappingByFunctionRep IsNonSPMappingByFunctionWithInverseRep IsNonTrivial IsNonassocWord IsNonassocWordCollection IsNonassocWordFamily IsNonassocWordWithOne IsNonassocWordWithOneCollection IsNonassocWordWithOneFamily IsNoncharacteristicMatrixPGroup IsNonnegativeIntegers IsNormal IsNormalBasis IsNormalForm IsNormalInParent IsNormalOp IsNotElmsColls IsNotIdenticalObj IsNullMapMatrix IsNumberField IsNumeratorParentForExponentsRep IsNumeratorParentPcgsFamilyPcgs IsObjToBePrinted IsObject IsOddAdditiveNestingDepthFamily IsOddAdditiveNestingDepthObject IsOddInt IsOne IsOperation IsOperationAlgebraHomomorphismDefaultRep IsOrdering IsOrderingOnFamilyOfAssocWords IsOrdinaryMatrix IsOrdinaryMatrixCollection IsOrdinaryTable IsOutputStream IsOutputTextFileRep IsOutputTextNone IsOutputTextNoneRep IsOutputTextStream IsOutputTextStringRep IsPGroup IsPNilpotent IsPNilpotentOp IsPQuotientSystem IsPSL IsPSolvable IsPSolvableCharacterTable IsPSolvableCharacterTableOp IsPSolvableOp IsPackedElementDefaultRep IsPadicExtensionNumber IsPadicExtensionNumberFamily IsPadicNumber IsPadicNumberCollColl IsPadicNumberCollection IsPadicNumberFamily IsPadicNumberList IsPadicNumberTable IsParentPcgsFamilyPcgs IsPartialOrderBinaryRelation IsPartition IsPcGroup IsPcGroupGeneralMappingByImages IsPcGroupHomomorphismByImages IsPcgs IsPcgsCentralSeries IsPcgsChiefSeries IsPcgsDefaultRep IsPcgsElementaryAbelianSeries IsPcgsFamily IsPcgsPCentralSeriesPGroup IsPcgsPermGroupRep IsPcgsToPcgsGeneralMappingByImages IsPcgsToPcgsHomomorphism IsPerfect IsPerfectCharacterTable IsPerfectGroup IsPerfectLibraryGroup IsPerfectTom IsPerm IsPermCollColl IsPermCollection IsPermGroup IsPermGroupGeneralMappingByImages IsPermGroupHomomorphismByImages IsPermOnEnumerator IsPlistRep IsPolycyclicCollector IsPolycyclicGroup IsPolynomial IsPolynomialDefaultRep IsPolynomialFunction IsPolynomialFunctionCollection IsPolynomialFunctionsFamily IsPolynomialFunctionsFamilyElement IsPolynomialRing IsPolynomialRingIdeal IsPosInt IsPosRat IsPositionDictionary IsPositionLookupDictionary IsPositionalObjectRep IsPositionsList IsPositiveIntegers IsPowerCommutatorCollector IsPowerConjugateCollector IsPreOrderBinaryRelation IsPreimagesByAsGroupGeneralMappingByImages IsPresentation IsPresentationDefaultRep IsPrimGrpIterRep IsPrime IsPrimeField IsPrimeInt IsPrimeOrdersPcgs IsPrimePowerInt IsPrimitive IsPrimitiveAffine IsPrimitiveCharacter IsPrimitiveMatrixGroup IsPrimitivePolynomial IsPrimitiveRootMod IsProbablyPrimeInt IsProbablyPrimeIntWithFail IsProjectionDirectProductPermGroup IsProjectionSubdirectProductPermGroup IsPseudoCanonicalBasisFullHomModule IsPurePadicNumber IsPurePadicNumberFamily IsQuasiDihedralGroup IsQuasiPrimitive IsQuaternion IsQuaternionCollColl IsQuaternionCollection IsQuaternionGroup IsQuickPositionList IsQuotientSemigroup IsQuotientSystem IsQuotientToAdditiveGroup IsQuotientToFpGroup IsQuotientToMatrixGroup IsQuotientToPermGroup IsQuotientToTupleGroup IsRDistributive IsRange IsRangeRep IsRat IsRationalClassGroupRep IsRationalClassPermGroupRep IsRationalFunction IsRationalFunctionCollection IsRationalFunctionDefaultRep IsRationalFunctionOverField IsRationalFunctionsFamily IsRationalFunctionsFamilyElement IsRationalMatrixGroup IsRationals IsRationalsPolynomialRing IsReadOnlyGVar IsReadOnlyGlobal IsReadableFile IsRecord IsRecordCollColl IsRecordCollection IsRectangularTable IsRectangularTablePlist IsReduced IsReducedConfluentRewritingSystem IsReducedForm IsReductionOrdering IsReesCongruence IsReesCongruenceSemigroup IsReesMatrixSemigroup IsReesMatrixSemigroupElement IsReesMatrixSemigroupElementCollection IsReesMatrixSemigroupElementRep IsReesZeroMatrixSemigroup IsReesZeroMatrixSemigroupElement IsReesZeroMatrixSemigroupElementCollection IsReflexiveBinaryRelation IsRegular IsRegularDClass IsRegularSemigroup IsRegularSemigroupElement IsRelativeBasisDefaultRep IsRelativelySM IsRestrictedLieAlgebra IsRewritingSystem IsRightActedOnByDivisionRing IsRightActedOnByRing IsRightActedOnBySuperset IsRightAlgebraModule IsRightAlgebraModuleElement IsRightAlgebraModuleElementCollection IsRightCoset IsRightCosetDefaultRep IsRightIdeal IsRightIdealFromGenerators IsRightIdealInParent IsRightIdealOp IsRightMagmaCongruence IsRightMagmaIdeal IsRightModule IsRightOperatorAdditiveGroup IsRightSemigroupCongruence IsRightSemigroupIdeal IsRightTransversal IsRightTransversalCollection IsRightTransversalFpGroupRep IsRightTransversalPcGroupRep IsRightTransversalPermGroupRep IsRightTransversalRep IsRightTransversalViaCosetsRep IsRing IsRingCollsMagmaRingColls IsRingElement IsRingElementCollColl IsRingElementCollCollColl IsRingElementCollection IsRingElementFamily IsRingElementList IsRingElementTable IsRingElementWithInverse IsRingElementWithInverseCollColl IsRingElementWithInverseCollCollColl IsRingElementWithInverseCollection IsRingElementWithInverseList IsRingElementWithInverseTable IsRingElementWithOne IsRingElementWithOneCollColl IsRingElementWithOneCollCollColl IsRingElementWithOneCollection IsRingElementWithOneList IsRingElementWithOneTable IsRingGeneralMapping IsRingHomomorphism IsRingWithOne IsRingWithOneGeneralMapping IsRingWithOneHomomorphism IsRingsMagmaRings IsRootSystem IsRootSystemFromLieAlgebra IsRowModule IsRowSpace IsRowVector IsSCAlgebraObj IsSCAlgebraObjCollColl IsSCAlgebraObjCollCollColl IsSCAlgebraObjCollection IsSCAlgebraObjFamily IsSCAlgebraObjSpace IsSL IsSPGeneralMapping IsSPMappingByFunctionRep IsSPMappingByFunctionWithInverseRep IsSSortedList IsScalar IsScalarCollColl IsScalarCollection IsScalarList IsScalarTable IsSearchTable IsSemiEchelonBasisOfGaussianMatrixSpaceRep IsSemiEchelonBasisOfGaussianRowSpaceRep IsSemiEchelonized IsSemiRegular IsSemigroup IsSemigroupCongruence IsSemigroupIdeal IsSemiring IsSemiringWithOne IsSemiringWithOneAndZero IsSemiringWithZero IsSet IsShortLexLessThanOrEqual IsShortLexOrdering IsSimple IsSimpleAlgebra IsSimpleCharacterTable IsSimpleGroup IsSimpleSemigroup IsSingleCollectorRep IsSingleValued IsSkewFieldFamily IsSlicedPerm IsSlicedPermInv IsSmallIntRep IsSmallList IsSolvable IsSolvableCharacterTable IsSolvableGroup IsSolvableTom IsSortDictionary IsSortLookupDictionary IsSortedList IsSortedPcgsRep IsSpaceOfElementsOfMagmaRing IsSpaceOfRationalFunctions IsSpaceOfUEAElements IsSparseHashRep IsSparseRowSpaceElement IsSparseRowSpaceElementCollection IsSparseRowSpaceElementFamily IsSpecialLinearGroup IsSpecialPcgs IsSporadicSimple IsSporadicSimpleCharacterTable IsSporadicSimpleGroup IsStabChainViaChainSubgroup IsStandardGeneratorsOfGroup IsStandardized IsStraightLineProgElm IsStraightLineProgram IsStream IsString IsStringRep IsSubalgebraFpAlgebra IsSubgroup IsSubgroupFgGroup IsSubgroupFpGroup IsSubgroupOfWholeGroupByQuotientRep IsSubgroupSL IsSubmonoidFpMonoid IsSubnormal IsSubnormallyMonomial IsSubsemigroupFpSemigroup IsSubsemigroupReesMatrixSemigroup IsSubsemigroupReesZeroMatrixSemigroup IsSubset IsSubsetBlist IsSubsetInducedNumeratorModuloTailPcgsRep IsSubsetInducedPcgsRep IsSubsetLocallyFiniteGroup IsSubsetSet IsSubspace IsSubspacesFullRowSpaceDefaultRep IsSubspacesVectorSpace IsSubspacesVectorSpaceDefaultRep IsSupersolvable IsSupersolvableCharacterTable IsSupersolvableGroup IsSurjective IsSyllableAssocWordRep IsSyllableWordsFamily IsSymmetricBinaryRelation IsSymmetricGroup IsSymmetricPowerElement IsSymmetricPowerElementCollection IsTable IsTableOfMarks IsTableOfMarksWithGens IsTailInducedPcgsRep IsTensorElement IsTensorElementCollection IsToBeDefinedObj IsToFpGroupGeneralMappingByImages IsToFpGroupHomomorphismByImages IsToPcGroupGeneralMappingByImages IsToPcGroupHomomorphismByImages IsToPermGroupGeneralMappingByImages IsToPermGroupHomomorphismByImages IsTotal IsTotalOrdering IsTransformation IsTransformationCollection IsTransformationMonoid IsTransformationRep IsTransformationRepOfEndo IsTransformationSemigroup IsTransitive IsTransitiveBinaryRelation IsTranslationInvariantOrdering IsTransvByDirProd IsTransvByDirProdCollection IsTransvByHomomorphism IsTransvByHomomorphismCollection IsTransvBySchreierTree IsTransvBySchreierTreeCollection IsTransvBySiftFunct IsTransvBySiftFunctCollection IsTransvByTrivSubgrp IsTransvByTrivSubgrpCollection IsTrivial IsTrivialAOpEZero IsTrivialHomCoset IsTrivialLOpEOne IsTrivialLOpEZero IsTrivialRBase IsTrivialROpEOne IsTrivialROpEZero IsTrivialUOpEOne IsTrivialUOpEZero IsTuple IsTupleCollection IsTupleFamily IsTwoSidedIdeal IsTwoSidedIdealInParent IsTwoSidedIdealOp IsType IsTypeDefaultRep IsUEALatticeElement IsUEALatticeElementCollection IsUEALatticeElementFamily IsUFDFamily IsUniformMatrixGroup IsUniqueFactorizationRing IsUnit IsUnivariatePolynomial IsUnivariatePolynomialRing IsUnivariatePolynomialsFamily IsUnivariatePolynomialsFamilyElement IsUnivariateRationalFunction IsUnivariateRationalFunctionDefaultRep IsUnknown IsUnknownDefaultRep IsUnsortedPcgsRep IsUpToDatePolycyclicCollector IsUpperActedOnByGroup IsUpperActedOnBySuperset IsUpperAlphaChar IsUpperTriangularMat IsValidIdentifier IsVector IsVectorCollColl IsVectorCollection IsVectorList IsVectorSearchTable IsVectorSearchTableDefaultRep IsVectorSpace IsVectorSpaceHomomorphism IsVectorTable IsVirtualCharacter IsWLetterAssocWordRep IsWLetterWordsFamily IsWPObj IsWeakPointerObject IsWedgeElement IsWedgeElementCollection IsWeightLexOrdering IsWeightRepElement IsWeightRepElementCollection IsWeightRepElementFamily IsWellFoundedOrdering IsWeylGroup IsWholeFamily IsWord IsWordCollection IsWordWithInverse IsWordWithOne IsWreathProductElement IsWreathProductElementCollection IsWreathProductElementDefaultRep IsWreathProductOrdering IsWritableFile IsZDFRE IsZDFRECollColl IsZDFRECollection IsZero IsZeroCochainRep IsZeroCyc IsZeroGroup IsZeroMultiplicationRing IsZeroRationalFunction IsZeroSimpleSemigroup IsZeroSquaredElement IsZeroSquaredElementCollColl IsZeroSquaredElementCollection IsZeroSquaredRing IsZmodnZObj IsZmodnZObjNonprime IsZmodnZObjNonprimeCollColl IsZmodnZObjNonprimeCollCollColl IsZmodnZObjNonprimeCollection IsZmodnZObjNonprimeFamily IsZmodpZObj IsZmodpZObjLarge IsZmodpZObjSmall IsolatePoint IsomorphicSubgroups IsomorphismAbelianGroups IsomorphismFpAlgebra IsomorphismFpFLMLOR IsomorphismFpGroup IsomorphismFpGroupByCompositionSeries IsomorphismFpGroupByGenerators IsomorphismFpGroupByGeneratorsNC IsomorphismFpGroupByPcgs IsomorphismFpGroupBySubnormalSeries IsomorphismFpMonoid IsomorphismFpSemigroup IsomorphismGroups IsomorphismMatrixAlgebra IsomorphismMatrixFLMLOR IsomorphismPcGroup IsomorphismPermGroup IsomorphismPermGroupImfGroup IsomorphismPermGroupOrFailFpGroup IsomorphismPermGroups IsomorphismReesMatrixSemigroup IsomorphismRefinedPcGroup IsomorphismSCAlgebra IsomorphismSCFLMLOR IsomorphismSimplifiedFpGroup IsomorphismSolvableSmallGroups IsomorphismSpecialPcGroup IsomorphismToFullRowSpace IsomorphismTransformationSemigroup IsomorphismTypeInfoFiniteSimpleGroup Iterated Iterator IteratorByBasis IteratorByFunctions IteratorList IteratorSorted IteratorsFamily Jacobi JenningsLieAlgebra JenningsSeries JoinEquivalenceRelations JoinMagmaCongruences JoinSemigroupCongruences JoinStringsWithSeparator JordanDecomposition KBOverlaps KappaPerp Kernel KernelHcommaC KernelOfAdditiveGeneralMapping KernelOfCharacter KernelOfHomQuotientGroup KernelOfMultiplicativeGeneralMapping KernelOfTransformation KernelUnderDualAction KeyDependentOperation KillingMatrix KnownAttributesOfObject KnownNaturalHomomorphismsPool KnownPropertiesOfObject KnownTruePropertiesOfObject KnowsDictionary KnowsHowToDecompose KnuthBendixRewritingSystem KroneckerProduct KuKGenerators LClassOfHClass LGFirst LGHeads LGLayers LGLength LGTails LGWeights LLLReducedBasis LLLReducedGramMat LLLint LMPSLPSeed LaTeX LaTeXObj LaTeXStringDecompositionMatrix LaTeXToHTMLString LabsLims Lambda LargeGaloisField LargestElementGroup LargestElementStabChain LargestMovedPoint LargestMovedPointPerm LargestMovedPointPerms LargestUnknown LastHashIndex LastReadValue LastSystemError LatticeByCyclicExtension LatticeGeneratorsInUEA LatticeSubgroups LatticeSubgroupsByTom LaurentPolynomialByCoefficients LaurentPolynomialByExtRep Lcm LcmInt LcmOp LcmPP LeadCoeffsIGS LeadingCoefficient LeadingCoefficientOfPolynomial LeadingExponentOfPcElement LeadingMonomial LeadingMonomialOfPolynomial LeadingMonomialPosExtRep LeadingTermOfPolynomial LeadingUEALatticeMonomial LeastBadComplementLayer LeastBadHallLayer LeftActingAlgebra LeftActingDomain LeftActingGroup LeftActingRingOfIdeal LeftAction LeftAlgebraModule LeftAlgebraModuleByGenerators LeftDerivations LeftIdeal LeftIdealByGenerators LeftIdealNC LeftMagmaCongruence LeftMagmaCongruenceByGeneratingPairs LeftMagmaIdeal LeftMagmaIdealByGenerators LeftModuleByGenerators LeftModuleByHomomorphismToMatAlg LeftModuleGeneralMappingByImages LeftModuleGeneratorsForIdealFromGenerators LeftModuleHomomorphismByImages LeftModuleHomomorphismByImagesNC LeftModuleHomomorphismByMatrix LeftNormedComm LeftQuotient LeftQuotientPowerPcgsElement LeftReduceUEALatticeElement LeftSemigroupCongruenceByGeneratingPairs LeftSemigroupIdealEnumeratorDataGetElement LeftShiftRowVector Legendre Length LengthOfDescendingSeries LengthOfLongestCommonPrefixOfTwoAssocWords LengthWPObj LengthsTom LenstraBase LessBoxedObj LessThanFunction LessThanOrEqualFunction LetterRepAssocWord LetterRepWordsLessFunc LevelsOfGenerators LeviMalcevDecomposition LexicographicOrdering LexicographicOrderingNC LieAlgebra LieAlgebraByDomain LieAlgebraByStructureConstants LieBracket LieCenter LieCentralizer LieCentralizerInParent LieCentre LieCoboundaryOperator LieDerivedSeries LieDerivedSubalgebra LieFamily LieLowerCentralSeries LieNilRadical LieNormalizer LieNormalizerInParent LieObject LieSolvableRadical LieUpperCentralSeries LiftAbsAndIrredModules LiftEpimorphism LiftEpimorphismSQ LiftInduciblePair LiftedInducedPcgs LiftedPcElement LineNumberStringPosition LinearAction LinearActionBasis LinearActionLayer LinearCharacters LinearCombination LinearCombinationPcgs LinearCombinationVecs LinearGroupParameters LinearIndependentColumns LinearOperation LinearOperationLayer LinesOfStraightLineProgram List ListBlist ListHashParams ListN ListOp ListPerm ListSorted ListStabChain ListWithIdenticalEntries ListX ListXHelp ListsFamily LoadAllPackages LoadDynamicModule LoadPackage LoadPackageDocumentation LoadStaticModule LoadedModules LockNaturalHomomorphismsPool Log LogFFE LogInputTo LogInt LogMod LogModRhoIterate LogModShanks LogOutputTo LogTo LongestWeylWordPerm LookupDictionary LowIndexSubgroupsFpGroup LowerCentralSeries LowerCentralSeriesOfGroup LowerTriangularMatrix LowercaseString Lucas MATINTbezout MATINTmgcdex MATINTrgcd MATINTsplit Magma MagmaByGenerators MagmaByMultiplicationTable MagmaByMultiplicationTableCreator MagmaCongruenceByGeneratingPairs MagmaCongruencePartition MagmaElement MagmaGeneratorsOfFamily MagmaHomomorphismByFunctionNC MagmaIdeal MagmaIdealByGenerators MagmaInputString MagmaIsomorphismByFunctionsNC MagmaRingModuloSpanOfZero MagmaWithInverses MagmaWithInversesByGenerators MagmaWithInversesByMultiplicationTable MagmaWithOne MagmaWithOneByGenerators MagmaWithOneByMultiplicationTable MakeCanonical MakeConfluent MakeConsequences MakeConsequencesPres MakeFormulaVector MakeGAPDocDoc MakeHomChain MakeImagesInfoLinearGeneralMappingByImages MakeImmutable MakeKnuthBendixRewritingSystemConfluent MakeLIBTOMLIST MakeMagmaWithInversesByFiniteGenerators MakeMapping MakeMonomialOrdering MakePreImagesInfoLinearGeneralMappingByImages MakePreImagesInfoLinearMappingByMatrix MakePreImagesInfoOperationAlgebraHomomorphism MakeReadOnlyGVar MakeReadOnlyGlobal MakeReadWriteGVar MakeReadWriteGlobal MakeStabChainLong ManageableQuotientOfAbelianPGroup ManageableQuotientOfNilpotentGroup MappedExpression MappedExpressionForElementOfFreeAssociativeAlgebra MappedPcElement MappedVector MappedWord MappedWordSyllableAssocWord MappingByFunction MappingGeneratorsImages MappingOfWhichItIsAsGGMBI MappingPermListList MarksTom MatAlgebra MatAutomorphismsFamily MatCharsWreathSymmetric MatClassMultCoeffsCharTable MatLieAlgebra MatOrbs MatOrbsApprox MatScalarProducts MatSpace MatTom MathieuGroup MathieuGroupCons MatricesOfRelator MatrixAlgebra MatrixAutomorphisms MatrixByBlockMatrix MatrixDimension MatrixLieAlgebra MatrixNewBasePoint MatrixOfAction MatrixOperationOfCP MatrixOperationOfCPGroup MatrixSpace MatrixSpinCharsSn MaxHashViewSize MaxNumeratorCoeffAlgElm MaximalAbelianQuotient MaximalBlocks MaximalBlocksAttr MaximalBlocksOp MaximalNormalSubgroups MaximalSubgroupClassReps MaximalSubgroupClassesRepsLayer MaximalSubgroups MaximalSubgroupsLattice MaximalSubgroupsSymmAlt MaximalSubgroupsTom Maximum MaximumList MeetEquivalenceRelations MeetMagmaCongruences MeetMaps MeetPartitionStrat MeetPartitionStratCell MeetSemigroupCongruences MembershipTestKnownBase MinimalBlockDimension MinimalElementCosetStabChain MinimalGeneratingSet MinimalGensLayer MinimalNonmonomialGroup MinimalNormalSubgroups MinimalPolynomial MinimalPolynomialMatrixNC MinimalStabChain MinimalSupergroupsLattice MinimalSupergroupsTom MinimizeExplicitTransversal MinimizedBombieriNorm Minimum MinimumGroupOnSubgroupsOrbit MinimumList MinusCharacter ModGauss ModifyMinGens ModifyPcgs ModularCharacterDegree ModuleByRestriction ModuleOfExtension ModuloPcgs ModuloPcgsByPcSequence ModuloPcgsByPcSequenceNC ModuloTailPcgsByList ModulusOfZmodnZObj MoebiusMu MoebiusTom MolienSeries MolienSeriesInfo MolienSeriesWithGivenDenominator Monoid MonoidByGenerators MonoidByMultiplicationTable MonoidOfRewritingSystem MonomialComparisonFunction MonomialExtGrlexLess MonomialExtrepComparisonFun MonomialGrevlexOrdering MonomialGrlexOrdering MonomialLexOrdering MonomialOrderingsFamily MonomialTotalDegreeLess MorClassLoop MorClassOrbs MorFindGeneratingSystem MorFroWords MorMaxFusClasses MorRatClasses Morphium MorrisRecursion MostFrequentGeneratorFpGroup MovedPoints MovedPointsPerms MulExt MultCoeffs MultMatrixPadicNumbersByCoefficientsList MultRowVector MultiplicationTable MultiplicativeElementsWithInversesFamilyByRws MultiplicativeNeutralElement MultiplicativeZero MultiplicativeZeroOp Multiply MutableBasis MutableBasisOfClosureUnderAction MutableBasisOfIdealInNonassociativeAlgebra MutableBasisOfNonassociativeAlgebra MutableBasisOfProductSpace MutableCopyMat MutableIdentityMat MutableNullMat MutableTransposedMat MutableTransposedMatDestructive MyFingerprint MyIntCoefficients Naive Name NameFunction NameIsomorphismClass NameMonth NameRNam NameWeekDay NamesFilter NamesGVars NamesLibTom NamesLocalVariablesFunction NamesOfComponents NamesOfFusionSources NamesSystemGVars NamesUserGVars NaturalActedSpace NaturalCharacter NaturalHomomorphismByFixedPointSubspace NaturalHomomorphismByGenerators NaturalHomomorphismByHomVW NaturalHomomorphismByIdeal NaturalHomomorphismByInvariantSubspace NaturalHomomorphismByNilpotentClassTwoElement NaturalHomomorphismByNormalSubgroup NaturalHomomorphismByNormalSubgroupInParent NaturalHomomorphismByNormalSubgroupNC NaturalHomomorphismByNormalSubgroupNCInParent NaturalHomomorphismByNormalSubgroupNCOp NaturalHomomorphismByNormalSubgroupNCOrig NaturalHomomorphismByNormalSubgroupOp NaturalHomomorphismBySubAlgebraModule NaturalHomomorphismBySubspace NaturalHomomorphismBySubspaceOntoFullRowSpace NaturalHomomorphismsPool NaturalIsomorphismByPcgs NearAdditiveGroup NearAdditiveGroupByGenerators NearAdditiveMagma NearAdditiveMagmaByGenerators NearAdditiveMagmaWithInverses NearAdditiveMagmaWithInversesByGenerators NearAdditiveMagmaWithZero NearAdditiveMagmaWithZeroByGenerators NearlyCharacterTablesFamily NegativeRootVectors NegativeRoots NestingDepthA NestingDepthM NewAttribute NewCategory NewConstructor NewDictionary NewFamily NewFilter NewInfoClass NewOperation NewProperty NewRepresentation NewToBeDefinedObj NewType NewmanInfinityCriterion NextIterator NextLevelRegularGroups NextPrimeInt NextRBasePoint NextStepCentralizer NiceAlgebraMonomorphism NiceBasis NiceBasisFiltersInfo NiceBasisNC NiceFreeLeftModule NiceFreeLeftModuleForFLMLOR NiceFreeLeftModuleInfo NiceMonomorphism NiceMonomorphismAutomGroup NiceNormalFormByExtRepFunction NiceObject NiceVector NicomorphismOfFFEMatrixGroup NicomorphismOfGeneralMatrixGroup NilpotencyClassOfGroup NilpotentClassTwoElement NilpotentQuotientOfFpLieAlgebra NinKernelCSPG NonLieNilpotentElement NonNilpotentElement NonPerfectCSPG NonSplitExtensions NonTrivialRightHandSides NonassocWord NonnegIntScalarProducts NonnegativeIntegers NorSerPermPcgs Norm NormalBase NormalClosure NormalClosureByChain NormalClosureInParent NormalClosureOp NormalFormIntMat NormalIntersection NormalIntersectionPcgs NormalMaximalSubgroups NormalSeriesByPcgs NormalSubgroupClasses NormalSubgroupClassesInfo NormalSubgroups NormalSubgroupsAbove NormalSubgroupsCalc NormalizeNameAndKey NormalizeWhitespace NormalizedArgList NormalizedElementOfMagmaRingModuloRelations NormalizedNameAndKey NormalizedWhitespace Normalizer NormalizerInGLnZ NormalizerInGLnZBravaisGroup NormalizerInHomePcgs NormalizerInParent NormalizerOp NormalizerParentSA NormalizerStabCSPG NormalizerTom NormalizersTom NormalizingReducedGL NormedRowVector NormedRowVectors NormedVectors NotifiedFusionsOfLibTom NotifiedFusionsToLibTom NrAffinePrimitiveGroups NrArrangements NrArrangementsMSetA NrArrangementsMSetK NrArrangementsSetA NrArrangementsSetK NrArrangementsX NrBasisVectors NrBitsInt NrCombinations NrCombinationsMSetA NrCombinationsMSetK NrCombinationsSetA NrCombinationsSetK NrCombinationsX NrCompatiblePolynomials NrConjugacyClasses NrConjugacyClassesGL NrConjugacyClassesGU NrConjugacyClassesInSupergroup NrConjugacyClassesPGL NrConjugacyClassesPGU NrConjugacyClassesPSL NrConjugacyClassesPSU NrConjugacyClassesSL NrConjugacyClassesSLIsogeneous NrConjugacyClassesSU NrConjugacyClassesSUIsogeneous NrDerangements NrDerangementsK NrInputsOfStraightLineProgram NrIrreducibleSolvableGroups NrMovedPoints NrMovedPointsPerm NrMovedPointsPerms NrOrderedPartitions NrPartitionTuples NrPartitions NrPartitionsSet NrPerfectGroups NrPerfectLibraryGroups NrPermutationsList NrPolyhedralSubgroups NrPrimitiveGroups NrRestrictedPartitions NrRestrictedPartitionsK NrSmallGroups NrSolvableAffinePrimitiveGroups NrSubsTom NrSyllables NrTransitiveGroups NrTuples NrUnorderedTuples NthChainSubgroup NthFundamentalOrbit NthRoot NthSchreierTransversalOfChainSubgroup NthSiftOneLevel Nucleus NullAlgebra NullMapMatrix NullMat NullspaceIntMat NullspaceMat NullspaceMatDestructive NullspaceModQ NumBol Number NumberArgumentsFunction NumberCells NumberCoset NumberDigits NumberFFVector NumberField NumberGeneratorsOfRws NumberIrreducibleSolvableGroups NumberOfCommutators NumberOfNewGenerators NumberOp NumberPerfectGroups NumberPerfectLibraryGroups NumberSmallGroups NumberSyllables NumeratorOfModuloPcgs NumeratorOfRationalFunction NumeratorRat OCAddBigMatrices OCAddCentralizer OCAddComplement OCAddGenerators OCAddGeneratorsGeneral OCAddGeneratorsPcgs OCAddMatrices OCAddRelations OCAddSumMatrices OCAddToFunctions OCConjugatingWord OCCoprimeComplement OCEquationMatrix OCEquationVector OCNormalRelations OCOneCoboundaries OCOneCocycles OCSmallEquationMatrix OCSmallEquationVector OCTestRelations OCTestRelators ONanScottType ObjByExponents ObjByExtRep ObjByVector Objectify ObjectifyWithAttributes OccuringVariableIndices OctaveAlgebra OddSpinVals OldGeneratorsOfPresentation OldKernelHcommaC OldSubspaceVectorSpaceGroup Omega OmegaAndLowerPCentralSeries OmegaOp OmegaSeries OminusEven OnBreak OnBreakMessage OnCharReadHookExcFds OnCharReadHookExcFuncs OnCharReadHookExcStreams OnCharReadHookInFds OnCharReadHookInFuncs OnCharReadHookInStreams OnCharReadHookOutFds OnCharReadHookOutFuncs OnCharReadHookOutStreams OnCocycle OnIndeterminates OnLeftAntiOperation OnLeftInverse OnLines OnPairs OnPoints OnQuit OnRelVector OnRight OnSets OnSetsDisjointSets OnSetsSets OnSetsTuples OnSubspacesByCanonicalBasis OnTuples OnTuplesSets OnTuplesTuples One OneAttr OneCoboundaries OneCocycles OneFactorBound OneGroup OneImmutable OneIrreducibleSolvableGroup OneMutable OneNormalizerfixedBlockSystem OneOfPcgs OneOp OnePrimitiveGroup OneSM OneSameMutability OneSmallGroup OneTransitiveGroup OperationAlgebraHomomorphism OperatorOfExternalSet OplusEven OpmOdd OpmSmall OptionsStack Orbit OrbitByPosOp OrbitChar OrbitFusions OrbitGenerators OrbitGeneratorsInv OrbitGeneratorsOfGroup OrbitLength OrbitLengthOp OrbitLengths OrbitLengthsDomain OrbitOp OrbitPerms OrbitPowerMaps OrbitRepresentativesCharacters OrbitShortVectors OrbitSplit OrbitStabChain OrbitStabilizer OrbitStabilizerAlgorithm OrbitStabilizerOp OrbitStabilizingParentGroup OrbitalPartition OrbitishFO OrbitishReq Orbits OrbitsByPosOp OrbitsCharacters OrbitsDomain OrbitsPartition OrbitsPerms OrbitsishOperation OrbitsishReq Order OrderKnownDividendList OrderMatLimit OrderMatTrial OrderMod OrderModK OrderOfRewritingSystem OrderOfSchurLift OrderPerm OrderedPartitions OrderedPartitionsA OrderedPartitionsK OrderingByLessThanFunctionNC OrderingByLessThanOrEqualFunctionNC OrderingOfRewritingSystem OrderingOnGenerators OrderingsFamily OrdersClassRepresentatives OrdersTom Ordinal OrdinaryCharacterTable OrthogonalComponents OrthogonalEmbeddings OrthogonalEmbeddingsSpecialDimension OrthogonalSpaceInFullRowSpace OrthogonalityDefectEuclideanLattice OutdatePolycyclicCollector OutputLogTo OutputTextFile OutputTextFileStillOpen OutputTextFileType OutputTextNone OutputTextNoneType OutputTextString OutputTextStringType OutputTextUser OzeroEven OzeroOdd PBIsMinimal PCentralLieAlgebra PCentralNormalSeriesByPcgsPGroup PCentralSeries PCentralSeriesOp PClassPGroup PCore PCoreOp PCover PERFRec PGroupGeneratorsOfAbelianGroup PMultiplicator PQStatistics PQuotient PRIMGrp PRump PRumpOp PSLDegree PSLUnderlyingField PSp PackageInfo PackageVariablesInfo PadicCoefficients PadicExpansionByRat PadicExtensionNumberFamily PadicNumber Page PageDisplay Pager Parametrized Parent ParentAttr ParentPcgs ParityPol ParseArguments ParseBibFiles ParseError ParseTreeXMLString PartialClosureOfCongruence PartialOrderByOrderingFunction PartialOrderOfHasseDiagram Partition PartitionBacktrack PartitionSortedPoints PartitionStabilizerPermGroup PartitionTuples Partitions PartitionsA PartitionsGreatestEQ PartitionsGreatestLE PartitionsK PartitionsRecursively PartitionsSet PartitionsSetA PartitionsSetK PartitionsTest PcElementByExponents PcElementByExponentsNC PcGroupClassMatrixColumn PcGroupCode PcGroupCodeRec PcGroupFpGroup PcGroupFpGroupNC PcGroupWithPcgs PcSeries Pcgs PcgsByIndependentGeneratorsOfAbelianGroup PcgsByPcSequence PcgsByPcSequenceCons PcgsByPcSequenceNC PcgsCentralSeries PcgsChiefSeries PcgsElAbSerFromSpecPcgs PcgsElementaryAbelianSeries PcgsHomSoImPow PcgsMemberPcSeriesPermGroup PcgsPCentralSeriesPGroup PcgsStabChainSeries PcgsSystemLGSeries PcgsSystemWithComplementSystem PcgsSystemWithHallSystem PcgsSystemWithWf PerfGrpConst PerfGrpLoad PerfectCSPG PerfectCentralProduct PerfectGroup PerfectIdentification PerfectResiduum PerfectSubdirectProduct PerfectSubgroupsAlternatingGroup Perform PermBounds PermCandidates PermCandidatesFaithful PermCharInfo PermCharInfoRelative PermChars PermCharsTom PermComb PermLeftQuoTransformation PermList PermListList PermMatrixGroup PermNatAnTestDetect PermNewBasePoint PermOnEnumerator Permanent PermgpContainsAn PermpcgsPcGroupPcgs Permut Permutation PermutationCharacter PermutationCycle PermutationCycleOp PermutationGModule PermutationMat PermutationOp PermutationToSortCharacters PermutationToSortClasses PermutationTom PermutationsFamily PermutationsList PermutationsListK Permuted Phi PlainListCopy PlainListCopyOp PointInCellNo PolycyclicFactorGroup PolycyclicFactorGroupByRelators PolycyclicFactorGroupByRelatorsNC PolycyclicFactorGroupNC PolynomialByExtRep PolynomialByExtRepNC PolynomialCoefficientsOfPolynomial PolynomialDivisionAlgorithm PolynomialModP PolynomialReducedRemainder PolynomialReduction PolynomialRing PopOptions PosSublOdd PosVecEnumFF Position PositionBound PositionCanonical PositionFirstComponent PositionMatchingDelimiter PositionNonZero PositionNot PositionNthOccurrence PositionNthTrueBlist PositionProperty PositionSet PositionSorted PositionStream PositionSublist PositionWord PositionsTrueBlist PositiveExponentsPresentationFpHom PositiveIntegers PositiveRootVectors PositiveRoots PositiveRootsAsWeights PossibleClassFusions PossibleFusionsCharTableTom PossiblePowerMaps PostMakeImmutable Pover PowerDecompositions PowerMap PowerMapByComposition PowerMapOfGroup PowerMapOfGroupWithInvariants PowerMapOp PowerMapsAllowedBySymmetrisations PowerMapsAllowedBySymmetrizations PowerMod PowerModCoeffs PowerModEvalPol PowerModInt PowerPartition PowerPcgsElement PowerS PowerSi PowerSubalgebraSeries PowerWreath PowersumsElsyms PreBasis PreImage PreImageElm PreImageSetStabBlocksHomomorphism PreImageWord PreImages PreImagesElm PreImagesRange PreImagesRepresentative PreImagesRepresentativeOperationAlgebraHomomorphism PreImagesSet PreOrbishProcessing PreferredGenerators PrefrattiniSubgroup PreimagesOfTransformation Presentation PresentationAugmentedCosetTable PresentationFpGroup PresentationNormalClosure PresentationNormalClosureRrs PresentationRegularPermutationGroup PresentationRegularPermutationGroupNC PresentationSubgroup PresentationSubgroupMtc PresentationSubgroupRrs PresentationViaCosetTable PresentationsFamily PrevPrimeInt PriGroItNext PrimGrpLoad PrimaryGeneratorWords PrimeBlocks PrimeBlocksOp PrimeField PrimeOfPGroup PrimePGroup PrimePowerComponent PrimePowerComponents PrimePowerPcSequence PrimePowersInt PrimeResidues PrimeResiduesCache Primes PrimitiveElement PrimitiveFacExtRepRatPol PrimitiveGroup PrimitiveGroupSims PrimitiveGroupsIterator PrimitiveIdentification PrimitiveIndexIrreducibleSolvableGroup PrimitivePolynomial PrimitiveRoot PrimitiveRootMod Print PrintAmbiguity PrintArray PrintBibAsBib PrintBibAsHTML PrintBibAsText PrintCharacterTable PrintCounters PrintFactorsInt PrintFormattedString PrintFormattingStatus PrintGAPDocElementTemplates PrintHashWithNames PrintObj PrintPadicExpansion PrintRecIndent PrintSixFile PrintTo ProbabilityShapes Process ProcessFixpoint ProdCoefRatfun ProdCoeffLaurpol ProdCoeffUnivfunc Product ProductCoeffs ProductMod ProductOp ProductPP ProductPol ProductRootsPol ProductSpace ProductX ProductXHelp ProfileFunctions ProfileFunctionsInGlobalVariables ProfileGlobalFunctions ProfileMethods ProfileOperations ProfileOperationsAndMethods ProfileOperationsAndMethodsOff ProfileOperationsAndMethodsOn ProfileOperationsOff ProfileOperationsOn ProjectedInducedPcgs ProjectedPcElement Projection ProjectionMap ProjectionOntoFullRowSpace ProjectionOntoVectorSubspace ProjectiveActionHomomorphismMatrixGroup ProjectiveActionOnFullSpace ProjectiveCharDeg ProjectiveGeneralLinearGroup ProjectiveGeneralLinearGroupCons ProjectiveGeneralUnitaryGroup ProjectiveGeneralUnitaryGroupCons ProjectiveOrder ProjectiveSpecialLinearGroup ProjectiveSpecialLinearGroupCons ProjectiveSpecialUnitaryGroup ProjectiveSpecialUnitaryGroupCons ProjectiveSymplecticGroup ProjectiveSymplecticGroupCons PropertyMethodByNiceMonomorphism PropertyMethodByNiceMonomorphismCollColl PropertyMethodByNiceMonomorphismCollElm PropertyMethodByNiceMonomorphismElmColl PseudoRandom PseudoRandomSeed PthPowerImage PthPowerImages PullBack PullbackCSPG PullbackKernelCSPG PurePadicNumberFamily PushOptions Quadratic QuasiDihedralGenerators QuaternionAlgebra QuaternionGenerators QuickInverseRepresentative QuoInt QuotRemLaurpols QuotRemPolList QuotSysDefinitionByIndex QuotSysIndexByDefinition Quotient QuotientFromSCTable QuotientGroup QuotientGroupByChainHomomorphicImage QuotientGroupByHomomorphism QuotientGroupByImages QuotientGroupByImagesNC QuotientGroupHom QuotientMod QuotientPolynomialsExtRep QuotientRemainder QuotientSemigroupCongruence QuotientSemigroupHomomorphism QuotientSemigroupPreimage QuotientSystem RBaseGroupsBloxPermGroup RClassOfHClass RNamObj RPFactorsModPrime RPGcdCRT RPGcdModPrime RPGcdRepresentationModPrime RPIFactors RPIGcd RPQuotientModPrime RPSquareHensel RRefine RSSDefaultOptions RadicalGroup RadicalOfAlgebra RanImgSrcSurjBloho RanImgSrcSurjTraho Random RandomBinaryRelationOnPoints RandomByPcs RandomCommutatorSubproduct RandomElmAsWord RandomHashKey RandomInvertibleMat RandomIsomorphismTest RandomList RandomMat RandomNormalSubproduct RandomPcgsSylowSubgroup RandomPol RandomPrimitivePolynomial RandomSchreierSims RandomSpecialPcgsCoded RandomSubprod RandomTransformation RandomUnimodularMat Range Rank RankAction RankFilter RankMat RankMatDestructive RankOfTransformation RankPGroup RanksOfDescendingSeries Rat RatClasPElmArrangeClasses RatPairString RationalClass RationalClasses RationalClassesInEANS RationalClassesPElements RationalClassesPermGroup RationalClassesSolvableGroup RationalClassesTry RationalFunctionByExtRep RationalFunctionByExtRepWithCancellation RationalFunctionsFamily RationalIdentificationPermGroup RationalizedMat Rationals ReObjectify Read ReadAll ReadAllIoStreamByPty ReadAllLine ReadAndCheckFunc ReadAsFunction ReadByte ReadGapRoot ReadGrp ReadLib ReadLine ReadOrComplete ReadPackage ReadPkg ReadPrim ReadSmall ReadSmallLib ReadTest ReadTom ReadTrans RealClasses RealizableBrauerCharacters RecFields RecNames RecordsFamily RecurseSchreierTree RedispatchOnCondition ReduceCoefficientsOfRws ReduceCoeffs ReduceCoeffsMod ReduceLetterRepWordsRewSys ReduceRules ReduceStabChain ReduceWordUsingRewritingSystem Reduced ReducedAdditiveInverse ReducedByIsomorphisms ReducedCharacters ReducedClassFunctions ReducedComm ReducedConfluentRewritingSystem ReducedConfluentRwsFromKbrwsNC ReducedConjugate ReducedDifference ReducedForm ReducedGaloisStabilizerInfo ReducedGroebnerBasis ReducedInverse ReducedLeftQuotient ReducedOne ReducedOrdinary ReducedPcElement ReducedPower ReducedProduct ReducedQuotient ReducedRrsWord ReducedSCTable ReducedScalarProduct ReducedSum ReducedVectorLTM ReducedZero Ree ReeGroup ReeGroupCons ReesCongruenceOfSemigroupIdeal ReesMatrixSemigroup ReesMatrixSemigroupElement ReesMatrixSemigroupEnumeratorGetElement ReesZeroMatrixSemigroup ReesZeroMatrixSemigroupElement ReesZeroMatrixSemigroupElementIsZero ReesZeroMatrixSemigroupEnumeratorGetElement RefinedChain RefinedPcGroup RefinedSymmetrisations RefinedSymmetrizations Refinements ReflectionMat ReflexiveClosureBinaryRelation RegisterRBasePoint RegularActionHomomorphism RegularModule RegularModuleByGens RegularNinKernelCSPG RelVectorToCocycle RelationsOfFpMonoid RelationsOfFpSemigroup RelativeBasis RelativeBasisNC RelativeOrderOfPcElement RelativeOrders RelatorFixedMultiplier RelatorMatrixAbelianizedNormalClosure RelatorMatrixAbelianizedNormalClosureRrs RelatorMatrixAbelianizedSubgroup RelatorMatrixAbelianizedSubgroupMtc RelatorMatrixAbelianizedSubgroupRrs RelatorRepresentatives RelatorsCode RelatorsOfFpAlgebra RelatorsOfFpGroup RelatorsPermGroupHom RelsSortedByStartGen RelsViaCosetTable RemInt RemoveCharacters RemoveElmList RemoveFile RemoveOuterCoeffs RemoveRelator RemoveRootParseTree RemoveSet RemoveStabChain RenumberHighestWeightGenerators RenumberTree RenumberedWord RepOpElmTuplesPermGroup RepOpSetsPermGroup RepeatedString ReplacedString RepresentationsOfMatrix RepresentationsOfObject Representative RepresentativeAction RepresentativeActionOp RepresentativeFromGenerators RepresentativeLinearOperation RepresentativeSmallest RepresentativeTom RepresentativeTomByGenerators RepresentativeTomByGeneratorsNC RepresentativesContainedRightCosets RepresentativesFusions RepresentativesMinimalBlocks RepresentativesMinimalBlocksAttr RepresentativesMinimalBlocksOp RepresentativesPerfectSubgroups RepresentativesPowerMaps RepresentativesSimpleSubgroups RepsPerfSimpSub RequirePackage Reread RereadAndCheckFunc RereadGrp RereadLib RereadPackage RereadPkg RereadPrim RereadSmall RereadTrans ResetFilterObj ResetOptionsStack ResizeFlatHashTable ResizeListHashTable RespectsAddition RespectsAdditiveInverses RespectsInverses RespectsMultiplication RespectsOne RespectsScalarMultiplication RespectsZero RestoreStateRandom Restricted RestrictedClassFunction RestrictedClassFunctions RestrictedExternalSet RestrictedMapping RestrictedNiceMonomorphism RestrictedPartitions RestrictedPartitionsA RestrictedPartitionsK RestrictedPerm RestrictedTransformation ResultOfLineOfStraightLineProgram ResultOfStraightLineProgram Resultant ReturnFail ReturnFalse ReturnNextBasePoint ReturnPopOptions ReturnTrue Reversed ReversedOp Revision RewindStream RewriteAbelianizedSubgroupRelators RewriteSubgroupRelators RewriteWord RightActingAlgebra RightActingDomain RightActingGroup RightActingRingOfIdeal RightAction RightAlgebraModule RightAlgebraModuleByGenerators RightCoset RightCosetCanonicalRepresentativeDeterminator RightCosets RightCosetsNC RightDerivations RightIdeal RightIdealByGenerators RightIdealNC RightMagmaCongruence RightMagmaCongruenceByGeneratingPairs RightMagmaIdeal RightMagmaIdealByGenerators RightModuleByHomomorphismToMatAlg RightSemigroupCongruenceByGeneratingPairs RightSemigroupIdealEnumeratorDataGetElement RightShiftRowVector RightTransversal RightTransversalInParent RightTransversalOp RightTransversalPermGroupConstructor Ring RingByGenerators RingElmTimesElm RingFromFFE RingWithOne RingWithOneByGenerators Root RootBound RootInt RootMod RootModPrime RootModPrimePower RootOfDefiningPolynomial RootSystem RootsMod RootsModPrime RootsModPrimePower RootsOfUPol RootsRepresentativeFFPol RootsUnityMod RootsUnityModPrime RootsUnityModPrimePower RoundCyc RoundCycDown RowEchelonFormLTM RowIndexOfReesMatrixSemigroupElement RowIndexOfReesZeroMatrixSemigroupElement RowSpace RowsOfReesMatrixSemigroup RowsOfReesZeroMatrixSemigroup Rules RunImmediateMethods Runtime Runtimes SCMinSmaGens SCRExtend SCRExtendRecord SCRMakeStabStrong SCRNotice SCRRandomPerm SCRRandomString SCRRandomSubproduct SCRRestoredRecord SCRSchTree SCRSift SCRStrongGenTest SCTableEntry SCTableProduct SLDegree SLUnderlyingField SNFofREF SPolynomial SSortedList SSortedListList STDOut STGSelFunc SameBlock SandwichMatrixOfReesMatrixSemigroup SandwichMatrixOfReesZeroMatrixSemigroup SaveWorkspace ScalarProduct SchreierTransversal SchreierTreeDepth SchreierTreeInternalConsistencyCheck SchuMu SchurCover SchurCoverFP ScriptFromString Search SecHMSM SecondaryGeneratorWordsAugmentedCosetTable SecondaryImagesAugmentedCosetTable SecondsDMYhms SeekPositionStream SelectSmallGroups SelectTransitiveGroups SemiEchelonBasis SemiEchelonBasisNC SemiEchelonMat SemiEchelonMatDestructive SemiEchelonMatTransformation SemiEchelonMatTransformationDestructive SemiEchelonMats SemiEchelonMatsDestructive SemiEchelonMatsNoCo SemiSimpleType SemidirectFactorsOfGroup SemidirectProduct SemidirectProductInfo Semigroup SemigroupByGenerators SemigroupByMultiplicationTable SemigroupCongruenceByGeneratingPairs SemigroupIdealByGenerators SemigroupIdealEnumeratorDataGetElement SemigroupOfRewritingSystem SemigroupTCInitialTableSize SemigroupToddCoxeterInfo Semiring SemiringByGenerators SemiringWithOne SemiringWithOneAndZero SemiringWithOneAndZeroByGenerators SemiringWithOneByGenerators SemiringWithZero SemiringWithZeroByGenerators SeqsOrbits Set SetANonReesCongruenceOfSemigroup SetAbelianInvariants SetAbelianInvariantsOfList SetAbsoluteValue SetActingDomain SetActionHomomorphismAttr SetActionKernelExternalSet SetActorOfExternalSet SetActualLibFileName SetAdditiveElementAsMultiplicativeElement SetAdditiveElementsAsMultiplicativeElementsFamily SetAdditiveInverse SetAdditiveInverseAttr SetAdditiveInverseImmutable SetAdditiveNeutralElement SetAdditivelyActingDomain SetAdjointBasis SetAdjointModule SetAlgebraicElementsFamilies SetAllBlocks SetAllInfoLevels SetAlpha SetAlternatingDegree SetAlternatingSubgroup SetAsDuplicateFreeList SetAsGroup SetAsGroupGeneralMappingByImages SetAsLeftModuleGeneralMappingByImages SetAsList SetAsMagma SetAsMonoid SetAsNearRing SetAsPolynomial SetAsRing SetAsSSortedList SetAsSemigroup SetAsSemiring SetAsSemiringWithOne SetAsSemiringWithOneAndZero SetAsSemiringWithZero SetAsSortedList SetAsSubgroupOfWholeGroupByQuotient SetAssertionLevel SetAssociatedReesMatrixSemigroupOfDClass SetAssociatedSemigroup SetAugmentationIdeal SetAugmentedCosetTableMtcInWholeGroup SetAugmentedCosetTableNormalClosureInWholeGroup SetAugmentedCosetTableRrsInWholeGroup SetAutomorphismDomain SetAutomorphismGroup SetAutomorphismsOfTable SetBaseIntMat SetBaseMat SetBaseOfBasicImageGroup SetBaseOfGroup SetBaseOrthogonalSpaceMat SetBasis SetBasisOfHomCosetAddMatrixGroup SetBasisVectors SetBaumClausenInfo SetBilinearFormMat SetBlocksAttr SetBlocksInfo SetBrauerCharacterValue SetBravaisGroup SetBravaisSubgroups SetBravaisSupergroups SetCanEasilyCompareElements SetCanEasilySortElements SetCanFindNilpotentClassTwoElement SetCanonicalBasis SetCanonicalElt SetCanonicalGenerators SetCanonicalNiceMonomorphism SetCanonicalPcgs SetCanonicalPcgsWrtFamilyPcgs SetCanonicalPcgsWrtHomePcgs SetCanonicalPcgsWrtSpecialPcgs SetCanonicalRepresentativeDeterminatorOfExternalSet SetCanonicalRepresentativeOfExternalOrbitByPcgs SetCanonicalRepresentativeOfExternalSet SetCartanMatrix SetCartanSubalgebra SetCayleyGraphDualSemigroup SetCayleyGraphSemigroup SetCenter SetCentralCharacter SetCentralIdempotentsOfSemiring SetCentralNormalSeriesByPcgs SetCentralizerInGLnZ SetCentralizerInParent SetCentre SetCentreOfCharacter SetChainSubgroup SetChainSubgroupQuotient SetCharacterDegrees SetCharacterNames SetCharacterParameters SetCharacteristic SetCharacteristicPolynomial SetChevalleyBasis SetChiefNormalSeriesByPcgs SetChiefSeries SetClassNames SetClassNamesTom SetClassParameters SetClassPermutation SetClassPositionsOfCentre SetClassPositionsOfDerivedSubgroup SetClassPositionsOfDirectProductDecompositions SetClassPositionsOfElementaryAbelianSeries SetClassPositionsOfFittingSubgroup SetClassPositionsOfKernel SetClassPositionsOfLowerCentralSeries SetClassPositionsOfMaximalNormalSubgroups SetClassPositionsOfNormalSubgroups SetClassPositionsOfSolvableResiduum SetClassPositionsOfSupersolvableResiduum SetClassPositionsOfUpperCentralSeries SetClassRoots SetClassTypesTom SetCoKernelOfAdditiveGeneralMapping SetCoKernelOfMultiplicativeGeneralMapping SetCoefficientsAndMagmaElements SetCoefficientsFamily SetCoefficientsOfLaurentPolynomial SetCoefficientsOfUnivariatePolynomial SetCoefficientsOfUnivariateRationalFunction SetCoefficientsRing SetCollectionsFamily SetColumnIndexOfReesMatrixSemigroupElement SetColumnIndexOfReesZeroMatrixSemigroupElement SetColumnsOfReesMatrixSemigroup SetColumnsOfReesZeroMatrixSemigroup SetCommutator SetCommutatorANC SetCommutatorFactorGroup SetCommutatorLength SetCommutatorNC SetComplementSystem SetComplexConjugate SetComponentsOfTuplesFamily SetCompositionSeries SetComputedAgemos SetComputedAscendingChains SetComputedBrauerTables SetComputedClassFusions SetComputedCyclicExtensionsTom SetComputedHallSubgroups SetComputedIndicators SetComputedIsPNilpotents SetComputedIsPSolvableCharacterTables SetComputedIsPSolvables SetComputedOmegas SetComputedPCentralSeriess SetComputedPCores SetComputedPRumps SetComputedPowerMaps SetComputedPrimeBlockss SetComputedSylowComplements SetComputedSylowSubgroups SetConductor SetConfluentRws SetConjugacyClasses SetConjugacyClassesMaximalSubgroups SetConjugacyClassesPerfectSubgroups SetConjugacyClassesSubgroups SetConjugate SetConjugateANC SetConjugateNC SetConjugates SetConjugatorInnerAutomorphism SetConjugatorOfConjugatorIsomorphism SetConstantTimeAccessList SetConstituentsOfCharacter SetConvertBasicImageGroupElement SetCoreInParent SetCosetTableFpHom SetCosetTableInWholeGroup SetCosetTableNormalClosureInWholeGroup SetCosetTableOfFpSemigroup SetCrystGroupDefaultAction SetCycleStructurePerm SetCyclicExtensionsTom SetDataType SetDecompositionMatrix SetDecompositionTypesOfGroup SetDefaultFieldOfMatrix SetDefaultFieldOfMatrixGroup SetDefectApproximation SetDefiningPcgs SetDefiningPolynomial SetDefinitionNC SetDegreeAction SetDegreeOfBinaryRelation SetDegreeOfCharacter SetDegreeOfLaurentPolynomial SetDegreeOfMatrixGroup SetDegreeOfTransformation SetDegreeOfTransformationSemigroup SetDegreeOperation SetDegreeOverPrimeField SetDelta SetDenominatorOfModuloPcgs SetDenominatorOfRationalFunction SetDepthOfUpperTriangularMatrix SetDerivations SetDerivative SetDerivedLength SetDerivedSeriesOfGroup SetDerivedSubgroup SetDerivedSubgroupsTomPossible SetDerivedSubgroupsTomUnique SetDeterminantMat SetDeterminantOfCharacter SetDihedralGenerators SetDimension SetDimensionOfMatrixGroup SetDimensionOfVectors SetDimensionsLoewyFactors SetDimensionsMat SetDirectFactorsOfGroup SetDirectProductInfo SetDirectSumDecomposition SetDisplayOptions SetDixonRecord SetEANormalSeriesByPcgs SetEarns SetEggBoxOfDClass SetElementTestFunction SetElementaryAbelianSeries SetElementaryAbelianSeriesLargeSteps SetElementaryAbelianSubseries SetElementsFamily SetElmWPObj SetEmptyRowVector SetEntrySCTable SetEnumerator SetEnumeratorByBasis SetEnumeratorSorted SetEquivalenceClassRelation SetEquivalenceClasses SetEquivalenceRelationPartition SetErrorHandler SetExponent SetExponentOfPowering SetExtRepDenominatorRatFun SetExtRepNumeratorRatFun SetExtRepPolynomialRatFun SetExternalOrbits SetExternalOrbitsStabilizers SetExternalSet SetFactorsOfDirectProduct SetFaithfulModule SetFamiliesOfGeneralMappingsAndRanges SetFamilyForOrdering SetFamilyForRewritingSystem SetFamilyPcgs SetFamilyRange SetFamilySource SetFeatureObj SetFieldOfMatrixGroup SetFilterObj SetFittingSubgroup SetFpElmComparisonMethod SetFpElmEqualityMethod SetFpElmKBRWS SetFrattiniSubgroup SetFrattinifactorId SetFrattinifactorSize SetFreeAlgebraOfFpAlgebra SetFreeGeneratorsOfFpAlgebra SetFreeGeneratorsOfFpGroup SetFreeGeneratorsOfFpMonoid SetFreeGeneratorsOfFpSemigroup SetFreeGroupOfBasicImageGroup SetFreeGroupOfFpGroup SetFreeMonoidOfFpMonoid SetFreeMonoidOfRewritingSystem SetFreeSemigroupOfFpSemigroup SetFreeSemigroupOfRewritingSystem SetFrobeniusAutomorphism SetFunctionAction SetFusionConjugacyClassesOp SetFusionsOfLibTom SetFusionsToLibTom SetFusionsTom SetGLDegree SetGLUnderlyingField SetGaloisGroup SetGaloisMat SetGaloisStabilizer SetGaloisType SetGapDocHTMLOptions SetGapDocLaTeXOptions SetGapDocTxtOptions SetGasmanMessageStatus SetGeneralizedPcgs SetGeneratingPairsOfLeftMagmaCongruence SetGeneratingPairsOfMagmaCongruence SetGeneratingPairsOfRightMagmaCongruence SetGeneratingSetIsComplete SetGeneratorOfCyclicGroup SetGeneratorsOfAdditiveGroup SetGeneratorsOfAdditiveMagma SetGeneratorsOfAdditiveMagmaWithInverses SetGeneratorsOfAdditiveMagmaWithZero SetGeneratorsOfAlgebra SetGeneratorsOfAlgebraModule SetGeneratorsOfAlgebraWithOne SetGeneratorsOfDivisionRing SetGeneratorsOfDomain SetGeneratorsOfEquivalenceRelationPartition SetGeneratorsOfExtASet SetGeneratorsOfExtLSet SetGeneratorsOfExtRSet SetGeneratorsOfExtUSet SetGeneratorsOfFLMLOR SetGeneratorsOfFLMLORWithOne SetGeneratorsOfField SetGeneratorsOfGroup SetGeneratorsOfIdeal SetGeneratorsOfLeftIdeal SetGeneratorsOfLeftMagmaIdeal SetGeneratorsOfLeftModule SetGeneratorsOfLeftOperatorAdditiveGroup SetGeneratorsOfLeftOperatorRing SetGeneratorsOfLeftOperatorRingWithOne SetGeneratorsOfLeftVectorSpace SetGeneratorsOfMagma SetGeneratorsOfMagmaIdeal SetGeneratorsOfMagmaWithInverses SetGeneratorsOfMagmaWithOne SetGeneratorsOfMonoid SetGeneratorsOfNearAdditiveGroup SetGeneratorsOfNearAdditiveMagma SetGeneratorsOfNearAdditiveMagmaWithInverses SetGeneratorsOfNearAdditiveMagmaWithZero SetGeneratorsOfRightIdeal SetGeneratorsOfRightMagmaIdeal SetGeneratorsOfRightModule SetGeneratorsOfRightOperatorAdditiveGroup SetGeneratorsOfRing SetGeneratorsOfRingWithOne SetGeneratorsOfRws SetGeneratorsOfSemigroup SetGeneratorsOfSemiring SetGeneratorsOfSemiringWithOne SetGeneratorsOfSemiringWithOneAndZero SetGeneratorsOfSemiringWithZero SetGeneratorsOfTwoSidedIdeal SetGeneratorsOfVectorSpace SetGeneratorsSmallest SetGeneratorsSubgroupsTom SetGlobalPartitionOfClasses SetGrading SetGreensDRelation SetGreensHRelation SetGreensJRelation SetGreensLRelation SetGreensRRelation SetGroupByPcgs SetGroupHClassOfGreensDClass SetGroupOfPcgs SetHallSystem SetHashEntry SetHashEntryAtLastIndex SetHelpViewer SetHirschLength SetHomCosetFamily SetHomFromFreeOfBasicImageGroup SetHomeEnumerator SetHomePcgs SetIBr SetIdGroup SetIdempotents SetIdempotentsTom SetIdempotentsTomInfo SetIdentificationOfConjugacyClasses SetIdentifier SetIdentity SetIdentityMapping SetImage SetImageElt SetImageListOfTransformation SetImageSetOfTransformation SetImagesSmallestGenerators SetImagesSource SetImfRecord SetIndependentGeneratorsOfAbelianGroup SetIndependentGeneratorsOfAbelianMatrixGroup SetIndeterminateName SetIndeterminateNumberOfLaurentPolynomial SetIndeterminateNumberOfUnivariateLaurentPolynomial SetIndeterminateNumberOfUnivariateRationalFunction SetIndeterminateOfUnivariateRationalFunction SetIndeterminatesOfPolynomialRing SetIndexInParent SetIndexInWholeGroup SetIndicesCentralNormalSteps SetIndicesChiefNormalSteps SetIndicesEANormalSteps SetIndicesInvolutaryGenerators SetIndicesNormalSteps SetIndicesOfAdjointBasis SetIndicesPCentralNormalStepsPGroup SetInducedPcgs SetInducedPcgsWrtFamilyPcgs SetInducedPcgsWrtHomePcgs SetInducedPcgsWrtSpecialPcgs SetInfoLevel SetInfoText SetInjectionZeroMagma SetInnerAutomorphismsAutomorphismGroup SetInt SetInternalRepresentative SetInvariantBilinearForm SetInvariantForm SetInvariantLattice SetInvariantQuadraticForm SetInvariantSesquilinearForm SetInverse SetInverseAttr SetInverseClasses SetInverseGeneralMapping SetInverseImmutable SetIrr SetIrrBaumClausen SetIrrConlon SetIrrDixonSchneider SetIrrFacsPol SetIrreducibleRepresentations SetIsAbelian SetIsAbelianNumberField SetIsAbelianTom SetIsAdditiveGroupGeneralMapping SetIsAdditiveGroupHomomorphism SetIsAdditiveGroupToGroupGeneralMapping SetIsAdditiveGroupToGroupHomomorphism SetIsAdditivelyCommutative SetIsAlgebraGeneralMapping SetIsAlgebraHomomorphism SetIsAlgebraModule SetIsAlgebraWithOneGeneralMapping SetIsAlgebraWithOneHomomorphism SetIsAlternatingGroup SetIsAnticommutative SetIsAntisymmetricBinaryRelation SetIsAssociative SetIsAutomorphismGroup SetIsBasicWreathProductOrdering SetIsBergerCondition SetIsBijective SetIsBravaisGroup SetIsBuiltFromAdditiveMagmaWithInverses SetIsBuiltFromGroup SetIsBuiltFromMagma SetIsBuiltFromMagmaWithInverses SetIsBuiltFromMagmaWithOne SetIsBuiltFromMonoid SetIsBuiltFromSemigroup SetIsCanonicalBasis SetIsCanonicalBasisFullMatrixModule SetIsCanonicalBasisFullRowModule SetIsCanonicalBasisFullSCAlgebra SetIsCanonicalNiceMonomorphism SetIsCanonicalPcgs SetIsCanonicalPcgsWrtSpecialPcgs SetIsChainTypeGroup SetIsCharacter SetIsCharacteristicMatrixPGroup SetIsCommutative SetIsCommutativeFamily SetIsConfluent SetIsConjugatorAutomorphism SetIsConjugatorIsomorphism SetIsConstantRationalFunction SetIsConstantTimeAccessGeneralMapping SetIsCycInt SetIsCyclic SetIsCyclicTom SetIsCyclicWithSize SetIsCyclotomicField SetIsDihedralGroup SetIsDistributive SetIsDivisionRing SetIsDuplicateFree SetIsDuplicateFreeList SetIsElementaryAbelian SetIsEmpty SetIsEndoGeneralMapping SetIsEndoMapping SetIsEquivalenceRelation SetIsFFEMatrixGroupOverLargeSpace SetIsFamilyPcgs SetIsField SetIsFieldHomomorphism SetIsFinite SetIsFiniteDimensional SetIsFiniteOrdersPcgs SetIsFiniteSemigroupGreensRelation SetIsFinitelyGeneratedGroup SetIsFrattiniFree SetIsFreeMonoid SetIsFreeSemigroup SetIsFullFpAlgebra SetIsFullHomModule SetIsFullMatrixModule SetIsFullRowModule SetIsFullSCAlgebra SetIsFullSubgroupGLorSLRespectingBilinearForm SetIsFullSubgroupGLorSLRespectingQuadraticForm SetIsFullSubgroupGLorSLRespectingSesquilinearForm SetIsFullTransformationSemigroup SetIsGL SetIsGeneralLinearGroup SetIsGeneralizedCartanMatrix SetIsGeneratorsOfMagmaWithInverses SetIsGreensClass SetIsGreensDClass SetIsGreensDRelation SetIsGreensHClass SetIsGreensHRelation SetIsGreensJClass SetIsGreensJRelation SetIsGreensLClass SetIsGreensLRelation SetIsGreensRClass SetIsGreensRRelation SetIsGreensRelation SetIsGroupGeneralMapping SetIsGroupHClass SetIsGroupHomomorphism SetIsGroupOfAutomorphisms SetIsGroupOfAutomorphismsFiniteGroup SetIsGroupRing SetIsGroupToAdditiveGroupGeneralMapping SetIsGroupToAdditiveGroupHomomorphism SetIsHandledByNiceMonomorphism SetIsHasseDiagram SetIsHomCosetOfAdditiveElt SetIsHomCosetOfFp SetIsHomCosetOfMatrix SetIsHomCosetOfPerm SetIsHomCosetOfTuple SetIsIdealInParent SetIsIdempotent SetIsImpossible SetIsInducedFromNormalSubgroup SetIsInducedPcgsWrtSpecialPcgs SetIsInjective SetIsInnerAutomorphism SetIsIntegerMatrixGroup SetIsIntegralBasis SetIsIntegralCyclotomic SetIsIntegralRing SetIsIrreducibleCharacter SetIsJacobianRing SetIsLDistributive SetIsLatticeOrderBinaryRelation SetIsLaurentPolynomial SetIsLeftActedOnByDivisionRing SetIsLeftAlgebraModule SetIsLeftIdealInParent SetIsLeftModuleGeneralMapping SetIsLeftModuleHomomorphism SetIsLeftSemigroupCongruence SetIsLeftSemigroupIdeal SetIsLieAbelian SetIsLieAlgebra SetIsLieNilpotent SetIsLieSolvable SetIsLinearlyPrimitive SetIsMagmaHomomorphism SetIsMapping SetIsMatrixModule SetIsMinimalNonmonomial SetIsMonoid SetIsMonomialCharacter SetIsMonomialCharacterTable SetIsMonomialGroup SetIsMonomialMatrix SetIsMonomialNumber SetIsNaturalAlternatingGroup SetIsNaturalGL SetIsNaturalSL SetIsNaturalSymmetricGroup SetIsNearRing SetIsNearRingWithOne SetIsNilpQuotientSystem SetIsNilpotentCharacterTable SetIsNilpotentGroup SetIsNilpotentTom SetIsNonTrivial SetIsNoncharacteristicMatrixPGroup SetIsNormalBasis SetIsNormalForm SetIsNormalInParent SetIsNumberField SetIsNumeratorParentPcgsFamilyPcgs SetIsOne SetIsOrderingOnFamilyOfAssocWords SetIsPGroup SetIsPQuotientSystem SetIsPSL SetIsParentPcgsFamilyPcgs SetIsPartialOrderBinaryRelation SetIsPcgsCentralSeries SetIsPcgsChiefSeries SetIsPcgsElementaryAbelianSeries SetIsPcgsPCentralSeriesPGroup SetIsPerfectCharacterTable SetIsPerfectGroup SetIsPerfectTom SetIsPolycyclicGroup SetIsPolynomial SetIsPositionsList SetIsPreOrderBinaryRelation SetIsPrimeField SetIsPrimeOrdersPcgs SetIsPrimitive SetIsPrimitiveAffine SetIsPrimitiveCharacter SetIsPrimitiveMatrixGroup SetIsPseudoCanonicalBasisFullHomModule SetIsQuasiDihedralGroup SetIsQuasiPrimitive SetIsQuaternionGroup SetIsRDistributive SetIsRationalMatrixGroup SetIsRectangularTable SetIsReduced SetIsReesCongruence SetIsReesCongruenceSemigroup SetIsReesMatrixSemigroup SetIsReesZeroMatrixSemigroup SetIsReflexiveBinaryRelation SetIsRegular SetIsRegularDClass SetIsRegularSemigroup SetIsRelativelySM SetIsRestrictedLieAlgebra SetIsRightAlgebraModule SetIsRightIdealInParent SetIsRightSemigroupCongruence SetIsRightSemigroupIdeal SetIsRing SetIsRingGeneralMapping SetIsRingHomomorphism SetIsRingWithOne SetIsRingWithOneGeneralMapping SetIsRingWithOneHomomorphism SetIsRowModule SetIsSL SetIsSSortedList SetIsSemiEchelonized SetIsSemiRegular SetIsSemigroup SetIsSemigroupCongruence SetIsSemigroupIdeal SetIsSemiring SetIsSemiringWithOne SetIsSemiringWithOneAndZero SetIsSemiringWithZero SetIsShortLexOrdering SetIsSimpleAlgebra SetIsSimpleCharacterTable SetIsSimpleGroup SetIsSimpleSemigroup SetIsSingleValued SetIsSkewFieldFamily SetIsSmallList SetIsSolvableCharacterTable SetIsSolvableGroup SetIsSolvableTom SetIsSortedList SetIsSpecialLinearGroup SetIsSpecialPcgs SetIsSporadicSimpleCharacterTable SetIsSporadicSimpleGroup SetIsStabChainViaChainSubgroup SetIsSubgroupSL SetIsSubmonoidFpMonoid SetIsSubnormallyMonomial SetIsSubsemigroupFpSemigroup SetIsSubsemigroupReesMatrixSemigroup SetIsSubsemigroupReesZeroMatrixSemigroup SetIsSubsetLocallyFiniteGroup SetIsSupersolvableCharacterTable SetIsSupersolvableGroup SetIsSurjective SetIsSymmetricBinaryRelation SetIsSymmetricGroup SetIsTotal SetIsTotalOrdering SetIsTransformationMonoid SetIsTransformationSemigroup SetIsTransitive SetIsTransitiveBinaryRelation SetIsTranslationInvariantOrdering SetIsTrivial SetIsTwoSidedIdealInParent SetIsUFDFamily SetIsUniformMatrixGroup SetIsUnivariatePolynomial SetIsUnivariateRationalFunction SetIsVectorSpaceHomomorphism SetIsVirtualCharacter SetIsWeightLexOrdering SetIsWellFoundedOrdering SetIsWeylGroup SetIsWholeFamily SetIsWreathProductOrdering SetIsZero SetIsZeroGroup SetIsZeroMultiplicationRing SetIsZeroRationalFunction SetIsZeroSimpleSemigroup SetIsZeroSquaredRing SetIsomorphismFpAlgebra SetIsomorphismFpFLMLOR SetIsomorphismFpGroup SetIsomorphismFpMonoid SetIsomorphismFpSemigroup SetIsomorphismMatrixAlgebra SetIsomorphismMatrixFLMLOR SetIsomorphismPcGroup SetIsomorphismPermGroup SetIsomorphismReesMatrixSemigroup SetIsomorphismRefinedPcGroup SetIsomorphismSCAlgebra SetIsomorphismSCFLMLOR SetIsomorphismSimplifiedFpGroup SetIsomorphismSpecialPcGroup SetIsomorphismTransformationSemigroup SetJenningsLieAlgebra SetJenningsSeries SetJordanDecomposition SetKernelOfAdditiveGeneralMapping SetKernelOfCharacter SetKernelOfMultiplicativeGeneralMapping SetKernelOfTransformation SetKillingMatrix SetKnowsHowToDecompose SetLClassOfHClass SetLGFirst SetLGHeads SetLGLayers SetLGLength SetLGTails SetLGWeights SetLargestElementGroup SetLargestMovedPoint SetLargestMovedPointPerm SetLatticeGeneratorsInUEA SetLatticeSubgroups SetLeadCoeffsIGS SetLeftActingAlgebra SetLeftActingDomain SetLeftActingGroup SetLeftActingRingOfIdeal SetLeftDerivations SetLength SetLengthsTom SetLessThanFunction SetLessThanOrEqualFunction SetLetterRepWordsLessFunc SetLevelsOfGenerators SetLeviMalcevDecomposition SetLieAlgebraByDomain SetLieCenter SetLieCentralizerInParent SetLieCentre SetLieDerivedSeries SetLieDerivedSubalgebra SetLieFamily SetLieLowerCentralSeries SetLieNilRadical SetLieNormalizerInParent SetLieObject SetLieSolvableRadical SetLieUpperCentralSeries SetLinearActionBasis SetLinearCharacters SetLinesOfStraightLineProgram SetLongestWeylWordPerm SetLowerCentralSeriesOfGroup SetMagmaGeneratorsOfFamily SetMappingGeneratorsImages SetMappingOfWhichItIsAsGGMBI SetMarksTom SetMatTom SetMatrixByBlockMatrix SetMatrixDimension SetMaximalAbelianQuotient SetMaximalBlocksAttr SetMaximalNormalSubgroups SetMaximalSubgroupClassReps SetMaximalSubgroups SetMaximalSubgroupsLattice SetMaximalSubgroupsTom SetMinimalBlockDimension SetMinimalGeneratingSet SetMinimalNormalSubgroups SetMinimalStabChain SetMinimalSupergroupsLattice SetMinimizedBombieriNorm SetModuleOfExtension SetModulusOfZmodnZObj SetMoebiusTom SetMolienSeriesInfo SetMonoidOfRewritingSystem SetMonomialComparisonFunction SetMonomialExtrepComparisonFun SetMovedPoints SetMultipleAttributes SetMultiplicationTable SetMultiplicativeNeutralElement SetMultiplicativeZero SetName SetNameIsomorphismClass SetNamesLibTom SetNamesOfFusionSources SetNaturalCharacter SetNaturalHomomorphismByNormalSubgroupNCInParent SetNaturalHomomorphismsPool SetNegativeRootVectors SetNegativeRoots SetNestingDepthA SetNestingDepthM SetNiceAlgebraMonomorphism SetNiceBasis SetNiceFreeLeftModule SetNiceFreeLeftModuleInfo SetNiceMonomorphism SetNiceNormalFormByExtRepFunction SetNiceObject SetNilpotencyClassOfGroup SetNilpotentClassTwoElement SetNonLieNilpotentElement SetNonNilpotentElement SetNorm SetNormalBase SetNormalClosureInParent SetNormalMaximalSubgroups SetNormalSeriesByPcgs SetNormalSubgroupClassesInfo SetNormalSubgroups SetNormalizerInGLnZ SetNormalizerInGLnZBravaisGroup SetNormalizerInHomePcgs SetNormalizerInParent SetNormalizersTom SetNormedRowVector SetNormedRowVectors SetNormedVectors SetNotifiedFusionsOfLibTom SetNotifiedFusionsToLibTom SetNrConjugacyClasses SetNrInputsOfStraightLineProgram SetNrMovedPoints SetNrMovedPointsPerm SetNrSubsTom SetNrSyllables SetNullAlgebra SetNullspaceIntMat SetNullspaceMat SetNumberGeneratorsOfRws SetNumberSyllables SetNumeratorOfModuloPcgs SetNumeratorOfRationalFunction SetONanScottType SetOccuringVariableIndices SetOmegaAndLowerPCentralSeries SetOmegaSeries SetOne SetOneAttr SetOneImmutable SetOneOfPcgs SetOperatorOfExternalSet SetOrbitGeneratorsOfGroup SetOrbitLengths SetOrbitLengthsDomain SetOrbitStabilizingParentGroup SetOrbits SetOrbitsDomain SetOrder SetOrderingOfRewritingSystem SetOrderingOnGenerators SetOrderingsFamily SetOrdersClassRepresentatives SetOrdersTom SetOrdinaryCharacterTable SetOrthogonalSpaceInFullRowSpace SetPCentralLieAlgebra SetPCentralNormalSeriesByPcgsPGroup SetPClassPGroup SetPSLDegree SetPSLUnderlyingField SetPackageInfo SetParent SetParentAttr SetParentPcgs SetPartialClosureOfCongruence SetPartialOrderOfHasseDiagram SetPcGroupWithPcgs SetPcSeries SetPcgs SetPcgsCentralSeries SetPcgsChiefSeries SetPcgsElementaryAbelianSeries SetPcgsPCentralSeriesPGroup SetPerfectIdentification SetPerfectResiduum SetPermutationTom SetPositiveRootVectors SetPositiveRoots SetPositiveRootsAsWeights SetPower SetPowerANC SetPowerNC SetPowerS SetPowerSubalgebraSeries SetPreBasis SetPreImagesRange SetPreferredGenerators SetPrefrattiniSubgroup SetPresentation SetPrimaryGeneratorWords SetPrimeField SetPrimePGroup SetPrimePowerComponents SetPrimitiveElement SetPrimitiveIdentification SetPrimitiveRoot SetPrintFormattingStatus SetProjectiveOrder SetPseudoRandomSeed SetPthPowerImages SetQuasiDihedralGenerators SetQuaternionGenerators SetQuotientGroup SetQuotientGroupHom SetQuotientSemigroupCongruence SetQuotientSemigroupHomomorphism SetQuotientSemigroupPreimage SetRClassOfHClass SetRadicalGroup SetRadicalOfAlgebra SetRange SetRankAction SetRankMat SetRankOfTransformation SetRankPGroup SetRat SetRationalClasses SetRationalFunctionsFamily SetRationalizedMat SetRealClasses SetRecNames SetRecursionTrapInterval SetReducedConfluentRewritingSystem SetReducedMultiplication SetReesCongruenceOfSemigroupIdeal SetReesZeroMatrixSemigroupElementIsZero SetRefinedPcGroup SetRegularActionHomomorphism SetRelationsOfFpMonoid SetRelationsOfFpSemigroup SetRelativeOrder SetRelativeOrderNC SetRelativeOrders SetRelatorsOfFpAlgebra SetRelatorsOfFpGroup SetRepresentative SetRepresentativeSmallest SetRepresentativesContainedRightCosets SetRepresentativesMinimalBlocksAttr SetRepresentativesPerfectSubgroups SetRepresentativesSimpleSubgroups SetRespectsAddition SetRespectsAdditiveInverses SetRespectsInverses SetRespectsMultiplication SetRespectsOne SetRespectsScalarMultiplication SetRespectsZero SetRightActingAlgebra SetRightActingDomain SetRightActingGroup SetRightActingRingOfIdeal SetRightDerivations SetRightTransversalInParent SetRootOfDefiningPolynomial SetRootSystem SetRowIndexOfReesMatrixSemigroupElement SetRowIndexOfReesZeroMatrixSemigroupElement SetRowsOfReesMatrixSemigroup SetRowsOfReesZeroMatrixSemigroup SetRules SetSLDegree SetSLUnderlyingField SetSandwichMatrixOfReesMatrixSemigroup SetSandwichMatrixOfReesZeroMatrixSemigroup SetSemiEchelonBasis SetSemiEchelonMat SetSemiEchelonMatTransformation SetSemiSimpleType SetSemidirectFactorsOfGroup SetSemidirectProductInfo SetSemigroupOfRewritingSystem SetSiftFunction SetSiftGroup SetSignPerm SetSimpleSystem SetSimsNo SetSize SetSizesCentralizers SetSizesConjugacyClasses SetSmallGeneratingSet SetSmallestGeneratorPerm SetSmallestMovedPoint SetSmallestMovedPointPerm SetSocle SetSocleComplement SetSocleDimensions SetSocleTypePrimitiveGroup SetSortingPerm SetSource SetSparseCartanMatrix SetSpecialPcgs SetSplittingField SetStabChainImmutable SetStabChainMutable SetStabChainOptions SetStabilizerOfExternalSet SetStandardGeneratorsInfo SetStoredExcludedOrders SetStoredGroebnerBasis SetStraightLineProgElmType SetStraightLineProgramsTom SetString SetStructureConstantsTable SetStructureDescription SetSubdirectProductInfo SetSubfields SetSubnormalSeriesInParent SetSubsTom SetSubspaces SetSubspacesAll SetSuccessors SetSupersolvableResiduum SetSurjectiveActionHomomorphismAttr SetSylowSystem SetSymmetricDegree SetSymmetricParentGroup SetTableOfMarks SetTestMonomial SetTestMonomialQuick SetTestQuasiPrimitive SetTestRelativelySM SetTestSubnormallyMonomial SetTietzeOrigin SetTrace SetTranformsOneIntoZero SetTransformationRepresentation SetTransformsAdditionIntoMultiplication SetTransformsAdditiveInversesIntoInverses SetTransformsInversesIntoAdditiveInverses SetTransformsMultiplicationIntoAddition SetTransformsZeroIntoOne SetTransitiveIdentification SetTransitivity SetTransposedMat SetTransposedMatAttr SetTransposedMatImmutable SetTransposedMatrixGroup SetTransversal SetTriangulizedNullspaceMat SetTrivialCharacter SetTrivialSubFLMLOR SetTrivialSubadditiveMagmaWithZero SetTrivialSubalgebra SetTrivialSubgroup SetTrivialSubmagmaWithOne SetTrivialSubmodule SetTrivialSubmonoid SetTrivialSubnearAdditiveMagmaWithZero SetTrivialSubspace SetTwoClosure SetTypeObj SetTzOptions SetTzRules SetUnderlyingCharacterTable SetUnderlyingCharacteristic SetUnderlyingCollection SetUnderlyingElementOfReesMatrixSemigroupElement SetUnderlyingElementOfReesZeroMatrixSemigroupElement SetUnderlyingExternalSet SetUnderlyingFamily SetUnderlyingField SetUnderlyingGeneralMapping SetUnderlyingGroup SetUnderlyingLeftModule SetUnderlyingLieAlgebra SetUnderlyingMagma SetUnderlyingRelation SetUnderlyingSemigroupOfReesMatrixSemigroup SetUnderlyingSemigroupOfReesZeroMatrixSemigroup SetUnderlyingVectorSpace SetUnits SetUniversalEnvelopingAlgebra SetUpperActingDomain SetUpperCentralSeriesOfGroup SetValueOption SetValuesOfClassFunction SetWeightOfGenerators SetWeightsTom SetWeylGroup SetWreathProductInfo SetX SetXHelp SetZClassRepsQClass SetZero SetZeroAttr SetZeroCoefficient SetZeroImmutable SetZuppos SetnpeGL SetnpePSL SetnpeSL SetsOrbits Setter ShallowCopy ShapeFrequencies SharedObj SharedType ShiftedCoeffs ShiftedPadicNumber ShortLexOrdering ShortLexOrderingNC ShortestVectors ShowArgument ShowArguments ShowDetails ShowImpliedFilters ShowMethods ShowOtherMethods ShowPackageVariables ShrinkCoeffs ShrinkRowVector ShrinkableHashTable ShrinkableSingleValuedHashTable Sift SiftAsWord SiftForStrongGenerator SiftFunction SiftGroup SiftOneLevel SiftVector SiftedPcElement SiftedPermutation SiftedVector SiftedVectorForGaussianMatrixSpace SiftedVectorForGaussianRowSpace SiftedWord Sigma SignInt SignPartition SignPerm SignPermGroup SimpleLieAlgebra SimpleLieAlgebraTypeH SimpleLieAlgebraTypeK SimpleLieAlgebraTypeS SimpleLieAlgebraTypeW SimpleSystem SimplifiedFpGroup SimplifyPresentation SimsName SimsNo SimultaneousEigenvalues SingleCollector SingleCollectorByGenerators SingleCollectorByRelators SingleValuedHashTable Size SizeBlist SizeConsiderFunction SizeGL SizeNumbersPerfectGroups SizeOfChainOfGroup SizeOfFieldOfDefinition SizeOfGLdZmodmZ SizePSL SizePolynomialUnipotentClassGL SizeSL SizeScreen SizeStabChain SizeUpperBound SizesCentralizers SizesConjugacyClasses SizesPerfectGroups Sleep SmallGeneratingSet SmallGroup SmallGroupsInformation SmallSpaceCutoff SmallerDegreePermutationRepresentation SmallestGeneratorPerm SmallestMovedPoint SmallestMovedPointPerm SmallestMovedPointPerms SmallestPrimeDivisor SmallestRootInt SmithNormalFormIntegerMat SmithNormalFormIntegerMatTransforms SmithNormalFormSQ Socle SocleComplement SocleDimensions SocleTypePrimitiveGroup SolutionIntMat SolutionMat SolutionMatDestructive SolutionMatNoCo SolutionNullspaceIntMat SolutionSQ SolvableNormalClosurePermGroup SolvableQuotient SomeVerbalSubgroups Sort SortParallel SortRationalClasses SortRelsSortedByStartGen SortedCharacterTable SortedCharacters SortedList SortedSparseActionHomomorphism SortedSparseActionHomomorphismOp SortedTom Sortex SortingPerm Source SourceElt Sp SpanOfMatrixGroup SpanningTree SparseActionHomomorphism SparseActionHomomorphismOp SparseCartanMatrix SparseHashTable SparseIntKey SpecialLinearGroup SpecialLinearGroupCons SpecialOrthogonalGroup SpecialOrthogonalGroupCons SpecialPcgs SpecialPcgsFactor SpecialPcgsSubgroup SpecialUnitaryGroup SpecialUnitaryGroupCons SpecializedExtRepPol SpinInductionScheme SpinorNorm SplitCell SplitCharacters SplitExtension SplitStep SplitString SplitStringInternal SplitTwoSpace SplitUpSublistsByFpFunc SplitWordTail SplittingField Sqrt SquareRoots StabChain StabChainBaseStrongGenerators StabChainForcePoint StabChainImmutable StabChainMutable StabChainOp StabChainOptions StabChainPermGroupToPermGroupGeneralMappingByImages StabChainRandomPermGroup StabChainStrong StabChainSwap Stabilizer StabilizerByMatrixOperation StabilizerFunc StabilizerFuncOp StabilizerOfBlockNC StabilizerOfExternalSet StabilizerOp StabilizerPcgs StandardAssociate StandardClassMatrixColumn StandardGeneratorsFunctions StandardGeneratorsInfo StandardGeneratorsOfFullHomModule StandardGeneratorsOfFullMatrixModule StandardGeneratorsOfGroup StandardScalarProduct StandardizeTable StandardizeTableC StarCyc StateRandom StatusRandom StepModGauss StopNumConsecSiftToOne StopNumSift StopSize StoreAlgExtFam StoreFactorsPol StoreFusion StoreInfoFreeMagma StoredExcludedOrders StoredGroebnerBasis StraightLineProgElm StraightLineProgElmType StraightLineProgGens StraightLineProgram StraightLineProgramElmRankFilter StraightLineProgramNC StraightLineProgramsDefaultType StraightLineProgramsFamily StraightLineProgramsTom StratMeetPartition StreamsFamily StretchImportantSLPElement String StringDate StringFamily StringFile StringImType StringOfResultOfLineOfStraightLineProgram StringOfResultOfStraightLineProgram StringOfUnivariateRationalPolynomialByCoefficients StringPP StringPrint StringStreamInputTextFile StringTime StringToStraightLineProgram StringUnivariateLaurent StringView StripBeginEnd StripEscapeSequences StrongGeneratorsStabChain StrongGens StronglyConnectedComponents StructuralCopy StructureConstantsPadicNumbers StructureConstantsTable StructureDescription SuPeRfail SubAlgebraModule SubFLMLOR SubFLMLORNC SubFLMLORWithOne SubFLMLORWithOneNC SubGModLeadPos SubSyllables SubadditiveGroup SubadditiveGroupNC SubadditiveMagma SubadditiveMagmaNC SubadditiveMagmaWithInverses SubadditiveMagmaWithInversesNC SubadditiveMagmaWithZero SubadditiveMagmaWithZeroNC Subalgebra SubalgebraNC SubalgebraWithOne SubalgebraWithOneNC SubdirProdPcGroups SubdirectDiagonalPerms SubdirectProduct SubdirectProductInfo SubdirectProductOp SubdirectProducts Subfield SubfieldNC Subfields SubgpConjSymmgp Subgroup SubgroupByPcgs SubgroupByProperty SubgroupGeneratorsCosetTable SubgroupMethodByNiceMonomorphism SubgroupMethodByNiceMonomorphismCollColl SubgroupMethodByNiceMonomorphismCollElm SubgroupMethodByNiceMonomorphismCollOther SubgroupNC SubgroupOfWholeGroupByCosetTable SubgroupOfWholeGroupByQuotientSubgroup SubgroupProperty SubgroupShell SubgroupsMethodByNiceMonomorphism SubgroupsOrbitsAndNormalizers SubgroupsSolvableGroup Submagma SubmagmaNC SubmagmaWithInverses SubmagmaWithInversesNC SubmagmaWithOne SubmagmaWithOneNC Submodule SubmoduleNC Submonoid SubmonoidNC SubnearAdditiveGroup SubnearAdditiveGroupNC SubnearAdditiveMagma SubnearAdditiveMagmaNC SubnearAdditiveMagmaWithInverses SubnearAdditiveMagmaWithInversesNC SubnearAdditiveMagmaWithZero SubnearAdditiveMagmaWithZeroNC SubnormalSeries SubnormalSeriesInParent SubnormalSeriesOp SuboLiBli SuboSiBli SuboTruePos SuboUniteBlist Suborbits Subring SubringNC SubringWithOne SubringWithOneNC SubsTom Subsemigroup SubsemigroupNC Subsemiring SubsemiringNC SubsemiringWithOne SubsemiringWithOneAndZero SubsemiringWithOneAndZeroNC SubsemiringWithOneNC SubsemiringWithZero SubsemiringWithZeroNC Subspace SubspaceNC SubspaceVectorSpaceGroup Subspaces SubspacesAll SubspacesDim SubstitutedWord SubstitutionSublist SubtractBlist SubtractBlistOrbitStabChain SubtractSet Subtype Subword Successors SuggestUpgrades Sum SumCoefPolynomial SumCoefRatfun SumCoeffLaurpol SumCoeffUnivfunc SumFactorizationFunctionPcgs SumIntersectionMat SumOfMBMAndMapping SumOfMappingAndMBM SumOfPcElement SumOp SumPcgs SumRootsPol SumRootsPolComp SumX SumXHelp SummandMolienSeries SupType SupersolvableResiduum SupersolvableResiduumDefault SupportedCharacterTableInfo SupportedLibraryTableComponents SurjectiveActionHomomorphismAttr SuzukiGroup SuzukiGroupCons SyllableRepAssocWord SyllableWordObjByExtRep SylowComplement SylowComplementOp SylowSubgroup SylowSubgroupOp SylowSubgroupPermGroup SylowSystem SymAdic SymmetricClosureBinaryRelation SymmetricDegree SymmetricGroup SymmetricGroupCons SymmetricParentGroup SymmetricParts SymmetricPower SymmetricPowerOfAlgebraModule Symmetrisations Symmetrizations SymplecticComponents SymplecticGroup SymplecticGroupCons SyzygyCriterion Sz TRANSGrp TRANSProperties TableAutomorphisms TableHasIntKeyFun TableOfMarks TableOfMarksByLattice TableOfMarksComponents TableOfMarksCyclic TableOfMarksDihedral TableOfMarksFamily TableOfMarksFrobenius TableOfMarksFromLibrary TailOfPcgsPermGroup TailsInverses Tau TeX TeXObj TemporaryGlobalVarName TensorProduct TensorProductGModule TensorProductOfAlgebraModules TensorWreathProductOfMatrixGroup Tensored TestConsistencyMaps TestHomogeneous TestInducedFromNormalSubgroup TestJacobi TestMonomial TestMonomialFromLattice TestMonomialQuick TestMonomialUseLattice TestPackageAvailability TestQuasiPrimitive TestRelativelySM TestRelativelySMFun TestRow TestSubnormallyMonomial Tester TextAttr TextM TietzeOrigin TietzeWordAbstractWord TmpDirectory TmpName ToBeDefinedObjFamily ToBeDefinedObjType ToggleEcho TopExtensionsByAutomorphism Trace TraceDefinition TraceImmediateMethods TraceMat TraceMethods TraceModQF TracePolynomial TracedCosetFpGroup TrailingEntriesLTM TranformsOneIntoZero TransArrange TransCombinat TransGrpLoad TransStabCSPG TransferDiagram TransferPcgsInfo TransferedExtensionPol Transformation TransformationData TransformationFamily TransformationNC TransformationRelation TransformationRepresentation TransformationType TransformingPermutationFamily TransformingPermutations TransformingPermutationsCharacterTables TransformsAdditionIntoMultiplication TransformsAdditiveInversesIntoInverses TransformsInversesIntoAdditiveInverses TransformsMultiplicationIntoAddition TransformsZeroIntoOne TransitiveClosureBinaryRelation TransitiveGroup TransitiveIdentification Transitivity TranslateString TranslatorSubalgebra TransposedMat TransposedMatAttr TransposedMatDestructive TransposedMatImmutable TransposedMatMutable TransposedMatOp TransposedMatrixGroup TransvByDirProdFamily TransvByHomomorphismFamily TransvBySchreierTreeFamily TransvBySiftFunctFamily TransvByTrivSubgrpFamily Transversal TransversalBySiftFunction TransversalByTrivial TransversalElt TransversalOfChainSubgroup TreeEntry TreeRepresentedWord TrialQuotientRPF TriangulizeIntegerMat TriangulizeMat TriangulizeMonomialElementList TriangulizeWeightRepElementList TriangulizedGeneratorsByMatrix TriangulizedIntegerMat TriangulizedIntegerMatTransform TriangulizedIntegerMatTransforms TriangulizedNullspaceMat TriangulizedNullspaceMatDestructive TriangulizedNullspaceMatNT TrivialCharacter TrivialGModule TrivialGroup TrivialGroupCons TrivialIterator TrivialModule TrivialPartition TrivialQuotientSubgroup TrivialSubFLMLOR TrivialSubadditiveMagmaWithZero TrivialSubalgebra TrivialSubgroup TrivialSubmagmaWithOne TrivialSubmodule TrivialSubmonoid TrivialSubnearAdditiveMagmaWithZero TrivialSubspace TryCombinations TryConwayPolynomialForFrobeniusCharacterValue TryCosetTableInWholeGroup TryGcdCancelExtRepPolynomials TryLayerSQ TryModuleSQ TryNextMethod TryPcgsPermGroup TrySecondaryImages Tschirnhausen Tuple TupleNC Tuples TuplesFamily TuplesK TwoClosure TwoClosurePermGroup TwoCoboundaries TwoCoboundariesSQ TwoCocycles TwoCocyclesSQ TwoCohomology TwoCohomologySQ TwoSeqPol TwoSidedIdeal TwoSidedIdealByGenerators TwoSidedIdealNC TwoSquares TypeObj TypeOfDefaultGeneralMapping TypeOfFamilies TypeOfFamilyOfFamilies TypeOfFamilyOfTypes TypeOfTypes TzCheckRecord TzEliminate TzEliminateFromTree TzEliminateGen TzEliminateGens TzFindCyclicJoins TzGeneratorExponents TzGo TzGoGo TzImagesOldGens TzInitGeneratorImages TzMostFrequentPairs TzNewGenerator TzOccurrences TzOccurrencesPairs TzOptionNames TzOptions TzPreImagesNewGens TzPrint TzPrintGeneratorImages TzPrintGenerators TzPrintLengths TzPrintOptions TzPrintPairs TzPrintPresentation TzPrintRelators TzPrintStatus TzRelator TzRemoveGenerators TzRenumberGens TzReplaceGens TzRules TzSearch TzSearchC TzSearchEqual TzSort TzSortC TzSubstitute TzSubstituteCyclicJoins TzSubstituteGen TzSubstituteWord TzTestInitialSetup TzUpdateGeneratorImages TzWordAbstractWord UNIXSelect UglyVector UnInstallCharReadHookFunc UnSetImage Unbind UnbindElmWPObj UnbindGlobal UnderlyingCharacterTable UnderlyingCharacteristic UnderlyingCollection UnderlyingDomainOfBinaryRelation UnderlyingElement UnderlyingElementOfReesMatrixSemigroupElement UnderlyingElementOfReesZeroMatrixSemigroupElement UnderlyingExternalSet UnderlyingFamily UnderlyingField UnderlyingGeneralMapping UnderlyingGroup UnderlyingLeftModule UnderlyingLieAlgebra UnderlyingMagma UnderlyingRelation UnderlyingSemigroupOfReesMatrixSemigroup UnderlyingSemigroupOfReesZeroMatrixSemigroup UnderlyingVectorSpace UndoRefinement UnhideGlobalVariables Union UnionBlist UnionSet UnipotentSubgroup Unique UniteBlist UniteBlistList UniteSet Units UnivariateLaurentPolynomialByCoefficients UnivariatePolynomial UnivariatePolynomialByCoefficients UnivariatePolynomialRing UnivariateRationalFunctionByCoefficients UnivariateRationalFunctionByExtRep UnivariatenessTestRationalFunction UniversalEnvelopingAlgebra Unknown UnknownsType UnloadSmallGroupsData UnlockNaturalHomomorphismsPool UnmarkTree UnorderedTuples UnorderedTuplesK UnprofileFunctions UnprofileMethods UntraceMethods UpEnv UpdateMap UpdatePolycyclicCollector UpdateWeightInfo UpperActingDomain UpperCentralSeries UpperCentralSeriesOfGroup UpperSubdiagonal UseBasis UseFactorRelation UseIsomorphismRelation UseMatrixChainSubgroups UsePermChainSubgroups UseStabChainViaChainSubgroup UseSubsetRelation UseSubsetRelationNC VPActionHom VSTInsertToLeft VSTNode ValidatePackageInfo Valuation Value ValueCochain ValueGlobal ValueMolienSeries ValueOption ValuePol ValuesOfClassFunction VectorOfRelator VectorSearchTable VectorSpace VectorSpaceByPcgsOfElementaryAbelianGroup VerifySGS VerifyStabilizer View ViewFullHomModule ViewLength ViewMolienSeries ViewObj VirtualCharacter WallForm WeakPointerObj WedgeGModule WeekDay WeightLexOrdering WeightLexOrderingNC WeightOfGenerators WeightVecFFE WeightsTom WeylGroup WeylOrbitIterator Where WindowCmd Word WordAlp WordsString WreathElm WreathProduct WreathProductImprimitiveAction WreathProductInfo WreathProductOfMatrixGroup WreathProductOrdering WreathProductProductAction WriteAll WriteBibFile WriteByte WriteLine ZClassRepsQClass ZOp ZassenhausIntersection Zero ZeroAttr ZeroCoefficient ZeroCoefficientRatFun ZeroImmutable ZeroMapping ZeroMutable ZeroOp ZeroSM ZeroSameMutability ZevData ZevDataValue ZippedListQuotient ZippedProduct ZippedSum ZmodnZ ZmodnZObj ZmodpZ ZmodpZNC ZumbroichBase Zuppos"++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_'5ba'2dzA'2dZ'5d'5cw'2a = compileRegex "[a-zA-Z]\\w*"+regex_'5cb'28for'29'5cb = compileRegex "\\b(for)\\b"+regex_'5cb'28while'29'5cb = compileRegex "\\b(while)\\b"+regex_'5cb'28od'29'5cb = compileRegex "\\b(od)\\b"+regex_'5cb'28repeat'29'5cb = compileRegex "\\b(repeat)\\b"+regex_'5cb'28until'29'5cb = compileRegex "\\b(until)\\b"+regex_'5cb'28if'29'5cb = compileRegex "\\b(if)\\b"+regex_'5cb'28fi'29'5cb = compileRegex "\\b(fi)\\b"+regex_'5cb'28function'29'5cb = compileRegex "\\b(function)\\b"+regex_'5cb'28end'29'5cb = compileRegex "\\b(end)\\b"+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 "\"([^\"]|\"\"|\\\\\")*"++defaultAttributes = [("Top_Level","Normal Text"),("Commentary","Commentary"),("Code_Folding","Normal Text"),("Two Char Operators","Normal Text"),("Strings","Strings")]++parseRules "Top_Level" = +  do (attr, result) <- (((pDetectSpaces >>= withAttribute "Normal Text"))+                        <|>+                        ((parseRules "Strings"))+                        <|>+                        ((parseRules "Code_Folding"))+                        <|>+                        ((parseRules "Two Char Operators"))+                        <|>+                        ((pDetectChar False '#' >>= withAttribute "Normal Text") >>~ pushContext "Commentary")+                        <|>+                        ((pAnyChar "!%*+,/;=>|;-:<>\\^" >>= withAttribute "Operator1"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_builtinfunctions >>= withAttribute "Builtin Functions"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_controlstatements >>= withAttribute "Control Statements"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_gapkeywords >>= withAttribute "GAP Keywords"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_logicoperators >>= withAttribute "Logic Operators"))+                        <|>+                        ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_mathoperators >>= withAttribute "Math Operators"))+                        <|>+                        ((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"))+                        <|>+                        ((pRegExpr regex_'5ba'2dzA'2dZ'5d'5cw'2a >>= withAttribute "Variable")))+     return (attr, result)++parseRules "Commentary" = +  pzero++parseRules "Code_Folding" = +  do (attr, result) <- (((pRegExpr regex_'5cb'28for'29'5cb >>= withAttribute "Control Statements"))+                        <|>+                        ((pRegExpr regex_'5cb'28while'29'5cb >>= withAttribute "Control Statements"))+                        <|>+                        ((pRegExpr regex_'5cb'28od'29'5cb >>= withAttribute "Control Statements"))+                        <|>+                        ((pRegExpr regex_'5cb'28repeat'29'5cb >>= withAttribute "Control Statements"))+                        <|>+                        ((pRegExpr regex_'5cb'28until'29'5cb >>= withAttribute "Control Statements"))+                        <|>+                        ((pRegExpr regex_'5cb'28if'29'5cb >>= withAttribute "Control Statements"))+                        <|>+                        ((pRegExpr regex_'5cb'28fi'29'5cb >>= withAttribute "Control Statements"))+                        <|>+                        ((pRegExpr regex_'5cb'28function'29'5cb >>= withAttribute "Function"))+                        <|>+                        ((pRegExpr regex_'5cb'28end'29'5cb >>= withAttribute "Function")))+     return (attr, result)++parseRules "Two Char Operators" = +  do (attr, result) <- (((pString False ".." >>= withAttribute "Operator2"))+                        <|>+                        ((pString False "!." >>= withAttribute "Operator2"))+                        <|>+                        ((pString False ":=" >>= withAttribute "Operator2"))+                        <|>+                        ((pString False "->" >>= withAttribute "Operator2"))+                        <|>+                        ((pString False "<=" >>= withAttribute "Operator2"))+                        <|>+                        ((pString False ">=" >>= withAttribute "Operator2"))+                        <|>+                        ((pString False "<>" >>= withAttribute "Operator2")))+     return (attr, result)++parseRules "Strings" = +  do (attr, result) <- (((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")))+     return (attr, result)++parseRules x = fail $ "Unknown context" ++ x

@@ -0,0 +1,122 @@+{- This module was generated from data in the Kate syntax highlighting file gdb.xml, version 1.0,+   by  Milian Wolff (mail@milianw.de) -}++module Text.Highlighting.Kate.Syntax.Gdb ( 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)++-- | Full name of language.+syntaxName :: String+syntaxName = "GDB Backtrace"++-- | Filename extensions for this language.+syntaxExtensions :: String+syntaxExtensions = "*.kcrash;*.crash;*.bt"++-- | 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 = "GDB Backtrace" }+  context <- currentContext <|> (pushContext "apache" >> 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 [("GDB Backtrace",["apache"])], synStLanguage = "GDB Backtrace", synStCurrentLine = "", synStCharsParsedInLine = 0, synStPrevChar = '\n', synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}++parseSourceLine = manyTill parseExpressionInternal pEndLine++pEndLine = do+  lookAhead $ newline <|> (eof >> return '\n')+  context <- currentContext+  case context of+    "apache" -> return () >> pHandleEndLine+    "oneliners" -> (popContext) >> pEndLine+    "stackframe" -> return () >> pHandleEndLine+    "identifier" -> return () >> pHandleEndLine+    "file" -> (popContext >> popContext) >> pEndLine+    "thread" -> (popContext) >> pEndLine+    _ -> pHandleEndLine++withAttribute attr txt = do+  when (null txt) $ fail "Parser matched no text"+  let labs = attr : maybeToList (lookup attr styles)+  st <- getState+  let oldCharsParsed = synStCharsParsedInLine st+  let prevchar = if null txt then '\n' else last txt+  updateState $ \st -> st { synStCharsParsedInLine = oldCharsParsed + length txt, synStPrevChar = prevchar } +  return (labs, txt)++styles = [("Crash","er"),("QualifiedIdentifier","ot"),("Function","fu"),("File","dt"),("Thread","bn")]++parseExpressionInternal = do+  context <- currentContext+  parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes))+++regex_'28'28'3f'3a'5b'5e_'5d'7c'3c'2e'2b'3e'29'2b'3a'3a'29'3f'28'5b'5e_'3a'5d'2b'29'5cs'2a'5c'28 = compileRegex "((?:[^ ]|<.+>)+::)?([^ :]+)\\s*\\("+regex_'5cb0x0'5cb = compileRegex "\\b0x0\\b"++defaultAttributes = [("apache","Normal"),("oneliners","Normal"),("stackframe","Normal"),("identifier","Normal"),("file","File"),("thread","Thread")]++parseRules "apache" = +  do (attr, result) <- (((pFirstNonSpace >> pDetectChar False '#' >>= withAttribute "Normal") >>~ pushContext "stackframe")+                        <|>+                        ((parseRules "oneliners")))+     return (attr, result)++parseRules "oneliners" = +  do (attr, result) <- (((pString False "[KCrash Handler]" >>= withAttribute "Crash"))+                        <|>+                        ((pFirstNonSpace >> pString False "Thread" >>= withAttribute "Normal") >>~ pushContext "thread")+                        <|>+                        ((pFirstNonSpace >> pString False "[Current thread" >>= withAttribute "Normal") >>~ pushContext "thread"))+     return (attr, result)++parseRules "stackframe" = +  do (attr, result) <- (((lookAhead (pRegExpr regex_'28'28'3f'3a'5b'5e_'5d'7c'3c'2e'2b'3e'29'2b'3a'3a'29'3f'28'5b'5e_'3a'5d'2b'29'5cs'2a'5c'28) >> return ([],"") ) >>~ pushContext "identifier")+                        <|>+                        ((pString False "at" >>= withAttribute "Normal") >>~ pushContext "file")+                        <|>+                        ((pString False "from" >>= withAttribute "Normal") >>~ pushContext "file")+                        <|>+                        ((parseRules "oneliners")))+     return (attr, result)++parseRules "identifier" = +  do (attr, result) <- (((pString True "%1" >>= withAttribute "QualifiedIdentifier"))+                        <|>+                        ((pString True "%2" >>= withAttribute "Function"))+                        <|>+                        ((pRegExpr regex_'5cb0x0'5cb >>= withAttribute "Crash"))+                        <|>+                        ((pDetectChar False ')' >>= withAttribute "Normal") >>~ (popContext)))+     return (attr, result)++parseRules "file" = +  do (attr, result) <- ((pDetectChar False ':' >>= withAttribute "Normal") >>~ (popContext >> popContext))+     return (attr, result)++parseRules "thread" = +  pzero++parseRules x = fail $ "Unknown context" ++ x

@@ -0,0 +1,277 @@+{- This module was generated from data in the Kate syntax highlighting file gettext.xml, version 2.00,+   by  Dominik Haumann (dhdev@gmx.de) -}++module Text.Highlighting.Kate.Syntax.Gettext ( 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)++-- | Full name of language.+syntaxName :: String+syntaxName = "GNU Gettext"++-- | Filename extensions for this language.+syntaxExtensions :: String+syntaxExtensions = "*.po;*.pot"++-- | 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 = "GNU Gettext" }+  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 [("GNU Gettext",["Normal"])], synStLanguage = "GNU Gettext", synStCurrentLine = "", synStCharsParsedInLine = 0, synStPrevChar = '\n', synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}++parseSourceLine = manyTill parseExpressionInternal pEndLine++pEndLine = do+  lookAhead $ newline <|> (eof >> return '\n')+  context <- currentContext+  case context of+    "Normal" -> return () >> pHandleEndLine+    "TranslatorComment" -> (popContext) >> pEndLine+    "AutomaticComment" -> (popContext) >> pEndLine+    "References" -> (popContext) >> pEndLine+    "Flags" -> (popContext) >> pEndLine+    "StringDiffNewComment" -> (popContext) >> pEndLine+    "StringDiffOldComment" -> (popContext) >> pEndLine+    "String" -> return () >> pHandleEndLine+    "StringTag" -> return () >> pHandleEndLine+    "StringWrap" -> return () >> pHandleEndLine+    "StringDiffNew" -> return () >> pHandleEndLine+    "StringDiffOld" -> return () >> pHandleEndLine+    "StringWrapSub" -> return () >> pHandleEndLine+    "Previous" -> (popContext) >> pEndLine+    "StringPrevious" -> return () >> pHandleEndLine+    "StringTagPrevious" -> return () >> pHandleEndLine+    "StringDiffNewPrevious" -> return () >> pHandleEndLine+    "StringDiffOldPrevious" -> return () >> pHandleEndLine+    "StringWrapPrevious" -> return () >> pHandleEndLine+    "StringWrapSubPrevious" -> return () >> pHandleEndLine+    _ -> pHandleEndLine++withAttribute attr txt = do+  when (null txt) $ fail "Parser matched no text"+  let labs = attr : maybeToList (lookup attr styles)+  st <- getState+  let oldCharsParsed = synStCharsParsedInLine st+  let prevchar = if null txt then '\n' else last txt+  updateState $ \st -> st { synStCharsParsedInLine = oldCharsParsed + length txt, synStPrevChar = prevchar } +  return (labs, txt)++styles = [("Keyword","kw"),("KeywordPrevious","kw"),("String","st"),("StringPrevious","st"),("Translator Comment","co"),("Automatic Comment","co"),("Reference","co"),("Flag","co"),("FlagFuzzy","co"),("Char","ch"),("CharPrevious","ch"),("Entity","st"),("EntityPrevious","st"),("StringTag","st"),("StringTagPrevious","st"),("Index","dv"),("IndexPrevious","dv"),("StringDiffNewWrap","st"),("StringDiffOldWrap","st"),("StringDiffNew","st"),("StringDiffOld","st"),("StringDiffNewWrapComment","st"),("StringDiffOldWrapComment","st"),("StringDiffNewComment","st"),("StringDiffOldComment","st"),("StringDiffNewWrapPrevious","st"),("StringDiffOldWrapPrevious","st"),("StringDiffNewPrevious","st"),("StringDiffOldPrevious","st")]++parseExpressionInternal = do+  context <- currentContext+  parseRules context <|> (pDefault >>= withAttribute (fromMaybe "" $ lookup context defaultAttributes))+++regex_'28msgid'5fplural'7cmsgid'7cmsgstr'7cmsgctxt'29 = compileRegex "(msgid_plural|msgid|msgstr|msgctxt)"+regex_'5c'5c'2e = compileRegex "\\\\."+regex_'5c'5b'5cd'2b'5c'5d = compileRegex "\\[\\d+\\]"+regex_'26'28'5ba'2dzA'2dZ0'2d9'5f'2e'2d'5d'2b'7c'23'5b0'2d9'5d'2b'29'3b = compileRegex "&([a-zA-Z0-9_.-]+|#[0-9]+);"+regex_'2e = compileRegex "."+regex_'28msgctxt'7cmsgid'5fplural'7cmsgid'7cmsgstr'29 = compileRegex "(msgctxt|msgid_plural|msgid|msgstr)"+regex_'5b'5e'23'5d = compileRegex "[^#]"+regex_'28'23'5c'7c'29'3f_'2a'22 = compileRegex "(#\\|)? *\""++defaultAttributes = [("Normal","Normal Text"),("TranslatorComment","Translator Comment"),("AutomaticComment","Automatic Comment"),("References","Reference"),("Flags","Flag"),("StringDiffNewComment","StringDiffNewComment"),("StringDiffOldComment","StringDiffOldComment"),("String","String"),("StringTag","StringTag"),("StringWrap",""),("StringDiffNew","StringDiffNew"),("StringDiffOld","StringDiffOld"),("StringWrapSub",""),("Previous","Normal Text"),("StringPrevious","StringPrevious"),("StringTagPrevious","StringTagPrevious"),("StringDiffNewPrevious","StringDiffNewPrevious"),("StringDiffOldPrevious","StringDiffOldPrevious"),("StringWrapPrevious",""),("StringWrapSubPrevious","")]++parseRules "Normal" = +  do (attr, result) <- (((pColumn 0 >> pRegExpr regex_'28msgid'5fplural'7cmsgid'7cmsgstr'7cmsgctxt'29 >>= withAttribute "Keyword"))+                        <|>+                        ((pFirstNonSpace >> pString False "#." >>= withAttribute "Automatic Comment") >>~ pushContext "AutomaticComment")+                        <|>+                        ((pFirstNonSpace >> pString False "#:" >>= withAttribute "Reference") >>~ pushContext "References")+                        <|>+                        ((pFirstNonSpace >> pString False "#," >>= withAttribute "Flag") >>~ pushContext "Flags")+                        <|>+                        ((pFirstNonSpace >> pString False "#|" >>= withAttribute "StringPrevious") >>~ pushContext "Previous")+                        <|>+                        ((pFirstNonSpace >> pString False "#" >>= withAttribute "Translator Comment") >>~ pushContext "TranslatorComment")+                        <|>+                        ((pRegExpr regex_'5c'5c'2e >>= withAttribute "Char"))+                        <|>+                        ((pDetectChar False '"' >>= withAttribute "String") >>~ pushContext "String")+                        <|>+                        ((pRegExpr regex_'5c'5b'5cd'2b'5c'5d >>= withAttribute "Index")))+     return (attr, result)++parseRules "TranslatorComment" = +  do (attr, result) <- (((pString False "{+" >>= withAttribute "StringDiffNewWrapComment") >>~ pushContext "StringDiffNewComment")+                        <|>+                        ((pString False "{-" >>= withAttribute "StringDiffOldWrapComment") >>~ pushContext "StringDiffOldComment"))+     return (attr, result)++parseRules "AutomaticComment" = +  do (attr, result) <- (((pString False "{+" >>= withAttribute "StringDiffNewWrapComment") >>~ pushContext "StringDiffNewComment")+                        <|>+                        ((pString False "{-" >>= withAttribute "StringDiffOldWrapComment") >>~ pushContext "StringDiffOldComment"))+     return (attr, result)++parseRules "References" = +  do (attr, result) <- (((pString False "{+" >>= withAttribute "StringDiffNewWrapComment") >>~ pushContext "StringDiffNewComment")+                        <|>+                        ((pString False "{-" >>= withAttribute "StringDiffOldWrapComment") >>~ pushContext "StringDiffOldComment"))+     return (attr, result)++parseRules "Flags" = +  do (attr, result) <- (((pString False "fuzzy" >>= withAttribute "FlagFuzzy"))+                        <|>+                        ((pString False "{+" >>= withAttribute "StringDiffNewWrapComment") >>~ pushContext "StringDiffNewComment")+                        <|>+                        ((pString False "{-" >>= withAttribute "StringDiffOldWrapComment") >>~ pushContext "StringDiffOldComment"))+     return (attr, result)++parseRules "StringDiffNewComment" = +  do (attr, result) <- ((pString False "+}" >>= withAttribute "StringDiffNewWrapComment") >>~ (popContext))+     return (attr, result)++parseRules "StringDiffOldComment" = +  do (attr, result) <- ((pString False "-}" >>= withAttribute "StringDiffOldWrapComment") >>~ (popContext))+     return (attr, result)++parseRules "String" = +  do (attr, result) <- (((pRegExpr regex_'5c'5c'2e >>= withAttribute "Char"))+                        <|>+                        ((pRegExpr regex_'26'28'5ba'2dzA'2dZ0'2d9'5f'2e'2d'5d'2b'7c'23'5b0'2d9'5d'2b'29'3b >>= withAttribute "Entity"))+                        <|>+                        ((pString False "{+" >>= withAttribute "StringDiffNewWrap") >>~ pushContext "StringDiffNew")+                        <|>+                        ((pString False "{-" >>= withAttribute "StringDiffOldWrap") >>~ pushContext "StringDiffOld")+                        <|>+                        ((pDetectChar False '<' >>= withAttribute "StringTag") >>~ pushContext "StringTag")+                        <|>+                        ((pDetectChar False '"' >>= withAttribute "String") >>~ pushContext "StringWrap"))+     return (attr, result)++parseRules "StringTag" = +  do (attr, result) <- (((pRegExpr regex_'5c'5c'2e >>= withAttribute "Char"))+                        <|>+                        ((pString False "{+" >>= withAttribute "StringDiffNewWrap") >>~ pushContext "StringDiffNew")+                        <|>+                        ((pString False "{-" >>= withAttribute "StringDiffOldWrap") >>~ pushContext "StringDiffOld")+                        <|>+                        ((pDetectChar False '>' >>= withAttribute "StringTag") >>~ (popContext))+                        <|>+                        ((pDetectChar False '"' >>= withAttribute "String") >>~ pushContext "StringWrapSub"))+     return (attr, result)++parseRules "StringWrap" = +  do (attr, result) <- (((pDetectChar False '"' >>= withAttribute "String") >>~ (popContext))+                        <|>+                        ((lookAhead (pRegExpr regex_'2e) >> return ([],"") ) >>~ (popContext >> popContext)))+     return (attr, result)++parseRules "StringDiffNew" = +  do (attr, result) <- (((pRegExpr regex_'5c'5c'2e >>= withAttribute "Char"))+                        <|>+                        ((pString False "+}" >>= withAttribute "StringDiffNewWrap") >>~ (popContext))+                        <|>+                        ((pDetectChar False '"' >>= withAttribute "String") >>~ pushContext "StringWrapSub"))+     return (attr, result)++parseRules "StringDiffOld" = +  do (attr, result) <- (((pRegExpr regex_'5c'5c'2e >>= withAttribute "Char"))+                        <|>+                        ((pString False "-}" >>= withAttribute "StringDiffOldWrap") >>~ (popContext))+                        <|>+                        ((pDetectChar False '"' >>= withAttribute "String") >>~ pushContext "StringWrapSub"))+     return (attr, result)++parseRules "StringWrapSub" = +  do (attr, result) <- (((pDetectChar False '"' >>= withAttribute "String") >>~ (popContext))+                        <|>+                        ((lookAhead (pRegExpr regex_'2e) >> return ([],"") ) >>~ (popContext >> popContext >> popContext)))+     return (attr, result)++parseRules "Previous" = +  do (attr, result) <- (((pRegExpr regex_'28msgctxt'7cmsgid'5fplural'7cmsgid'7cmsgstr'29 >>= withAttribute "KeywordPrevious"))+                        <|>+                        ((pRegExpr regex_'5c'5c'2e >>= withAttribute "CharPrevious"))+                        <|>+                        ((pDetectChar False '"' >>= withAttribute "StringPrevious") >>~ pushContext "StringPrevious")+                        <|>+                        ((pRegExpr regex_'5c'5b'5cd'2b'5c'5d >>= withAttribute "IndexPrevious")))+     return (attr, result)++parseRules "StringPrevious" = +  do (attr, result) <- (((pRegExpr regex_'5c'5c'2e >>= withAttribute "CharPrevious"))+                        <|>+                        ((pRegExpr regex_'26'28'5ba'2dzA'2dZ0'2d9'5f'2e'2d'5d'2b'7c'23'5b0'2d9'5d'2b'29'3b >>= withAttribute "EntityPrevious"))+                        <|>+                        ((pString False "{+" >>= withAttribute "StringDiffNewWrapPrevious") >>~ pushContext "StringDiffNewPrevious")+                        <|>+                        ((pString False "{-" >>= withAttribute "StringDiffOldWrapPrevious") >>~ pushContext "StringDiffOldPrevious")+                        <|>+                        ((pDetectChar False '<' >>= withAttribute "StringTagPrevious") >>~ pushContext "StringTagPrevious")+                        <|>+                        ((pDetectChar False '"' >>= withAttribute "StringPrevious") >>~ pushContext "StringWrapPrevious"))+     return (attr, result)++parseRules "StringTagPrevious" = +  do (attr, result) <- (((pRegExpr regex_'5c'5c'2e >>= withAttribute "Char"))+                        <|>+                        ((pString False "{+" >>= withAttribute "StringDiffNewWrapPrevious") >>~ pushContext "StringDiffNewPrevious")+                        <|>+                        ((pString False "{-" >>= withAttribute "StringDiffOldWrapPrevious") >>~ pushContext "StringDiffOldPrevious")+                        <|>+                        ((pDetectChar False '>' >>= withAttribute "StringTagPrevious") >>~ (popContext))+                        <|>+                        ((pDetectChar False '"' >>= withAttribute "StringPrevious") >>~ pushContext "StringWrapSubPrevious"))+     return (attr, result)++parseRules "StringDiffNewPrevious" = +  do (attr, result) <- (((pRegExpr regex_'5c'5c'2e >>= withAttribute "CharPrevious"))+                        <|>+                        ((pString False "+}" >>= withAttribute "StringDiffNewWrapPrevious") >>~ (popContext))+                        <|>+                        ((pDetectChar False '"' >>= withAttribute "StringPrevious") >>~ pushContext "StringWrapSubPrevious"))+     return (attr, result)++parseRules "StringDiffOldPrevious" = +  do (attr, result) <- (((pRegExpr regex_'5c'5c'2e >>= withAttribute "CharPrevious"))+                        <|>+                        ((pString False "-}" >>= withAttribute "StringDiffOldWrapPrevious") >>~ (popContext))+                        <|>+                        ((pDetectChar False '"' >>= withAttribute "StringPrevious") >>~ pushContext "StringWrapSubPrevious"))+     return (attr, result)++parseRules "StringWrapPrevious" = +  do (attr, result) <- (((pFirstNonSpace >> lookAhead (pRegExpr regex_'5b'5e'23'5d) >> return ([],"") ) >>~ (popContext >> popContext))+                        <|>+                        ((pRegExpr regex_'28'23'5c'7c'29'3f_'2a'22 >>= withAttribute "StringPrevious") >>~ (popContext))+                        <|>+                        ((lookAhead (pRegExpr regex_'2e) >> return ([],"") ) >>~ (popContext >> popContext)))+     return (attr, result)++parseRules "StringWrapSubPrevious" = +  do (attr, result) <- (((pFirstNonSpace >> lookAhead (pRegExpr regex_'5b'5e'23'5d) >> return ([],"") ) >>~ (popContext >> popContext >> popContext))+                        <|>+                        ((pRegExpr regex_'28'23'5c'7c'29'3f_'2a'22 >>= withAttribute "StringPrevious") >>~ (popContext))+                        <|>+                        ((lookAhead (pRegExpr regex_'2e) >> return ([],"") ) >>~ (popContext >> popContext >> popContext)))+     return (attr, result)++parseRules x = fail $ "Unknown context" ++ x