diff --git a/Makefile b/Makefile new file mode 100644 --- /dev/null +++ b/Makefile @@ -0,0 +1,41 @@ +# The build procedure, after a fresh checkout from the repository: + +# make prep +# cabal install +# +# 'make prep' generates the Haskell syntax parsers from kate +# xml syntax definitions. + +XMLS=$(glob xml/*.xml) + +.PHONY: prep all test clean distclean install prof + +all: prep + cabal configure -fexecutable --enable-tests + cabal build + +prof: + cabal configure --enable-library-profiling --enable-executable-profiling --disable-optimization -fexecutable + cabal build + +prep: clean ParseSyntaxFiles $(XMLS) + cabal install -fexecutable --enable-tests --only-dependencies + ./ParseSyntaxFiles xml + @echo "Syntax parsers have been generated." + @echo "You may now use cabal to build the package." + +install: + cabal install + +test: + cabal test + +ParseSyntaxFiles: ParseSyntaxFiles.hs + cabal install HXT + ghc --make -Wall ParseSyntaxFiles.hs # requires HXT >= 9.0.0 + +clean: + rm -rf Text/Highlighting/Kate/Syntax/* + +distclean: + rm -rf ParseSyntaxFiles.o ParseSyntaxFiles.hi ParseSyntaxFiles diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -2,11 +2,12 @@ ----------------- A Haskell source code highlighting library, based -on Kate's syntax description files (http://kate-editor.org/). It -can produce both HTML and LaTeX output. +on Kate's syntax description files (http://kate-editor.org/), +now [part of the KDE Framework's "KTextEditor" component](http://kate-editor.org/2013/11/11/kate-on-5-the-future-of-ktexteditor-and-kate-part/). +It can produce both HTML and LaTeX output. Currently, the following languages/formats are supported: - +- Abc - Actionscript - Ada - Apache @@ -30,20 +31,24 @@ - D - Diff - Djangotemplate +- Dot - Doxygen - Dtd - Eiffel - Email - Erlang +- Fasm - Fortran - Fsharp +- Gcc +- Glsl - Gnuassembler - Go - Haskell - Haxe - Html -- Ilerpg - Ini +- Isocpp - Java - Javadoc - Javascript @@ -52,12 +57,15 @@ - Julia - Latex - Lex +- Lilypond - LiterateCurry - LiterateHaskell - Lua +- M4 - Makefile - Mandoc - Markdown +- Mathematica - Matlab - Maxima - Mediawiki @@ -72,6 +80,7 @@ - Objectivecpp - Ocaml - Octave +- Opencl - Pascal - Perl - Php @@ -81,9 +90,11 @@ - Pure - Python - R +- Relaxng - Relaxngcompact -- Restructuredtext +- Rest - Rhtml +- Roff - Ruby - Rust - Scala @@ -95,6 +106,7 @@ - SqlMysql - SqlPostgresql - Tcl +- Tcsh - Texinfo - Verilog - Vhdl @@ -104,12 +116,13 @@ - Xul - Yacc - Yaml +- Zsh To install, use the cabal tool: cabal install -Note: If you have checked out the source from the darcs repository, +Note: If you have checked out the source from the git repository, you will first need to do: make prep @@ -125,6 +138,10 @@ cabal haddock +To run the test suite: + + cabal test + 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: @@ -162,14 +179,14 @@ Note that ParseSyntaxFiles.hs requires the HXT package (>= 9.0.0). -To get the current Kate syntax highlighting files, clone the kate +To get the current Kate syntax highlighting files, clone the ktexteditor repository: - git clone git://anongit.kde.org/kate + git clone git://anongit.kde.org/ktexteditor The syntax definitions can then be found in - kate/part/syntax/data + src/syntax/data There is information on the syntax highlighting definitions at . See also @@ -177,11 +194,15 @@ Thanks are due to all the authors of these syntax definitions. -Changes have been made to the following xml files (the originals have -been left in the directory, with .bkp extensions): +Changes have been made to the following xml files (diffs have +been left in the directory, with .patch extensions): -- perl.xml: Fixed regexes - needed backslash-escapes before ] and ^ -- php.xml: Added fallthrough so `. diff --git a/Text/Highlighting/Kate/Common.hs b/Text/Highlighting/Kate/Common.hs --- a/Text/Highlighting/Kate/Common.hs +++ b/Text/Highlighting/Kate/Common.hs @@ -1,4 +1,4 @@ -{-# LANGUAGE CPP #-} +{-# LANGUAGE CPP, ScopedTypeVariables #-} {- | Module : Text.Highlighting.Kate.Common Copyright : Copyright (C) 2008 John MacFarlane @@ -23,6 +23,7 @@ import Text.ParserCombinators.Parsec hiding (State) import Data.Char (isDigit, toLower, isSpace) import Data.List (tails) +import Text.Printf import Control.Monad.State import qualified Data.Set as Set @@ -167,7 +168,7 @@ -- convert octal escapes to the form pcre wants. Note: -- need at least pcre 8.34 for the form \o{dddd}. --- So we prefer \ddd when possible. +-- So we prefer \ddd or \x{...}. convertOctal :: String -> String convertOctal [] = "" convertOctal ('\\':'0':x:y:z:rest) @@ -177,15 +178,10 @@ convertOctal ('\\':'o':'{':zs) = case break (=='}') zs of (ds, '}':rest) | all isOctalDigit ds && not (null ds) -> - if length ds <= 3 - then '\\': pad3 ds ++ convertOctal rest - else case reads ('\\':'o':ds) of - ((c,[]):_) -> c : convertOctal rest - _ -> '\\':'o':'{': convertOctal zs + case reads ('0':'o':ds) of + ((n :: Int,[]):_) -> printf "\\x{%x}" n ++ convertOctal rest + _ -> error $ "Unable to read octal number: " ++ ds _ -> '\\':'o':'{': convertOctal zs - where pad3 [x] = ['0','0',x] - pad3 [x,y] = ['0',x,y] - pad3 xs = xs convertOctal (x:xs) = x : convertOctal xs isOctalDigit :: Char -> Bool diff --git a/Text/Highlighting/Kate/Syntax.hs b/Text/Highlighting/Kate/Syntax.hs --- a/Text/Highlighting/Kate/Syntax.hs +++ b/Text/Highlighting/Kate/Syntax.hs @@ -15,6 +15,7 @@ import Data.Char (toLower) import Text.Highlighting.Kate.Types import Text.Highlighting.Kate.Common (matchGlobs) +import qualified Text.Highlighting.Kate.Syntax.Abc as Abc 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 @@ -40,15 +41,18 @@ import qualified Text.Highlighting.Kate.Syntax.D as D import qualified Text.Highlighting.Kate.Syntax.Diff as Diff import qualified Text.Highlighting.Kate.Syntax.Djangotemplate as Djangotemplate +import qualified Text.Highlighting.Kate.Syntax.Dot as Dot 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.Fasm as Fasm import qualified Text.Highlighting.Kate.Syntax.Fortran as Fortran import qualified Text.Highlighting.Kate.Syntax.Fsharp as Fsharp import qualified Text.Highlighting.Kate.Syntax.Gcc as Gcc +import qualified Text.Highlighting.Kate.Syntax.Glsl as Glsl 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 @@ -64,14 +68,18 @@ import qualified Text.Highlighting.Kate.Syntax.Julia as Julia import qualified Text.Highlighting.Kate.Syntax.Latex as Latex import qualified Text.Highlighting.Kate.Syntax.Lex as Lex +import qualified Text.Highlighting.Kate.Syntax.Lilypond as Lilypond import qualified Text.Highlighting.Kate.Syntax.LiterateCurry as LiterateCurry import qualified Text.Highlighting.Kate.Syntax.LiterateHaskell as LiterateHaskell import qualified Text.Highlighting.Kate.Syntax.Lua as Lua +import qualified Text.Highlighting.Kate.Syntax.M4 as M4 import qualified Text.Highlighting.Kate.Syntax.Makefile as Makefile import qualified Text.Highlighting.Kate.Syntax.Mandoc as Mandoc import qualified Text.Highlighting.Kate.Syntax.Markdown as Markdown +import qualified Text.Highlighting.Kate.Syntax.Mathematica as Mathematica 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.Modelines as Modelines @@ -84,6 +92,7 @@ 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.Opencl as Opencl 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 @@ -93,8 +102,9 @@ import qualified Text.Highlighting.Kate.Syntax.Pure as Pure import qualified Text.Highlighting.Kate.Syntax.Python as Python import qualified Text.Highlighting.Kate.Syntax.R as R +import qualified Text.Highlighting.Kate.Syntax.Relaxng as Relaxng import qualified Text.Highlighting.Kate.Syntax.Relaxngcompact as Relaxngcompact -import qualified Text.Highlighting.Kate.Syntax.Restructuredtext as Restructuredtext +import qualified Text.Highlighting.Kate.Syntax.Rest as Rest import qualified Text.Highlighting.Kate.Syntax.Rhtml as Rhtml import qualified Text.Highlighting.Kate.Syntax.Roff as Roff import qualified Text.Highlighting.Kate.Syntax.Ruby as Ruby @@ -108,6 +118,7 @@ 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.Tcsh as Tcsh 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 @@ -117,14 +128,15 @@ 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 +import qualified Text.Highlighting.Kate.Syntax.Zsh as Zsh -- | List of supported languages. languages :: [String] -languages = ["Actionscript","Ada","Alert","Alert_indent","Apache","Asn1","Asp","Awk","Bash","Bibtex","Boo","C","Changelog","Clojure","Cmake","Coffee","Coldfusion","Commonlisp","Cpp","Cs","Css","Curry","D","Diff","Djangotemplate","Doxygen","Doxygenlua","Dtd","Eiffel","Email","Erlang","Fortran","Fsharp","Gcc","Gnuassembler","Go","Haskell","Haxe","Html","Ini","Isocpp","Java","Javadoc","Javascript","Json","Jsp","Julia","Latex","Lex","LiterateCurry","LiterateHaskell","Lua","Makefile","Mandoc","Markdown","Matlab","Maxima","Metafont","Mips","Modelines","Modula2","Modula3","Monobasic","Nasm","Noweb","Objectivec","Objectivecpp","Ocaml","Octave","Pascal","Perl","Php","Pike","Postscript","Prolog","Pure","Python","R","Relaxngcompact","Restructuredtext","Rhtml","Roff","Ruby","Rust","Scala","Scheme","Sci","Sed","Sgml","Sql","SqlMysql","SqlPostgresql","Tcl","Texinfo","Verilog","Vhdl","Xml","Xorg","Xslt","Xul","Yacc","Yaml"] +languages = ["Abc","Actionscript","Ada","Alert","Alert_indent","Apache","Asn1","Asp","Awk","Bash","Bibtex","Boo","C","Changelog","Clojure","Cmake","Coffee","Coldfusion","Commonlisp","Cpp","Cs","Css","Curry","D","Diff","Djangotemplate","Dot","Doxygen","Doxygenlua","Dtd","Eiffel","Email","Erlang","Fasm","Fortran","Fsharp","Gcc","Glsl","Gnuassembler","Go","Haskell","Haxe","Html","Ini","Isocpp","Java","Javadoc","Javascript","Json","Jsp","Julia","Latex","Lex","Lilypond","LiterateCurry","LiterateHaskell","Lua","M4","Makefile","Mandoc","Markdown","Mathematica","Matlab","Maxima","Mediawiki","Metafont","Mips","Modelines","Modula2","Modula3","Monobasic","Nasm","Noweb","Objectivec","Objectivecpp","Ocaml","Octave","Opencl","Pascal","Perl","Php","Pike","Postscript","Prolog","Pure","Python","R","Relaxng","Relaxngcompact","Rest","Rhtml","Roff","Ruby","Rust","Scala","Scheme","Sci","Sed","Sgml","Sql","SqlMysql","SqlPostgresql","Tcl","Tcsh","Texinfo","Verilog","Vhdl","Xml","Xorg","Xslt","Xul","Yacc","Yaml","Zsh"] -- | List of language extensions. languageExtensions :: [(String, String)] -languageExtensions = [("Actionscript", Actionscript.syntaxExtensions), ("Ada", Ada.syntaxExtensions), ("Alert", Alert.syntaxExtensions), ("Alert_indent", Alert_indent.syntaxExtensions), ("Apache", Apache.syntaxExtensions), ("Asn1", Asn1.syntaxExtensions), ("Asp", Asp.syntaxExtensions), ("Awk", Awk.syntaxExtensions), ("Bash", Bash.syntaxExtensions), ("Bibtex", Bibtex.syntaxExtensions), ("Boo", Boo.syntaxExtensions), ("C", C.syntaxExtensions), ("Changelog", Changelog.syntaxExtensions), ("Clojure", Clojure.syntaxExtensions), ("Cmake", Cmake.syntaxExtensions), ("Coffee", Coffee.syntaxExtensions), ("Coldfusion", Coldfusion.syntaxExtensions), ("Commonlisp", Commonlisp.syntaxExtensions), ("Cpp", Cpp.syntaxExtensions), ("Cs", Cs.syntaxExtensions), ("Css", Css.syntaxExtensions), ("Curry", Curry.syntaxExtensions), ("D", D.syntaxExtensions), ("Diff", Diff.syntaxExtensions), ("Djangotemplate", Djangotemplate.syntaxExtensions), ("Doxygen", Doxygen.syntaxExtensions), ("Doxygenlua", Doxygenlua.syntaxExtensions), ("Dtd", Dtd.syntaxExtensions), ("Eiffel", Eiffel.syntaxExtensions), ("Email", Email.syntaxExtensions), ("Erlang", Erlang.syntaxExtensions), ("Fortran", Fortran.syntaxExtensions), ("Fsharp", Fsharp.syntaxExtensions), ("Gcc", Gcc.syntaxExtensions), ("Gnuassembler", Gnuassembler.syntaxExtensions), ("Go", Go.syntaxExtensions), ("Haskell", Haskell.syntaxExtensions), ("Haxe", Haxe.syntaxExtensions), ("Html", Html.syntaxExtensions), ("Ini", Ini.syntaxExtensions), ("Isocpp", Isocpp.syntaxExtensions), ("Java", Java.syntaxExtensions), ("Javadoc", Javadoc.syntaxExtensions), ("Javascript", Javascript.syntaxExtensions), ("Json", Json.syntaxExtensions), ("Jsp", Jsp.syntaxExtensions), ("Julia", Julia.syntaxExtensions), ("Latex", Latex.syntaxExtensions), ("Lex", Lex.syntaxExtensions), ("LiterateCurry", LiterateCurry.syntaxExtensions), ("LiterateHaskell", LiterateHaskell.syntaxExtensions), ("Lua", Lua.syntaxExtensions), ("Makefile", Makefile.syntaxExtensions), ("Mandoc", Mandoc.syntaxExtensions), ("Markdown", Markdown.syntaxExtensions), ("Matlab", Matlab.syntaxExtensions), ("Maxima", Maxima.syntaxExtensions), ("Metafont", Metafont.syntaxExtensions), ("Mips", Mips.syntaxExtensions), ("Modelines", Modelines.syntaxExtensions), ("Modula2", Modula2.syntaxExtensions), ("Modula3", Modula3.syntaxExtensions), ("Monobasic", Monobasic.syntaxExtensions), ("Nasm", Nasm.syntaxExtensions), ("Noweb", Noweb.syntaxExtensions), ("Objectivec", Objectivec.syntaxExtensions), ("Objectivecpp", Objectivecpp.syntaxExtensions), ("Ocaml", Ocaml.syntaxExtensions), ("Octave", Octave.syntaxExtensions), ("Pascal", Pascal.syntaxExtensions), ("Perl", Perl.syntaxExtensions), ("Php", Php.syntaxExtensions), ("Pike", Pike.syntaxExtensions), ("Postscript", Postscript.syntaxExtensions), ("Prolog", Prolog.syntaxExtensions), ("Pure", Pure.syntaxExtensions), ("Python", Python.syntaxExtensions), ("R", R.syntaxExtensions), ("Relaxngcompact", Relaxngcompact.syntaxExtensions), ("Restructuredtext", Restructuredtext.syntaxExtensions), ("Rhtml", Rhtml.syntaxExtensions), ("Roff", Roff.syntaxExtensions), ("Ruby", Ruby.syntaxExtensions), ("Rust", Rust.syntaxExtensions), ("Scala", Scala.syntaxExtensions), ("Scheme", Scheme.syntaxExtensions), ("Sci", Sci.syntaxExtensions), ("Sed", Sed.syntaxExtensions), ("Sgml", Sgml.syntaxExtensions), ("Sql", Sql.syntaxExtensions), ("SqlMysql", SqlMysql.syntaxExtensions), ("SqlPostgresql", SqlPostgresql.syntaxExtensions), ("Tcl", Tcl.syntaxExtensions), ("Texinfo", Texinfo.syntaxExtensions), ("Verilog", Verilog.syntaxExtensions), ("Vhdl", Vhdl.syntaxExtensions), ("Xml", Xml.syntaxExtensions), ("Xorg", Xorg.syntaxExtensions), ("Xslt", Xslt.syntaxExtensions), ("Xul", Xul.syntaxExtensions), ("Yacc", Yacc.syntaxExtensions), ("Yaml", Yaml.syntaxExtensions)] +languageExtensions = [("Abc", Abc.syntaxExtensions), ("Actionscript", Actionscript.syntaxExtensions), ("Ada", Ada.syntaxExtensions), ("Alert", Alert.syntaxExtensions), ("Alert_indent", Alert_indent.syntaxExtensions), ("Apache", Apache.syntaxExtensions), ("Asn1", Asn1.syntaxExtensions), ("Asp", Asp.syntaxExtensions), ("Awk", Awk.syntaxExtensions), ("Bash", Bash.syntaxExtensions), ("Bibtex", Bibtex.syntaxExtensions), ("Boo", Boo.syntaxExtensions), ("C", C.syntaxExtensions), ("Changelog", Changelog.syntaxExtensions), ("Clojure", Clojure.syntaxExtensions), ("Cmake", Cmake.syntaxExtensions), ("Coffee", Coffee.syntaxExtensions), ("Coldfusion", Coldfusion.syntaxExtensions), ("Commonlisp", Commonlisp.syntaxExtensions), ("Cpp", Cpp.syntaxExtensions), ("Cs", Cs.syntaxExtensions), ("Css", Css.syntaxExtensions), ("Curry", Curry.syntaxExtensions), ("D", D.syntaxExtensions), ("Diff", Diff.syntaxExtensions), ("Djangotemplate", Djangotemplate.syntaxExtensions), ("Dot", Dot.syntaxExtensions), ("Doxygen", Doxygen.syntaxExtensions), ("Doxygenlua", Doxygenlua.syntaxExtensions), ("Dtd", Dtd.syntaxExtensions), ("Eiffel", Eiffel.syntaxExtensions), ("Email", Email.syntaxExtensions), ("Erlang", Erlang.syntaxExtensions), ("Fasm", Fasm.syntaxExtensions), ("Fortran", Fortran.syntaxExtensions), ("Fsharp", Fsharp.syntaxExtensions), ("Gcc", Gcc.syntaxExtensions), ("Glsl", Glsl.syntaxExtensions), ("Gnuassembler", Gnuassembler.syntaxExtensions), ("Go", Go.syntaxExtensions), ("Haskell", Haskell.syntaxExtensions), ("Haxe", Haxe.syntaxExtensions), ("Html", Html.syntaxExtensions), ("Ini", Ini.syntaxExtensions), ("Isocpp", Isocpp.syntaxExtensions), ("Java", Java.syntaxExtensions), ("Javadoc", Javadoc.syntaxExtensions), ("Javascript", Javascript.syntaxExtensions), ("Json", Json.syntaxExtensions), ("Jsp", Jsp.syntaxExtensions), ("Julia", Julia.syntaxExtensions), ("Latex", Latex.syntaxExtensions), ("Lex", Lex.syntaxExtensions), ("Lilypond", Lilypond.syntaxExtensions), ("LiterateCurry", LiterateCurry.syntaxExtensions), ("LiterateHaskell", LiterateHaskell.syntaxExtensions), ("Lua", Lua.syntaxExtensions), ("M4", M4.syntaxExtensions), ("Makefile", Makefile.syntaxExtensions), ("Mandoc", Mandoc.syntaxExtensions), ("Markdown", Markdown.syntaxExtensions), ("Mathematica", Mathematica.syntaxExtensions), ("Matlab", Matlab.syntaxExtensions), ("Maxima", Maxima.syntaxExtensions), ("Mediawiki", Mediawiki.syntaxExtensions), ("Metafont", Metafont.syntaxExtensions), ("Mips", Mips.syntaxExtensions), ("Modelines", Modelines.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), ("Opencl", Opencl.syntaxExtensions), ("Pascal", Pascal.syntaxExtensions), ("Perl", Perl.syntaxExtensions), ("Php", Php.syntaxExtensions), ("Pike", Pike.syntaxExtensions), ("Postscript", Postscript.syntaxExtensions), ("Prolog", Prolog.syntaxExtensions), ("Pure", Pure.syntaxExtensions), ("Python", Python.syntaxExtensions), ("R", R.syntaxExtensions), ("Relaxng", Relaxng.syntaxExtensions), ("Relaxngcompact", Relaxngcompact.syntaxExtensions), ("Rest", Rest.syntaxExtensions), ("Rhtml", Rhtml.syntaxExtensions), ("Roff", Roff.syntaxExtensions), ("Ruby", Ruby.syntaxExtensions), ("Rust", Rust.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), ("Tcsh", Tcsh.syntaxExtensions), ("Texinfo", Texinfo.syntaxExtensions), ("Verilog", Verilog.syntaxExtensions), ("Vhdl", Vhdl.syntaxExtensions), ("Xml", Xml.syntaxExtensions), ("Xorg", Xorg.syntaxExtensions), ("Xslt", Xslt.syntaxExtensions), ("Xul", Xul.syntaxExtensions), ("Yacc", Yacc.syntaxExtensions), ("Yaml", Yaml.syntaxExtensions), ("Zsh", Zsh.syntaxExtensions)] -- | Returns a list of languages appropriate for the given file extension. languagesByExtension :: String -> [String] @@ -140,7 +152,7 @@ -- extension (if unique). -- The parsers read the input lazily and parse line by line; -- results are returned immediately. --- Supported languages: @actionscript@, @ada@, @alert@, @alert_indent@, @apache@, @asn1@, @asp@, @awk@, @bash@, @bibtex@, @boo@, @c@, @changelog@, @clojure@, @cmake@, @coffee@, @coldfusion@, @commonlisp@, @cpp@, @cs@, @css@, @curry@, @d@, @diff@, @djangotemplate@, @doxygen@, @doxygenlua@, @dtd@, @eiffel@, @email@, @erlang@, @fortran@, @fsharp@, @gcc@, @gnuassembler@, @go@, @haskell@, @haxe@, @html@, @ini@, @isocpp@, @java@, @javadoc@, @javascript@, @json@, @jsp@, @julia@, @latex@, @lex@, @literatecurry@, @literatehaskell@, @lua@, @makefile@, @mandoc@, @markdown@, @matlab@, @maxima@, @metafont@, @mips@, @modelines@, @modula2@, @modula3@, @monobasic@, @nasm@, @noweb@, @objectivec@, @objectivecpp@, @ocaml@, @octave@, @pascal@, @perl@, @php@, @pike@, @postscript@, @prolog@, @pure@, @python@, @r@, @relaxngcompact@, @restructuredtext@, @rhtml@, @roff@, @ruby@, @rust@, @scala@, @scheme@, @sci@, @sed@, @sgml@, @sql@, @sqlmysql@, @sqlpostgresql@, @tcl@, @texinfo@, @verilog@, @vhdl@, @xml@, @xorg@, @xslt@, @xul@, @yacc@, @yaml@. +-- Supported languages: @abc@, @actionscript@, @ada@, @alert@, @alert_indent@, @apache@, @asn1@, @asp@, @awk@, @bash@, @bibtex@, @boo@, @c@, @changelog@, @clojure@, @cmake@, @coffee@, @coldfusion@, @commonlisp@, @cpp@, @cs@, @css@, @curry@, @d@, @diff@, @djangotemplate@, @dot@, @doxygen@, @doxygenlua@, @dtd@, @eiffel@, @email@, @erlang@, @fasm@, @fortran@, @fsharp@, @gcc@, @glsl@, @gnuassembler@, @go@, @haskell@, @haxe@, @html@, @ini@, @isocpp@, @java@, @javadoc@, @javascript@, @json@, @jsp@, @julia@, @latex@, @lex@, @lilypond@, @literatecurry@, @literatehaskell@, @lua@, @m4@, @makefile@, @mandoc@, @markdown@, @mathematica@, @matlab@, @maxima@, @mediawiki@, @metafont@, @mips@, @modelines@, @modula2@, @modula3@, @monobasic@, @nasm@, @noweb@, @objectivec@, @objectivecpp@, @ocaml@, @octave@, @opencl@, @pascal@, @perl@, @php@, @pike@, @postscript@, @prolog@, @pure@, @python@, @r@, @relaxng@, @relaxngcompact@, @rest@, @rhtml@, @roff@, @ruby@, @rust@, @scala@, @scheme@, @sci@, @sed@, @sgml@, @sql@, @sqlmysql@, @sqlpostgresql@, @tcl@, @tcsh@, @texinfo@, @verilog@, @vhdl@, @xml@, @xorg@, @xslt@, @xul@, @yacc@, @yaml@, @zsh@. highlightAs :: String -- ^ Language syntax (e.g. "haskell") or extension (e.g. "hs"). -> String -- ^ Source code to highlight -> [SourceLine] -- ^ List of highlighted source lines @@ -152,6 +164,7 @@ [l] -> map toLower l -- go by extension if unambiguous _ -> lang' in case lang'' of + "abc" -> Abc.highlight "actionscript" -> Actionscript.highlight "ada" -> Ada.highlight "alert" -> Alert.highlight @@ -177,15 +190,18 @@ "d" -> D.highlight "diff" -> Diff.highlight "djangotemplate" -> Djangotemplate.highlight + "dot" -> Dot.highlight "doxygen" -> Doxygen.highlight "doxygenlua" -> Doxygenlua.highlight "dtd" -> Dtd.highlight "eiffel" -> Eiffel.highlight "email" -> Email.highlight "erlang" -> Erlang.highlight + "fasm" -> Fasm.highlight "fortran" -> Fortran.highlight "fsharp" -> Fsharp.highlight "gcc" -> Gcc.highlight + "glsl" -> Glsl.highlight "gnuassembler" -> Gnuassembler.highlight "go" -> Go.highlight "haskell" -> Haskell.highlight @@ -201,14 +217,18 @@ "julia" -> Julia.highlight "latex" -> Latex.highlight "lex" -> Lex.highlight + "lilypond" -> Lilypond.highlight "literatecurry" -> LiterateCurry.highlight "literatehaskell" -> LiterateHaskell.highlight "lua" -> Lua.highlight + "m4" -> M4.highlight "makefile" -> Makefile.highlight "mandoc" -> Mandoc.highlight "markdown" -> Markdown.highlight + "mathematica" -> Mathematica.highlight "matlab" -> Matlab.highlight "maxima" -> Maxima.highlight + "mediawiki" -> Mediawiki.highlight "metafont" -> Metafont.highlight "mips" -> Mips.highlight "modelines" -> Modelines.highlight @@ -221,6 +241,7 @@ "objectivecpp" -> Objectivecpp.highlight "ocaml" -> Ocaml.highlight "octave" -> Octave.highlight + "opencl" -> Opencl.highlight "pascal" -> Pascal.highlight "perl" -> Perl.highlight "php" -> Php.highlight @@ -230,8 +251,9 @@ "pure" -> Pure.highlight "python" -> Python.highlight "r" -> R.highlight + "relaxng" -> Relaxng.highlight "relaxngcompact" -> Relaxngcompact.highlight - "restructuredtext" -> Restructuredtext.highlight + "rest" -> Rest.highlight "rhtml" -> Rhtml.highlight "roff" -> Roff.highlight "ruby" -> Ruby.highlight @@ -245,6 +267,7 @@ "sqlmysql" -> SqlMysql.highlight "sqlpostgresql" -> SqlPostgresql.highlight "tcl" -> Tcl.highlight + "tcsh" -> Tcsh.highlight "texinfo" -> Texinfo.highlight "verilog" -> Verilog.highlight "vhdl" -> Vhdl.highlight @@ -254,4 +277,5 @@ "xul" -> Xul.highlight "yacc" -> Yacc.highlight "yaml" -> Yaml.highlight + "zsh" -> Zsh.highlight _ -> map (\l -> [(NormalTok, l)]) . lines diff --git a/Text/Highlighting/Kate/Syntax/Abc.hs b/Text/Highlighting/Kate/Syntax/Abc.hs new file mode 100644 --- /dev/null +++ b/Text/Highlighting/Kate/Syntax/Abc.hs @@ -0,0 +1,144 @@ +{- This module was generated from data in the Kate syntax + highlighting file abc.xml, version 1.10, by Andrea Primiani (primiani@dag.it) -} + +module Text.Highlighting.Kate.Syntax.Abc + (highlight, parseExpression, syntaxName, syntaxExtensions) +where +import Text.Highlighting.Kate.Types +import Text.Highlighting.Kate.Common +import Text.ParserCombinators.Parsec hiding (State) +import Control.Monad.State +import Data.Char (isSpace) + +-- | Full name of language. +syntaxName :: String +syntaxName = "ABC" + +-- | Filename extensions for this language. +syntaxExtensions :: String +syntaxExtensions = "*.abc;*.ABC" + +-- | Highlight source code using this syntax definition. +highlight :: String -> [SourceLine] +highlight input = evalState (mapM parseSourceLine $ lines input) startingState + +parseSourceLine :: String -> State SyntaxState SourceLine +parseSourceLine = mkParseSourceLine (parseExpression Nothing) + +-- | Parse an expression using appropriate local context. +parseExpression :: Maybe (String,String) + -> KateParser Token +parseExpression mbcontext = do + (lang,cont) <- maybe currentContext return mbcontext + result <- parseRules (lang,cont) + optional $ do eof + updateState $ \st -> st{ synStPrevChar = '\n' } + pEndLine + return result + +startingState = SyntaxState {synStContexts = [("ABC","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []} + +pEndLine = do + updateState $ \st -> st{ synStPrevNonspace = False } + context <- currentContext + contexts <- synStContexts `fmap` getState + if length contexts >= 2 + then case context of + ("ABC","Normal") -> return () + ("ABC","Preprocessor") -> (popContext) >> pEndLine + ("ABC","Lyrics") -> (popContext) >> pEndLine + ("ABC","Part") -> (popContext) >> pEndLine + ("ABC","Comment") -> (popContext) >> pEndLine + ("ABC","Bar") -> (popContext) >> pEndLine + ("ABC","Header") -> return () + ("ABC","Header2") -> (popContext) >> pEndLine + _ -> return () + else return () + +withAttribute attr txt = do + when (null txt) $ fail "Parser matched no text" + updateState $ \st -> st { synStPrevChar = last txt + , synStPrevNonspace = synStPrevNonspace st || not (all isSpace txt) } + return (attr, txt) + + +regex_'5c'28'5b23456789'5d'3a'3f'5b23456789'5d'3f'3a'3f'5b23456789'5d'3f = compileRegex True "\\([23456789]:?[23456789]?:?[23456789]?" +regex_'5c'5b'5bABCGHILMNOQRSTUVZ'5d'3a = compileRegex True "\\[[ABCGHILMNOQRSTUVZ]:" +regex_'5bABCGHILMNOPQRSTUVZ'5d'3a = compileRegex True "[ABCGHILMNOPQRSTUVZ]:" +regex_'5b'5f'7c'5c'5e'5d'3f'5b'5f'7c'3d'7c'5c'5e'5d'5bA'2dGa'2dg'5d = compileRegex True "[_|\\^]?[_|=|\\^][A-Ga-g]" +regex_'5bA'2dGa'2dgZz'5d = compileRegex True "[A-Ga-gZz]" +regex_'3a'2a'5c'7c'2a'5b1'2d9'5d'7c'2f'2a'5c'7c = compileRegex True ":*\\|*[1-9]|/*\\|" +regex_K'3a'2e'2b = compileRegex True "K:.+" + +parseRules ("ABC","Normal") = + (((pRegExpr regex_'5c'28'5b23456789'5d'3a'3f'5b23456789'5d'3f'3a'3f'5b23456789'5d'3f >>= withAttribute DataTypeTok)) + <|> + ((pRangeDetect '"' '"' >>= withAttribute StringTok)) + <|> + ((pRangeDetect '!' '!' >>= withAttribute FloatTok)) + <|> + ((pRegExpr regex_'5c'5b'5bABCGHILMNOQRSTUVZ'5d'3a >>= withAttribute FloatTok) >>~ pushContext ("ABC","Header")) + <|> + ((pRegExpr regex_'5bABCGHILMNOPQRSTUVZ'5d'3a >>= withAttribute FloatTok) >>~ pushContext ("ABC","Header2")) + <|> + ((pColumn 0 >> pDetect2Chars False 'X' ':' >>= withAttribute FloatTok) >>~ pushContext ("ABC","Header")) + <|> + ((pAnyChar "|:[" >>= withAttribute CharTok) >>~ pushContext ("ABC","Bar")) + <|> + ((pDetectChar False ']' >>= withAttribute CharTok)) + <|> + ((pAnyChar "()" >>= withAttribute DataTypeTok)) + <|> + ((pAnyChar "{}" >>= withAttribute DataTypeTok)) + <|> + ((pDetect2Chars False 'W' ':' >>= withAttribute DataTypeTok) >>~ pushContext ("ABC","Lyrics")) + <|> + ((pDetect2Chars False 'w' ':' >>= withAttribute DataTypeTok) >>~ pushContext ("ABC","Lyrics")) + <|> + ((pDetect2Chars False '%' '%' >>= withAttribute StringTok) >>~ pushContext ("ABC","Preprocessor")) + <|> + ((pDetectChar False '%' >>= withAttribute CommentTok) >>~ pushContext ("ABC","Comment")) + <|> + ((pRegExpr regex_'5b'5f'7c'5c'5e'5d'3f'5b'5f'7c'3d'7c'5c'5e'5d'5bA'2dGa'2dg'5d >>= withAttribute NormalTok)) + <|> + (currentContext >>= \x -> guard (x == ("ABC","Normal")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("ABC","Preprocessor") = + (currentContext >>= \x -> guard (x == ("ABC","Preprocessor")) >> pDefault >>= withAttribute StringTok) + +parseRules ("ABC","Lyrics") = + (currentContext >>= \x -> guard (x == ("ABC","Lyrics")) >> pDefault >>= withAttribute DataTypeTok) + +parseRules ("ABC","Part") = + (currentContext >>= \x -> guard (x == ("ABC","Part")) >> pDefault >>= withAttribute FloatTok) + +parseRules ("ABC","Comment") = + (currentContext >>= \x -> guard (x == ("ABC","Comment")) >> pDefault >>= withAttribute CommentTok) + +parseRules ("ABC","Bar") = + (((pDetectChar False '"' >>= withAttribute NormalTok) >>~ (popContext)) + <|> + ((pRegExpr regex_'5bA'2dGa'2dgZz'5d >>= withAttribute NormalTok) >>~ (popContext)) + <|> + ((pDetectChar False ' ' >>= withAttribute NormalTok) >>~ (popContext)) + <|> + ((pRangeDetect '!' '!' >>= withAttribute FloatTok)) + <|> + ((pAnyChar "()" >>= withAttribute DataTypeTok)) + <|> + ((pRegExpr regex_'3a'2a'5c'7c'2a'5b1'2d9'5d'7c'2f'2a'5c'7c >>= withAttribute CharTok) >>~ (popContext)) + <|> + (currentContext >>= \x -> guard (x == ("ABC","Bar")) >> pDefault >>= withAttribute CharTok)) + +parseRules ("ABC","Header") = + (((pColumn 0 >> pRegExpr regex_K'3a'2e'2b >>= withAttribute FloatTok) >>~ (popContext)) + <|> + ((pDetectChar False ']' >>= withAttribute FloatTok) >>~ (popContext)) + <|> + (currentContext >>= \x -> guard (x == ("ABC","Header")) >> pDefault >>= withAttribute FloatTok)) + +parseRules ("ABC","Header2") = + (currentContext >>= \x -> guard (x == ("ABC","Header2")) >> pDefault >>= withAttribute FloatTok) + + +parseRules x = parseRules ("ABC","Normal") <|> fail ("Unknown context" ++ show x) diff --git a/Text/Highlighting/Kate/Syntax/Alert_indent.hs b/Text/Highlighting/Kate/Syntax/Alert_indent.hs --- a/Text/Highlighting/Kate/Syntax/Alert_indent.hs +++ b/Text/Highlighting/Kate/Syntax/Alert_indent.hs @@ -1,5 +1,5 @@ {- This module was generated from data in the Kate syntax - highlighting file alert_indent.xml, version 1.09, by Dominik Haumann (dhdev@gmx.de) -} + highlighting file alert_indent.xml, version 1.10, by Dominik Haumann (dhdev@gmx.de) -} module Text.Highlighting.Kate.Syntax.Alert_indent (highlight, parseExpression, syntaxName, syntaxExtensions) diff --git a/Text/Highlighting/Kate/Syntax/Awk.hs b/Text/Highlighting/Kate/Syntax/Awk.hs --- a/Text/Highlighting/Kate/Syntax/Awk.hs +++ b/Text/Highlighting/Kate/Syntax/Awk.hs @@ -1,5 +1,5 @@ {- This module was generated from data in the Kate syntax - highlighting file awk.xml, version 0.92, by -} + highlighting file awk.xml, version 0.93, by -} module Text.Highlighting.Kate.Syntax.Awk (highlight, parseExpression, syntaxName, syntaxExtensions) diff --git a/Text/Highlighting/Kate/Syntax/Css.hs b/Text/Highlighting/Kate/Syntax/Css.hs --- a/Text/Highlighting/Kate/Syntax/Css.hs +++ b/Text/Highlighting/Kate/Syntax/Css.hs @@ -244,7 +244,9 @@ ((popContext) >> currentContext >>= parseRules)) parseRules ("CSS","MQEV") = - (((pRegExpr regex_'5b1'2d9'5d'5b0'2d9'2e'5d'2a'5cs'2a'2f'5cs'2a'5b1'2d9'5d'5b0'2d9'2e'5d'2a >>= withAttribute DataTypeTok) >>~ (popContext)) + (((pDetectSpaces >>= withAttribute DecValTok)) + <|> + ((pRegExpr regex_'5b1'2d9'5d'5b0'2d9'2e'5d'2a'5cs'2a'2f'5cs'2a'5b1'2d9'5d'5b0'2d9'2e'5d'2a >>= withAttribute DataTypeTok) >>~ (popContext)) <|> ((pRegExpr regex_'5b0'2d9'2e'5d'2b'28em'7cex'7cch'7crem'7cvw'7cvh'7cvm'7cpx'7cin'7ccm'7cmm'7cpt'7cpc'7cdeg'7crad'7cgrad'7cturn'7cms'7cs'7cHz'7ckHz'7cdpi'7cdpcm'29'5cb >>= withAttribute DataTypeTok) >>~ (popContext)) <|> diff --git a/Text/Highlighting/Kate/Syntax/Diff.hs b/Text/Highlighting/Kate/Syntax/Diff.hs --- a/Text/Highlighting/Kate/Syntax/Diff.hs +++ b/Text/Highlighting/Kate/Syntax/Diff.hs @@ -1,5 +1,5 @@ {- This module was generated from data in the Kate syntax - highlighting file diff.xml, version 1.11, by -} + highlighting file diff.xml, version 1.12, by -} module Text.Highlighting.Kate.Syntax.Diff (highlight, parseExpression, syntaxName, syntaxExtensions) diff --git a/Text/Highlighting/Kate/Syntax/Dot.hs b/Text/Highlighting/Kate/Syntax/Dot.hs new file mode 100644 --- /dev/null +++ b/Text/Highlighting/Kate/Syntax/Dot.hs @@ -0,0 +1,157 @@ +{- This module was generated from data in the Kate syntax + highlighting file dot.xml, version 1.1, by Postula Loïs (lois.postula@live.be) -} + +module Text.Highlighting.Kate.Syntax.Dot + (highlight, parseExpression, syntaxName, syntaxExtensions) +where +import Text.Highlighting.Kate.Types +import Text.Highlighting.Kate.Common +import qualified Text.Highlighting.Kate.Syntax.Alert +import Text.ParserCombinators.Parsec hiding (State) +import Control.Monad.State +import Data.Char (isSpace) +import qualified Data.Set as Set + +-- | Full name of language. +syntaxName :: String +syntaxName = "dot" + +-- | Filename extensions for this language. +syntaxExtensions :: String +syntaxExtensions = "*.dot" + +-- | Highlight source code using this syntax definition. +highlight :: String -> [SourceLine] +highlight input = evalState (mapM parseSourceLine $ lines input) startingState + +parseSourceLine :: String -> State SyntaxState SourceLine +parseSourceLine = mkParseSourceLine (parseExpression Nothing) + +-- | Parse an expression using appropriate local context. +parseExpression :: Maybe (String,String) + -> KateParser Token +parseExpression mbcontext = do + (lang,cont) <- maybe currentContext return mbcontext + result <- parseRules (lang,cont) + optional $ do eof + updateState $ \st -> st{ synStPrevChar = '\n' } + pEndLine + return result + +startingState = SyntaxState {synStContexts = [("dot","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []} + +pEndLine = do + updateState $ \st -> st{ synStPrevNonspace = False } + context <- currentContext + contexts <- synStContexts `fmap` getState + if length contexts >= 2 + then case context of + ("dot","Normal") -> return () + ("dot","DetectAll") -> return () + ("dot","DetectComments") -> return () + ("dot","RegionCurly") -> return () + ("dot","RegionSquare") -> return () + ("dot","RegionParen") -> return () + ("dot","String") -> (popContext) >> pEndLine + ("dot","CommentSL") -> (popContext) >> pEndLine + ("dot","CommentML") -> return () + _ -> return () + else return () + +withAttribute attr txt = do + when (null txt) $ fail "Parser matched no text" + updateState $ \st -> st { synStPrevChar = last txt + , synStPrevNonspace = synStPrevNonspace st || not (all isSpace txt) } + return (attr, txt) + +list_keywords = Set.fromList $ words $ "digraph node edge subgraph" +list_attributes = Set.fromList $ words $ "center layers margin mclimit name nodesep nslimit ordering page pagedir rank rankdir ranksep ratio rotate size distortion fillcolor fontcolor fontname fontsize height layer orientation peripheries regular shape shapefile sides skew width arrowhead arrowsize arrowtail constraint decorateP dir headclip headlabel labelangle labeldistance labelfontcolor labelfontname labelfontsize minlen port_label_distance samehead sametail tailclip taillabel weight color bgcolor label URL fontcolor fontname fontsize layer style" + +regex_'5cb'5cw'2b'5cb = compileRegex True "\\b\\w+\\b" + +parseRules ("dot","Normal") = + (((parseRules ("dot","DetectAll"))) + <|> + (currentContext >>= \x -> guard (x == ("dot","Normal")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("dot","DetectAll") = + (((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_keywords >>= withAttribute KeywordTok)) + <|> + ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_attributes >>= withAttribute DataTypeTok)) + <|> + ((pDetectChar False '"' >>= withAttribute StringTok) >>~ pushContext ("dot","String")) + <|> + ((pAnyChar ";=" >>= withAttribute OtherTok)) + <|> + ((pDetect2Chars False '-' '>' >>= withAttribute OtherTok)) + <|> + ((pFloat >>= withAttribute DecValTok)) + <|> + ((pInt >>= withAttribute DecValTok)) + <|> + ((pRegExpr regex_'5cb'5cw'2b'5cb >>= withAttribute FunctionTok)) + <|> + ((parseRules ("dot","DetectComments"))) + <|> + ((pDetectChar False '{' >>= withAttribute OtherTok) >>~ pushContext ("dot","RegionCurly")) + <|> + ((pDetectChar False '[' >>= withAttribute OtherTok) >>~ pushContext ("dot","RegionSquare")) + <|> + ((pDetectChar False '(' >>= withAttribute OtherTok) >>~ pushContext ("dot","RegionParen")) + <|> + ((pAnyChar ")]}" >>= withAttribute ErrorTok)) + <|> + (currentContext >>= \x -> guard (x == ("dot","DetectAll")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("dot","DetectComments") = + (((pDetect2Chars False '/' '/' >>= withAttribute CommentTok) >>~ pushContext ("dot","CommentSL")) + <|> + ((pDetect2Chars False '/' '*' >>= withAttribute CommentTok) >>~ pushContext ("dot","CommentML")) + <|> + (currentContext >>= \x -> guard (x == ("dot","DetectComments")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("dot","RegionCurly") = + (((pDetectChar False '}' >>= withAttribute OtherTok) >>~ (popContext)) + <|> + ((parseRules ("dot","DetectAll"))) + <|> + (currentContext >>= \x -> guard (x == ("dot","RegionCurly")) >> pDefault >>= withAttribute CommentTok)) + +parseRules ("dot","RegionSquare") = + (((pDetectChar False ']' >>= withAttribute OtherTok) >>~ (popContext)) + <|> + ((parseRules ("dot","DetectAll"))) + <|> + (currentContext >>= \x -> guard (x == ("dot","RegionSquare")) >> pDefault >>= withAttribute CommentTok)) + +parseRules ("dot","RegionParen") = + (((pDetectChar False ')' >>= withAttribute OtherTok) >>~ (popContext)) + <|> + ((parseRules ("dot","DetectAll"))) + <|> + (currentContext >>= \x -> guard (x == ("dot","RegionParen")) >> pDefault >>= withAttribute CommentTok)) + +parseRules ("dot","String") = + (((pDetect2Chars False '\\' '\\' >>= withAttribute CharTok)) + <|> + ((pDetect2Chars False '\\' '"' >>= withAttribute CharTok)) + <|> + ((pDetectChar False '"' >>= withAttribute StringTok) >>~ (popContext)) + <|> + (currentContext >>= \x -> guard (x == ("dot","String")) >> pDefault >>= withAttribute StringTok)) + +parseRules ("dot","CommentSL") = + (((Text.Highlighting.Kate.Syntax.Alert.parseExpression (Just ("Alerts","")) >>= ((withAttribute CommentTok) . snd))) + <|> + (currentContext >>= \x -> guard (x == ("dot","CommentSL")) >> pDefault >>= withAttribute CommentTok)) + +parseRules ("dot","CommentML") = + (((pDetect2Chars False '*' '/' >>= withAttribute CommentTok) >>~ (popContext)) + <|> + ((Text.Highlighting.Kate.Syntax.Alert.parseExpression (Just ("Alerts","")) >>= ((withAttribute CommentTok) . snd))) + <|> + (currentContext >>= \x -> guard (x == ("dot","CommentML")) >> pDefault >>= withAttribute CommentTok)) + +parseRules ("Alerts", _) = Text.Highlighting.Kate.Syntax.Alert.parseExpression Nothing + +parseRules x = parseRules ("dot","Normal") <|> fail ("Unknown context" ++ show x) diff --git a/Text/Highlighting/Kate/Syntax/Doxygen.hs b/Text/Highlighting/Kate/Syntax/Doxygen.hs --- a/Text/Highlighting/Kate/Syntax/Doxygen.hs +++ b/Text/Highlighting/Kate/Syntax/Doxygen.hs @@ -1,5 +1,5 @@ {- This module was generated from data in the Kate syntax - highlighting file doxygen.xml, version 1.36, by Dominik Haumann (dhdev@gmx.de) -} + highlighting file doxygen.xml, version 1.37, by Dominik Haumann (dhdev@gmx.de) -} module Text.Highlighting.Kate.Syntax.Doxygen (highlight, parseExpression, syntaxName, syntaxExtensions) diff --git a/Text/Highlighting/Kate/Syntax/Email.hs b/Text/Highlighting/Kate/Syntax/Email.hs --- a/Text/Highlighting/Kate/Syntax/Email.hs +++ b/Text/Highlighting/Kate/Syntax/Email.hs @@ -1,5 +1,5 @@ {- 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) -} + highlighting file email.xml, version 1.01, by Carl A Joslin (carl.joslin@joslin.dyndns.org) -} module Text.Highlighting.Kate.Syntax.Email (highlight, parseExpression, syntaxName, syntaxExtensions) @@ -159,45 +159,45 @@ <|> ((pColumn 0 >> pRegExpr regex_'5bRr'5deceived'3a >>= withAttribute NormalTok)) <|> - ((pColumn 0 >> pRegExpr regex_'5bXx'5d'2d'5bMm'5dozilla'2d'5bSs'5dtatus'3a >>= withAttribute NormalTok)) + ((pColumn 0 >> pRegExpr regex_'5bXx'5d'2d'5bMm'5dozilla'2d'5bSs'5dtatus'3a >>= withAttribute CommentTok)) <|> - ((pColumn 0 >> pRegExpr regex_'5bXx'5d'2d'5bMm'5dozilla'2d'5bSs'5dtatus2'3a >>= withAttribute NormalTok)) + ((pColumn 0 >> pRegExpr regex_'5bXx'5d'2d'5bMm'5dozilla'2d'5bSs'5dtatus2'3a >>= withAttribute CommentTok)) <|> - ((pColumn 0 >> pRegExpr regex_'5bEe'5dnverlope'2d'5bTt'5do'3a >>= withAttribute NormalTok)) + ((pColumn 0 >> pRegExpr regex_'5bEe'5dnverlope'2d'5bTt'5do'3a >>= withAttribute CommentTok)) <|> - ((pColumn 0 >> pRegExpr regex_'5bDd'5delivery'2d'5bDd'5date'3a >>= withAttribute NormalTok)) + ((pColumn 0 >> pRegExpr regex_'5bDd'5delivery'2d'5bDd'5date'3a >>= withAttribute CommentTok)) <|> - ((pColumn 0 >> pRegExpr regex_'5bXx'5d'2d'5bOo'5driginating'2d'5bIi'5d'5bPp'5d'3a >>= withAttribute NormalTok)) + ((pColumn 0 >> pRegExpr regex_'5bXx'5d'2d'5bOo'5driginating'2d'5bIi'5d'5bPp'5d'3a >>= withAttribute CommentTok)) <|> - ((pColumn 0 >> pRegExpr regex_'5bXx'5d'2d'5bOo'5driginating'2d'5bEe'5dmail'3a >>= withAttribute NormalTok)) + ((pColumn 0 >> pRegExpr regex_'5bXx'5d'2d'5bOo'5driginating'2d'5bEe'5dmail'3a >>= withAttribute CommentTok)) <|> - ((pColumn 0 >> pRegExpr regex_'5bXx'5d'2d'5bSs'5dender'3a >>= withAttribute NormalTok)) + ((pColumn 0 >> pRegExpr regex_'5bXx'5d'2d'5bSs'5dender'3a >>= withAttribute CommentTok)) <|> - ((pColumn 0 >> pRegExpr regex_'5bMm'5dime'2d'5bVv'5dersion'3a >>= withAttribute NormalTok)) + ((pColumn 0 >> pRegExpr regex_'5bMm'5dime'2d'5bVv'5dersion'3a >>= withAttribute CommentTok)) <|> - ((pColumn 0 >> pRegExpr regex_'5bCc'5dontent'2d'5bTt'5dype'3a >>= withAttribute NormalTok)) + ((pColumn 0 >> pRegExpr regex_'5bCc'5dontent'2d'5bTt'5dype'3a >>= withAttribute CommentTok)) <|> - ((pColumn 0 >> pRegExpr regex_'5bXx'5d'2d'5bMm'5dailing'2d'5bLl'5dist'3a >>= withAttribute NormalTok)) + ((pColumn 0 >> pRegExpr regex_'5bXx'5d'2d'5bMm'5dailing'2d'5bLl'5dist'3a >>= withAttribute CommentTok)) <|> - ((pColumn 0 >> pRegExpr regex_'5bXx'5d'2d'5bLl'5doop'3a >>= withAttribute NormalTok)) + ((pColumn 0 >> pRegExpr regex_'5bXx'5d'2d'5bLl'5doop'3a >>= withAttribute CommentTok)) <|> - ((pColumn 0 >> pRegExpr regex_'5bLl'5dist'2d'5bPp'5dost'3a >>= withAttribute NormalTok)) + ((pColumn 0 >> pRegExpr regex_'5bLl'5dist'2d'5bPp'5dost'3a >>= withAttribute CommentTok)) <|> - ((pColumn 0 >> pRegExpr regex_'5bLl'5dist'2d'5bHh'5delp'3a >>= withAttribute NormalTok)) + ((pColumn 0 >> pRegExpr regex_'5bLl'5dist'2d'5bHh'5delp'3a >>= withAttribute CommentTok)) <|> - ((pColumn 0 >> pRegExpr regex_'5bLl'5dist'2d'5bUu'5dnsubscribe'3a >>= withAttribute NormalTok)) + ((pColumn 0 >> pRegExpr regex_'5bLl'5dist'2d'5bUu'5dnsubscribe'3a >>= withAttribute CommentTok)) <|> - ((pColumn 0 >> pRegExpr regex_'5bPp'5drecedence'3a >>= withAttribute NormalTok)) + ((pColumn 0 >> pRegExpr regex_'5bPp'5drecedence'3a >>= withAttribute CommentTok)) <|> - ((pColumn 0 >> pRegExpr regex_'5bCc'5dontent'2d'5bTt'5dransfer'2d'5bEe'5dncoding'3a >>= withAttribute NormalTok)) + ((pColumn 0 >> pRegExpr regex_'5bCc'5dontent'2d'5bTt'5dransfer'2d'5bEe'5dncoding'3a >>= withAttribute CommentTok)) <|> - ((pColumn 0 >> pRegExpr regex_'5bCc'5dontent'2d'5bTt'5dype'3a >>= withAttribute NormalTok)) + ((pColumn 0 >> pRegExpr regex_'5bCc'5dontent'2d'5bTt'5dype'3a >>= withAttribute CommentTok)) <|> - ((pColumn 0 >> pRegExpr regex_'5bXx'5d'2d'5bBb'5dulkmail'3a >>= withAttribute NormalTok)) + ((pColumn 0 >> pRegExpr regex_'5bXx'5d'2d'5bBb'5dulkmail'3a >>= withAttribute CommentTok)) <|> - ((pColumn 0 >> pRegExpr regex_'5bPp'5drecedence'3a >>= withAttribute NormalTok)) + ((pColumn 0 >> pRegExpr regex_'5bPp'5drecedence'3a >>= withAttribute CommentTok)) <|> - ((pColumn 0 >> pRegExpr regex_'5bCc'5dontent'2d'5bDd'5disposition'3a >>= withAttribute NormalTok)) + ((pColumn 0 >> pRegExpr regex_'5bCc'5dontent'2d'5bDd'5disposition'3a >>= withAttribute CommentTok)) <|> ((pColumn 0 >> pRegExpr regex_'5b0'2d9a'2dzA'2dZ'2d'2e'5d'2b'3a >>= withAttribute NormalTok)) <|> diff --git a/Text/Highlighting/Kate/Syntax/Fasm.hs b/Text/Highlighting/Kate/Syntax/Fasm.hs new file mode 100644 --- /dev/null +++ b/Text/Highlighting/Kate/Syntax/Fasm.hs @@ -0,0 +1,121 @@ +{- This module was generated from data in the Kate syntax + highlighting file fasm.xml, version 0.2, by rCX (rCX12@yahoo.com) -} + +module Text.Highlighting.Kate.Syntax.Fasm + (highlight, parseExpression, syntaxName, syntaxExtensions) +where +import Text.Highlighting.Kate.Types +import Text.Highlighting.Kate.Common +import Text.ParserCombinators.Parsec hiding (State) +import Control.Monad.State +import Data.Char (isSpace) +import qualified Data.Set as Set + +-- | Full name of language. +syntaxName :: String +syntaxName = "Intel x86 (FASM)" + +-- | Filename extensions for this language. +syntaxExtensions :: String +syntaxExtensions = "*.asm;*.inc;*.fasm" + +-- | Highlight source code using this syntax definition. +highlight :: String -> [SourceLine] +highlight input = evalState (mapM parseSourceLine $ lines input) startingState + +parseSourceLine :: String -> State SyntaxState SourceLine +parseSourceLine = mkParseSourceLine (parseExpression Nothing) + +-- | Parse an expression using appropriate local context. +parseExpression :: Maybe (String,String) + -> KateParser Token +parseExpression mbcontext = do + (lang,cont) <- maybe currentContext return mbcontext + result <- parseRules (lang,cont) + optional $ do eof + updateState $ \st -> st{ synStPrevChar = '\n' } + pEndLine + return result + +startingState = SyntaxState {synStContexts = [("Intel x86 (FASM)","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []} + +pEndLine = do + updateState $ \st -> st{ synStPrevNonspace = False } + context <- currentContext + contexts <- synStContexts `fmap` getState + if length contexts >= 2 + then case context of + ("Intel x86 (FASM)","Normal") -> return () + ("Intel x86 (FASM)","Comment") -> (popContext) >> pEndLine + ("Intel x86 (FASM)","Preprocessor") -> (popContext) >> pEndLine + ("Intel x86 (FASM)","String") -> (popContext) >> pEndLine + _ -> return () + else return () + +withAttribute attr txt = do + when (null txt) $ fail "Parser matched no text" + updateState $ \st -> st { synStPrevChar = last txt + , synStPrevNonspace = synStPrevNonspace st || not (all isSpace txt) } + return (attr, txt) + +list_registers = Set.fromList $ words $ "rax eax ax ah al rbx ebx bx bh bl rcx ecx cx ch cl rdx edx dx dh dl rbp ebp bp rsi esi si rdi edi di rsp esp sp r8 r9 r10 r11 r12 r13 r14 r15 cs ds es fs gs ss cr0 cr2 cr3 cr4 dr0 dr1 dr2 dr3 dr6 dr7 st mm0 mm1 mm2 mm3 mm4 mm5 mm6 mm7 xmm0 xmm1 xmm2 xmm3 xmm4 xmm5 xmm6 xmm7" +list_instructions = Set.fromList $ words $ "aaa aad aam aas adc add addpd addps addsd addss addsubpd addsubps and andnpd andnps andpd andps arpl bound bsf bsr bswap bt btc btr bts call cbw cwde cwd cdq cdqe cqo clc cld clgi cli clts clflush cmc cmova cmovae cmovb cmovbe cmovc cmove cmovg cmovge cmovl cmovle cmovna cmovnae cmovnb cmovnbe cmovnc cmovne cmovng cmovnge cmovnl cmovnle cmovno cmovnp cmovns cmovnz cmovo cmovp cmovpe cmovpo cmovs cmovz cmp cmpeqpd cmpeqps cmpeqsd cmpeqss cmplepd cmpleps cmplesd cmpless cmpltpd cmpltps cmpltsd cmpltss cmpneqpd cmpneqps cmpneqsd cmpneqss cmpnlepd cmpnleps cmpnlesd cmpnless cmpnltpd cmpnltps cmpnltsd cmpnltss cmpordpd cmpordps cmpordsd cmpordss cmppd cmpps cmps cmpsb cmpsd cmpss cmpsw cmpunordpd cmpunordps cmpunordsd cmpunordss cmpxchg cmpxchg486 cmpxchg8b cmpxchg16b comisd comiss cpuid cvtdq2pd cvtdq2ps cvtpd2dq cvtpd2pi cvtpd2ps cvtpi2pd cvtpi2ps cvtps2dq cvtps2pd cvtps2pi cvtsd2si cvtsd2ss cvtsi2sd cvtsi2ss cvtss2sd cvtss2si cvttpd2dq cvttpd2pi cvttps2dq cvttps2pi cvttsd2si cvttss2si daa das dec div divpd divps divsd divss emms enter f2xm1 fabs fadd faddp fbld fbstp fchs fclex fnclex fcmovb fcmovbe fcmove fcmovnb fcmovnbe fcmovne fcmovnu fcmovu fcom fcomp fcompp fcomi fcomip fcos fdecstp fdisi feni fdiv fdivr fdivp fdivrp femms ffree ffreep fiadd ficom ficomp fidiv fidivr fild fimul fincstp finit fist fistp fisttp fisub fisubr fld fld1 fldl2e fldl2t fldlg2 fldln2 fldcw fldenv fldpi fldz fmul fmulp fndisi fneni fninit fnop fnsave fnstcw fnstenv fnstsw fnwait fpatan fptan fprem fprem1 frndint frstor fsave fscale fsetpm fsin fsincos fsqrt fst fstp fstcw fstenv fstsw fsub fsubr fsubp fsubrp ftst fucom fucomp fucompp fucomi fucomip fwait fxam fxch fxrstor fxsave fxtract fyl2x fyl2xp1 haddpd haddps hlt hsubpd hsubps ibts idiv imul in inc ins insb insd insw int int1 int3 into invd invlpg invlpga iret iretd iretq iretw ja jae jb jbe jc je jg jge jl jle jna jnae jnb jnbe jnc jne jng jnge jnl jnle jno jnp jns jnz jo jp jpe jpo js jz jcxz jecxz jrcxz jmp lahf lar lddqu ldmxcsr lds les lea leave lfence lfs lgdt lgs lidt lldt lmsw loadall loadall286 lods lodsb lodsd lodsq lodsw loop loope loopne loopnz loopz lsl lss ltr maskmovdqu maskmovq maxpd maxps maxsd maxss mfence minpd minps minsd minss monitor mov movapd movaps movd movddup movdq2q movdqa movdqu movhlps movhpd movhps movlhps movlpd movlps movmskpd movmskps movntdq movnti movntpd movntps movntq movq movq2dq movs movsb movsd movshdup movsldup movsq movss movsx movsxd movsw movupd movups movzx mul mulpd mulps mulsd mulss mwait neg nop not or orpd orps out outs outsb outsw outsd packssdw packsswb packuswb paddb paddd paddq paddsb paddsw paddusb paddusw paddw pand pandn pause pavgb pavgusb pavgw pcmpeqb pcmpeqw pcmpeqd pcmpgtb pcmpgtw pcmpgtd pdistib pextrw pf2id pf2iw pfacc pfadd pfcmpeq pfcmpge pfcmpgt pfmax pfmin pfmul pfnacc pfpnacc pfrcp pfrcpit1 pfrcpit2 pfrsqit1 pfrsqrt pfsub pfsubr pi2fd pi2fw pinsrw pmachriw pmaddwd pmagw pmaxsw pmaxub pminsw pminub pmovmskb pmulhrw pmulhuw pmulhw pmullw pmuludq pmvgezb pmvlzb pmvnzb pmvzb pop popa popaw popad popf popfw popfd popfq por prefetch prefetchnta prefetcht0 prefetcht1 prefetcht2 prefetchw psadbw pshufd pshufhw pshuflw pshufw pslld pslldq psllq psllw psrad psraw psrld psrldq psrlq psrlw psubb psubd psubq psubsb psubsiw psubsw psubusb psubusw psubw pswapd punpckhbw punpckhdq punpckhqdq punpckhwd punpcklbw punpckldq punpcklqdq punpcklwd push pusha pushad pushaw pushf pushfd pushfq pushfw pxor rcl rcr rcpps rcpss rdmsr rdpmc rdshr rdtsc rdtscp ret retf retn rol ror rsdc rsldt rsm rsqrtps rsqrtss rsts sahf sal sar salc sbb scas scasb scasd scasq scasw seta setae setb setbe setc sete setg setge setl setle setna setnae setnb setnbe setnc setne setng setnge setnl setnle setno setnp setns setnz seto setp setpe setpo sets setz sfence sgdt shl shld shr shrd shufpd shufps sidt skinit sldt smi smint smintold smsw sqrtpd sqrtps sqrtsd sqrtss stc std stgi sti stmxcsr stos stosb stosd stosq stosw str sub subpd subps subsd subss svdc svldt svts swapgs syscall sysenter sysexit sysret test ucomisd ucomiss ud0 ud1 ud2 umov unpckhpd unpckhps unpcklpd unpcklps verr verw vmload vmmcall vmrun vmsave wait wbinvd wrmsr wrshr xadd xbts xchg xlat xlatb xor xorpd xorps" +list_Data = Set.fromList $ words $ "db dw du dd dp df dq dt rb rw rd rp rf rq rt file byte word dword pword qword tbyte tword dqword ptr" +list_Preprocessor_Keywords = Set.fromList $ words $ "append at break common display else end equ fix foward if irp irps label local match macro purge repeat rept reverse restore struc times while virtual" +list_Instruction'2dlike_Keywords = Set.fromList $ words $ "align entry extrn format include invoke data load from heap org proc public section segment stack store use16 use32 use64" + +regex_'5cs'2a'5bA'2dZa'2dz0'2d9'40'5f'2e'24'3f'5d'2b'3a = compileRegex True "\\s*[A-Za-z0-9@_.$?]+:" +regex_'28cmov'7cfcmov'7cj'7cloop'7cset'29'28a'7cae'7cb'7cbe'7cc'7ce'7cg'7cge'7cl'7cle'7cna'7cnae'7cnb'7cnbe'7cnc'7cne'7cng'7cnge'7cnl'7cnle'7cno'7cnp'7cns'7cnz'7co'7cp'7cpe'7cpo'7cs'7cz'29 = compileRegex True "(cmov|fcmov|j|loop|set)(a|ae|b|be|c|e|g|ge|l|le|na|nae|nb|nbe|nc|ne|ng|nge|nl|nle|no|np|ns|nz|o|p|pe|po|s|z)" +regex_'28'5e'7c'5b_'5ct'2c'5d'2b'29'28'28'5c'24'7c0x'29'7b1'7d'5b0'2d9'5d'2b'5ba'2df0'2d9'5d'2a'7c'5ba'2df0'2d9'5d'2bh'29'28'5b_'5ct'2c'5d'2b'7c'24'29 = compileRegex True "(^|[ \\t,]+)((\\$|0x){1}[0-9]+[a-f0-9]*|[a-f0-9]+h)([ \\t,]+|$)" +regex_'28'5e'7c'5b_'5ct'2c'5d'2b'29'28'5b0'2d7'5d'2b'28q'7co'29'7c'5b01'5d'2bb'29'28'5b_'5ct'2c'5d'2b'7c'24'29 = compileRegex True "(^|[ \\t,]+)([0-7]+(q|o)|[01]+b)([ \\t,]+|$)" + +parseRules ("Intel x86 (FASM)","Normal") = + (((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_registers >>= withAttribute KeywordTok)) + <|> + ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_Data >>= withAttribute DataTypeTok)) + <|> + ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_instructions >>= withAttribute KeywordTok)) + <|> + ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_Instruction'2dlike_Keywords >>= withAttribute KeywordTok)) + <|> + ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_Preprocessor_Keywords >>= withAttribute OtherTok)) + <|> + ((pDetectChar False ';' >>= withAttribute CommentTok) >>~ pushContext ("Intel x86 (FASM)","Comment")) + <|> + ((pAnyChar "\"'" >>= withAttribute StringTok) >>~ pushContext ("Intel x86 (FASM)","String")) + <|> + ((pColumn 0 >> pRegExpr regex_'5cs'2a'5bA'2dZa'2dz0'2d9'40'5f'2e'24'3f'5d'2b'3a >>= withAttribute FunctionTok)) + <|> + ((pRegExpr regex_'28cmov'7cfcmov'7cj'7cloop'7cset'29'28a'7cae'7cb'7cbe'7cc'7ce'7cg'7cge'7cl'7cle'7cna'7cnae'7cnb'7cnbe'7cnc'7cne'7cng'7cnge'7cnl'7cnle'7cno'7cnp'7cns'7cnz'7co'7cp'7cpe'7cpo'7cs'7cz'29 >>= withAttribute KeywordTok)) + <|> + ((pRegExpr regex_'28'5e'7c'5b_'5ct'2c'5d'2b'29'28'28'5c'24'7c0x'29'7b1'7d'5b0'2d9'5d'2b'5ba'2df0'2d9'5d'2a'7c'5ba'2df0'2d9'5d'2bh'29'28'5b_'5ct'2c'5d'2b'7c'24'29 >>= withAttribute BaseNTok)) + <|> + ((pRegExpr regex_'28'5e'7c'5b_'5ct'2c'5d'2b'29'28'5b0'2d7'5d'2b'28q'7co'29'7c'5b01'5d'2bb'29'28'5b_'5ct'2c'5d'2b'7c'24'29 >>= withAttribute BaseNTok)) + <|> + ((pDetectChar False '$' >>= withAttribute DecValTok)) + <|> + ((pHlCOct >>= withAttribute BaseNTok)) + <|> + ((pHlCHex >>= withAttribute BaseNTok)) + <|> + ((pFloat >>= withAttribute FloatTok)) + <|> + ((pInt >>= withAttribute DecValTok)) + <|> + ((pHlCChar >>= withAttribute CharTok)) + <|> + (currentContext >>= \x -> guard (x == ("Intel x86 (FASM)","Normal")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("Intel x86 (FASM)","Comment") = + (currentContext >>= \x -> guard (x == ("Intel x86 (FASM)","Comment")) >> pDefault >>= withAttribute CommentTok) + +parseRules ("Intel x86 (FASM)","Preprocessor") = + (currentContext >>= \x -> guard (x == ("Intel x86 (FASM)","Preprocessor")) >> pDefault >>= withAttribute OtherTok) + +parseRules ("Intel x86 (FASM)","String") = + (((pAnyChar "\"'" >>= withAttribute StringTok) >>~ (popContext)) + <|> + (currentContext >>= \x -> guard (x == ("Intel x86 (FASM)","String")) >> pDefault >>= withAttribute StringTok)) + + +parseRules x = parseRules ("Intel x86 (FASM)","Normal") <|> fail ("Unknown context" ++ show x) diff --git a/Text/Highlighting/Kate/Syntax/Fsharp.hs b/Text/Highlighting/Kate/Syntax/Fsharp.hs --- a/Text/Highlighting/Kate/Syntax/Fsharp.hs +++ b/Text/Highlighting/Kate/Syntax/Fsharp.hs @@ -1,5 +1,5 @@ {- This module was generated from data in the Kate syntax - highlighting file fsharp.xml, version 0.0.1, by Bas Bossink (bas.bossink@gmail.com) -} + highlighting file fsharp.xml, version 0.1, by Bas Bossink (bas.bossink@gmail.com) -} module Text.Highlighting.Kate.Syntax.Fsharp (highlight, parseExpression, syntaxName, syntaxExtensions) diff --git a/Text/Highlighting/Kate/Syntax/Glsl.hs b/Text/Highlighting/Kate/Syntax/Glsl.hs new file mode 100644 --- /dev/null +++ b/Text/Highlighting/Kate/Syntax/Glsl.hs @@ -0,0 +1,131 @@ +{- This module was generated from data in the Kate syntax + highlighting file glsl.xml, version 1.03, by Oliver Richers (o.richers@tu-bs.de) -} + +module Text.Highlighting.Kate.Syntax.Glsl + (highlight, parseExpression, syntaxName, syntaxExtensions) +where +import Text.Highlighting.Kate.Types +import Text.Highlighting.Kate.Common +import Text.ParserCombinators.Parsec hiding (State) +import Control.Monad.State +import Data.Char (isSpace) +import qualified Data.Set as Set + +-- | Full name of language. +syntaxName :: String +syntaxName = "GLSL" + +-- | Filename extensions for this language. +syntaxExtensions :: String +syntaxExtensions = "*.glsl;*.vert;*.frag;*.geom" + +-- | Highlight source code using this syntax definition. +highlight :: String -> [SourceLine] +highlight input = evalState (mapM parseSourceLine $ lines input) startingState + +parseSourceLine :: String -> State SyntaxState SourceLine +parseSourceLine = mkParseSourceLine (parseExpression Nothing) + +-- | Parse an expression using appropriate local context. +parseExpression :: Maybe (String,String) + -> KateParser Token +parseExpression mbcontext = do + (lang,cont) <- maybe currentContext return mbcontext + result <- parseRules (lang,cont) + optional $ do eof + updateState $ \st -> st{ synStPrevChar = '\n' } + pEndLine + return result + +startingState = SyntaxState {synStContexts = [("GLSL","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []} + +pEndLine = do + updateState $ \st -> st{ synStPrevNonspace = False } + context <- currentContext + contexts <- synStContexts `fmap` getState + if length contexts >= 2 + then case context of + ("GLSL","Normal") -> return () + ("GLSL","Member") -> (popContext) >> pEndLine + ("GLSL","Commentar 1") -> (popContext) >> pEndLine + ("GLSL","Commentar 2") -> return () + ("GLSL","Preprocessor") -> (popContext) >> pEndLine + _ -> return () + else return () + +withAttribute attr txt = do + when (null txt) $ fail "Parser matched no text" + updateState $ \st -> st { synStPrevChar = last txt + , synStPrevNonspace = synStPrevNonspace st || not (all isSpace txt) } + return (attr, txt) + +list_keywords = Set.fromList $ words $ "break continue do for while if else true false discard return struct" +list_types = Set.fromList $ words $ "float int void bool mat2 mat3 mat4 vec2 vec3 vec4 ivec2 ivec3 ivec4 bvec2 bvec3 bvec4 sampler1D sampler2D sampler3D samplerCube sampler1DShadow sampler2DShadow" +list_typequal = Set.fromList $ words $ "attribute const uniform varying in out inout" +list_attention = Set.fromList $ words $ "FIXME TODO BUG" +list_stdlib = Set.fromList $ words $ "radians degrees sin cos tan asin acos atan pow exp log exp2 log2 sqrt inversesqrt abs sign floor ceil fract mod min max clamp mix step smoothstep length distance dot cross normalize ftransform faceforward reflect refract matrixCompMult lessThan lessThenEqual greaterThan greaterThanEqual equal notEqual any all not texture1D texture1DProj texture1DLod texture1DProjLod texture2D texture2DProj texture2DLod texture2DProjLod texture3D texture3DProj texture3DLod texture3DProjLod textureCube textureCubeLod shadow1D shadow2D shadow1DProj shadow2DProj shadow1DLod shadow2DLod shadow1DProjLod shadow2DProjLod dFdx dFdy fwidth noise1 noise2 noise3 noise4" +list_stdvar = Set.fromList $ words $ "gl_Position gl_PointSize gl_ClipVertex gl_FragCoord gl_FragFacing gl_FragColor gl_FragData gl_FragDepth gl_Color gl_SecondaryColor gl_Normal gl_Vertex gl_MultiTexCoord0 gl_MultiTexCoord1 gl_MultiTexCoord2 gl_MultiTexCoord2 gl_MultiTexCoord3 gl_MultiTexCoord4 gl_MultiTexCoord5 gl_MultiTexCoord6 gl_MultiTexCoord7 gl_FogColor gl_MaxLights gl_MaxClipPlanes gl_MaxTextureUnits gl_MaxTextureCoords gl_MaxVertexAttributes gl_MaxVertexUniformComponents gl_MaxVaryingFloats gl_MaxVertexTextureImageUnits gl_MaxCombinedTextureImageUnits gl_MaxTextureImageUnits gl_MaxFragmentUniformComponents gl_MaxDrawBuffers gl_ModelViewMatrix gl_ProjectionMatrix gl_ModelViewProjectionMatrix gl_TextureMatrix gl_NormalMatrix gl_ModelViewMatrixInverse gl_ProjectionMatrixInverse gl_ModelViewProjectionMatrixInverse gl_TextureMatrixInverse gl_ModelViewMatrixTranspose gl_ProjectionMatrixTranspose gl_ModelViewProjectionMatrixTranspose gl_TextureMatrixTranspose gl_ModelViewMatrixInverseTranspose gl_ProjectionMatrixInverseTranspose gl_ModelViewProjectionMatrixInverseTranspose gl_TextureMatrixInverseTranspose gl_NormScale gl_DepthRangeParameters gl_DepthRange gl_ClipPlane gl_PointParameters gl_Point gl_MaterialParameters gl_FrontMaterial gl_BackMaterial gl_LightSourceParameters gl_LightSource gl_LightModelParameters gl_LightModel gl_LightModelProducts gl_FrontLightModelProduct gl_BackLightModelProduct gl_LightProducts gl_FrontLightProduct gl_BackLightProduct gl_TextureEnvColor gl_EyePlaneS gl_EyePlaneT gl_EyePlaneR gl_EyePlaneQ gl_ObjectPlaneS gl_ObjectPlaneT gl_ObjectPlaneR gl_ObjectPlaneQ gl_FogParameters gl_Fog gl_FrontColor gl_BackColor gl_FrontSecondaryColor gl_BackSecondaryColor gl_TexCoord gl_FogFragCoord gl_Color gl_SecondaryColor" + +regex_'5cb'5b'5f'5cw'5d'5b'5f'5cw'5cd'5d'2a'28'3f'3d'5b'5cs'5d'2a'5b'28'5d'29 = compileRegex True "\\b[_\\w][_\\w\\d]*(?=[\\s]*[(])" +regex_'5b'2e'5d'7b1'2c1'7d = compileRegex True "[.]{1,1}" +regex_'5cb'5b'5f'5cw'5d'5b'5f'5cw'5cd'5d'2a'28'3f'3d'5b'5cs'5d'2a'29 = compileRegex True "\\b[_\\w][_\\w\\d]*(?=[\\s]*)" + +parseRules ("GLSL","Normal") = + (((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_keywords >>= withAttribute KeywordTok)) + <|> + ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_types >>= withAttribute DataTypeTok)) + <|> + ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_typequal >>= withAttribute DataTypeTok)) + <|> + ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_stdlib >>= withAttribute FunctionTok)) + <|> + ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_stdvar >>= withAttribute FunctionTok)) + <|> + ((pFloat >>= withAttribute FloatTok)) + <|> + ((pHlCOct >>= withAttribute BaseNTok)) + <|> + ((pHlCHex >>= withAttribute BaseNTok)) + <|> + ((pInt >>= withAttribute DecValTok)) + <|> + ((pDetect2Chars False '/' '/' >>= withAttribute CommentTok) >>~ pushContext ("GLSL","Commentar 1")) + <|> + ((pDetect2Chars False '/' '*' >>= withAttribute CommentTok) >>~ pushContext ("GLSL","Commentar 2")) + <|> + ((pDetectChar False '{' >>= withAttribute NormalTok)) + <|> + ((pDetectChar False '}' >>= withAttribute NormalTok)) + <|> + ((pFirstNonSpace >> pDetectChar False '#' >>= withAttribute OtherTok) >>~ pushContext ("GLSL","Preprocessor")) + <|> + ((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 FunctionTok)) + <|> + ((pRegExpr regex_'5b'2e'5d'7b1'2c1'7d >>= withAttribute NormalTok) >>~ pushContext ("GLSL","Member")) + <|> + ((pAnyChar ".+-/*%<>[]()^|&~=!:;,?;" >>= withAttribute NormalTok)) + <|> + (currentContext >>= \x -> guard (x == ("GLSL","Normal")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("GLSL","Member") = + (((pRegExpr regex_'5cb'5b'5f'5cw'5d'5b'5f'5cw'5cd'5d'2a'28'3f'3d'5b'5cs'5d'2a'29 >>= withAttribute FunctionTok) >>~ (popContext)) + <|> + ((popContext) >> currentContext >>= parseRules)) + +parseRules ("GLSL","Commentar 1") = + (((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_attention >>= withAttribute AlertTok)) + <|> + (currentContext >>= \x -> guard (x == ("GLSL","Commentar 1")) >> pDefault >>= withAttribute CommentTok)) + +parseRules ("GLSL","Commentar 2") = + (((pDetect2Chars False '*' '/' >>= withAttribute CommentTok) >>~ (popContext)) + <|> + ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_attention >>= withAttribute AlertTok)) + <|> + (currentContext >>= \x -> guard (x == ("GLSL","Commentar 2")) >> pDefault >>= withAttribute CommentTok)) + +parseRules ("GLSL","Preprocessor") = + (currentContext >>= \x -> guard (x == ("GLSL","Preprocessor")) >> pDefault >>= withAttribute OtherTok) + + +parseRules x = parseRules ("GLSL","Normal") <|> fail ("Unknown context" ++ show x) diff --git a/Text/Highlighting/Kate/Syntax/Haskell.hs b/Text/Highlighting/Kate/Syntax/Haskell.hs --- a/Text/Highlighting/Kate/Syntax/Haskell.hs +++ b/Text/Highlighting/Kate/Syntax/Haskell.hs @@ -1,5 +1,5 @@ {- This module was generated from data in the Kate syntax - highlighting file haskell.xml, version 2.2, by Nicolas Wu (zenzike@gmail.com) -} + highlighting file haskell.xml, version 2.4, by Nicolas Wu (zenzike@gmail.com) -} module Text.Highlighting.Kate.Syntax.Haskell (highlight, parseExpression, syntaxName, syntaxExtensions) @@ -68,7 +68,7 @@ return (attr, txt) list_keywords = Set.fromList $ words $ "case class data deriving do else if in infixl infixr instance let module newtype of primitive then type where" -list_prelude_function = Set.fromList $ words $ "abs acos acosh all and any appendFile approxRational asTypeOf asin asinh atan atan2 atanh basicIORun break catch ceiling chr compare concat concatMap const cos cosh curry cycle decodeFloat denominator digitToInt div divMod drop dropWhile either elem encodeFloat enumFrom enumFromThen enumFromThenTo enumFromTo error even exp exponent fail filter flip floatDigits floatRadix floatRange floor fmap foldl foldl1 foldr foldr1 fromDouble fromEnum fromInt fromInteger fromIntegral fromRational fst gcd getChar getContents getLine group head id inRange index init intToDigit interact ioError isAlpha isAlphaNum isAscii isControl isDenormalized isDigit isHexDigit isIEEE isInfinite isLower isNaN isNegativeZero isOctDigit isPrint isSpace isUpper iterate last lcm length lex lexDigits lexLitChar lines log logBase lookup map mapM mapM_ max maxBound maximum maybe min minBound minimum mod negate not notElem null numerator odd or ord otherwise pack pi pred primExitWith print product properFraction putChar putStr putStrLn quot quotRem range rangeSize read readDec readFile readFloat readHex readIO readInt readList readLitChar readLn readOct readParen readSigned reads readsPrec realToFrac recip rem repeat replicate return reverse round scaleFloat scanl scanl1 scanr scanr1 seq sequence sequence_ show showChar showInt showList showLitChar showParen showSigned showString shows showsPrec significand signum sin sinh snd sort span splitAt sqrt subtract succ sum tail take takeWhile tan tanh threadToIOResult toEnum toInt toInteger toLower toRational toUpper truncate uncurry undefined unlines until unwords unzip unzip3 userError words writeFile zip zip3 zipWith zipWith3" +list_prelude_function = Set.fromList $ words $ "FilePath IOError abs acos acosh all and any appendFile approxRational asTypeOf asin asinh atan atan2 atanh basicIORun break catch ceiling chr compare concat concatMap const cos cosh curry cycle decodeFloat denominator digitToInt div divMod drop dropWhile either elem encodeFloat enumFrom enumFromThen enumFromThenTo enumFromTo error even exp exponent fail filter flip floatDigits floatRadix floatRange floor fmap foldl foldl1 foldr foldr1 fromDouble fromEnum fromInt fromInteger fromIntegral fromRational fst gcd getChar getContents getLine group head id inRange index init intToDigit interact ioError isAlpha isAlphaNum isAscii isControl isDenormalized isDigit isHexDigit isIEEE isInfinite isLower isNaN isNegativeZero isOctDigit isPrint isSpace isUpper iterate last lcm length lex lexDigits lexLitChar lines log logBase lookup map mapM mapM_ max maxBound maximum maybe min minBound minimum mod negate not notElem null numerator odd or ord otherwise pack pi pred primExitWith print product properFraction putChar putStr putStrLn quot quotRem range rangeSize read readDec readFile readFloat readHex readIO readInt readList readLitChar readLn readOct readParen readSigned reads readsPrec realToFrac recip rem repeat replicate return reverse round scaleFloat scanl scanl1 scanr scanr1 seq sequence sequence_ show showChar showInt showList showLitChar showParen showSigned showString shows showsPrec significand signum sin sinh snd sort span splitAt sqrt subtract succ sum tail take takeWhile tan tanh threadToIOResult toEnum toInt toInteger toLower toRational toUpper truncate uncurry undefined unlines until unwords unzip unzip3 userError words writeFile zip zip3 zipWith zipWith3" list_prelude_class = Set.fromList $ words $ "Bounded Enum Eq Floating Fractional Functor Integral Ix Monad Num Ord Read Real RealFloat RealFrac Show" list_prelude_type = Set.fromList $ words $ "Bool Char Double Either FilePath Float Int Integer IO IOError Maybe Ordering Ratio Rational ReadS ShowS String ByteString" list_prelude_data = Set.fromList $ words $ "False True Left Right Just Nothing EQ LT GT" @@ -88,7 +88,9 @@ regex_'28'5bA'2dZ'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a'5c'2e'29'2a'5ba'2dz'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a = compileRegex True "([A-Z][a-zA-Z0-9_']*\\.)*[a-z][a-zA-Z0-9_']*" regex_'28'5bA'2dZ'5d'5ba'2dzA'2dZ0'2d0'5f'27'5d'2a'5c'2e'29'2a'5b'5c'2d'21'23'5c'24'25'26'5c'2a'5c'2b'2f'3c'3d'3e'5c'3f'5c'40'5c'5e'5c'7c'7e'5c'2e'3a'5d'2b = compileRegex True "([A-Z][a-zA-Z0-0_']*\\.)*[\\-!#\\$%&\\*\\+/<=>\\?\\@\\^\\|~\\.:]+" regex_'28'5bA'2dZ'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a'5c'2e'29'2a'5bA'2dZ'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a = compileRegex True "([A-Z][a-zA-Z0-9_']*\\.)*[A-Z][a-zA-Z0-9_']*" -regex_'5cd'2b'5c'2e'5cd'2b = compileRegex True "\\d+\\.\\d+" +regex_'5cd'2b'5c'2e'5cd'2b'28'5bEe'5d'5b'2b'2d'5d'3f'5cd'2b'29'3f'7c'5cd'2b'5bEe'5d'5b'2b'2d'5d'3f'5cd'2b = compileRegex True "\\d+\\.\\d+([Ee][+-]?\\d+)?|\\d+[Ee][+-]?\\d+" +regex_0'5bOo'5d'5b0'2d7'5d'2b = compileRegex True "0[Oo][0-7]+" +regex_0'5bXx'5d'5b0'2d9A'2dFa'2df'5d'2b = compileRegex True "0[Xx][0-9A-Fa-f]+" regex_'5c'5c'2e = compileRegex True "\\\\." regex_context = compileRegex True "context" regex_call = compileRegex True "call" @@ -142,9 +144,13 @@ <|> ((pRegExpr regex_'28'5bA'2dZ'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a'5c'2e'29'2a'5bA'2dZ'5d'5ba'2dzA'2dZ0'2d9'5f'27'5d'2a >>= withAttribute DataTypeTok)) <|> - ((pInt >>= withAttribute DecValTok)) + ((pRegExpr regex_'5cd'2b'5c'2e'5cd'2b'28'5bEe'5d'5b'2b'2d'5d'3f'5cd'2b'29'3f'7c'5cd'2b'5bEe'5d'5b'2b'2d'5d'3f'5cd'2b >>= withAttribute FloatTok)) <|> - ((pRegExpr regex_'5cd'2b'5c'2e'5cd'2b >>= withAttribute FloatTok)) + ((pRegExpr regex_0'5bOo'5d'5b0'2d7'5d'2b >>= withAttribute BaseNTok)) + <|> + ((pRegExpr regex_0'5bXx'5d'5b0'2d9A'2dFa'2df'5d'2b >>= withAttribute BaseNTok)) + <|> + ((pInt >>= withAttribute DecValTok)) <|> ((pDetectChar False '\'' >>= withAttribute CharTok) >>~ pushContext ("Haskell","char")) <|> diff --git a/Text/Highlighting/Kate/Syntax/Javadoc.hs b/Text/Highlighting/Kate/Syntax/Javadoc.hs --- a/Text/Highlighting/Kate/Syntax/Javadoc.hs +++ b/Text/Highlighting/Kate/Syntax/Javadoc.hs @@ -1,5 +1,5 @@ {- This module was generated from data in the Kate syntax - highlighting file javadoc.xml, version 1.04, by Alfredo Luiz Foltran Fialho (alfoltran@ig.com.br) -} + highlighting file javadoc.xml, version 1.05, by Alfredo Luiz Foltran Fialho (alfoltran@ig.com.br) -} module Text.Highlighting.Kate.Syntax.Javadoc (highlight, parseExpression, syntaxName, syntaxExtensions) diff --git a/Text/Highlighting/Kate/Syntax/Lilypond.hs b/Text/Highlighting/Kate/Syntax/Lilypond.hs new file mode 100644 --- /dev/null +++ b/Text/Highlighting/Kate/Syntax/Lilypond.hs @@ -0,0 +1,844 @@ +{- This module was generated from data in the Kate syntax + highlighting file lilypond.xml, version 3.07, by Wilbert Berendsen (info@wilbertberendsen.nl) -} + +module Text.Highlighting.Kate.Syntax.Lilypond + (highlight, parseExpression, syntaxName, syntaxExtensions) +where +import Text.Highlighting.Kate.Types +import Text.Highlighting.Kate.Common +import qualified Text.Highlighting.Kate.Syntax.Alert +import Text.ParserCombinators.Parsec hiding (State) +import Control.Monad.State +import Data.Char (isSpace) +import qualified Data.Set as Set + +-- | Full name of language. +syntaxName :: String +syntaxName = "LilyPond" + +-- | Filename extensions for this language. +syntaxExtensions :: String +syntaxExtensions = "*.ly;*.LY;*.ily;*.ILY;*.lyi;*.LYI" + +-- | Highlight source code using this syntax definition. +highlight :: String -> [SourceLine] +highlight input = evalState (mapM parseSourceLine $ lines input) startingState + +parseSourceLine :: String -> State SyntaxState SourceLine +parseSourceLine = mkParseSourceLine (parseExpression Nothing) + +-- | Parse an expression using appropriate local context. +parseExpression :: Maybe (String,String) + -> KateParser Token +parseExpression mbcontext = do + (lang,cont) <- maybe currentContext return mbcontext + result <- parseRules (lang,cont) + optional $ do eof + updateState $ \st -> st{ synStPrevChar = '\n' } + pEndLine + return result + +startingState = SyntaxState {synStContexts = [("LilyPond","lilypond")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []} + +pEndLine = do + updateState $ \st -> st{ synStPrevNonspace = False } + context <- currentContext + contexts <- synStContexts `fmap` getState + if length contexts >= 2 + then case context of + ("LilyPond","lilypond") -> return () + ("LilyPond","music") -> return () + ("LilyPond","default") -> return () + ("LilyPond","basic") -> return () + ("LilyPond","musiccommand") -> (popContext) >> pEndLine + ("LilyPond","command") -> (popContext) >> pEndLine + ("LilyPond","assignment") -> (popContext) >> pEndLine + ("LilyPond","pitch") -> return () + ("LilyPond","duration") -> return () + ("LilyPond","chord") -> return () + ("LilyPond","chordpitch") -> return () + ("LilyPond","chordend") -> return () + ("LilyPond","commentline") -> (popContext) >> pEndLine + ("LilyPond","commentblock") -> return () + ("LilyPond","string") -> return () + ("LilyPond","connect") -> return () + ("LilyPond","scheme") -> return () + ("LilyPond","scheme2") -> (popContext >> popContext) >> pEndLine + ("LilyPond","scheme3") -> return () + ("LilyPond","schemerules") -> return () + ("LilyPond","schemequote") -> (popContext) >> pEndLine + ("LilyPond","schemelily") -> return () + ("LilyPond","schemecommentline") -> (popContext) >> pEndLine + ("LilyPond","schemecommentblock") -> return () + ("LilyPond","schemesub") -> (popContext) >> pEndLine + ("LilyPond","schemestring") -> return () + ("LilyPond","notemode") -> return () + ("LilyPond","notemode2") -> return () + ("LilyPond","noterules") -> return () + ("LilyPond","drummode") -> return () + ("LilyPond","drummode2") -> return () + ("LilyPond","drumrules") -> return () + ("LilyPond","drumchord") -> return () + ("LilyPond","chordmode") -> return () + ("LilyPond","chordmode2") -> return () + ("LilyPond","chordrules") -> return () + ("LilyPond","figuremode") -> return () + ("LilyPond","figuremode2") -> return () + ("LilyPond","figurerules") -> return () + ("LilyPond","figure") -> return () + ("LilyPond","lyricmode") -> return () + ("LilyPond","lyricmode2") -> return () + ("LilyPond","lyricsto") -> return () + ("LilyPond","lyricsto2") -> return () + ("LilyPond","lyricsto3") -> return () + ("LilyPond","lyricrules") -> return () + ("LilyPond","markup") -> return () + ("LilyPond","markup2") -> return () + ("LilyPond","markuprules") -> return () + ("LilyPond","section") -> return () + ("LilyPond","section2") -> return () + ("LilyPond","sectionrules") -> return () + ("LilyPond","context") -> return () + ("LilyPond","context2") -> return () + ("LilyPond","set") -> return () + ("LilyPond","override") -> return () + ("LilyPond","tempo") -> return () + _ -> return () + else return () + +withAttribute attr txt = do + when (null txt) $ fail "Parser matched no text" + updateState $ \st -> st { synStPrevChar = last txt + , synStPrevNonspace = synStPrevNonspace st || not (all isSpace txt) } + return (attr, txt) + +list_contexts = Set.fromList $ words $ "ChoirStaff ChordNames CueVoice Devnull DrumStaff DrumVoice Dynamics FiguredBass FretBoards Global GrandStaff GregorianTranscriptionStaff GregorianTranscriptionVoice Lyrics MensuralStaff MensuralVoice NoteNames PianoStaff RhythmicStaff Score Staff StaffGroup TabStaff TabVoice Timing VaticanaStaff VaticanaVoice Voice" +list_deprecatedcontexts = Set.fromList $ words $ "InnerChoirStaff InnerStaffGroup" +list_layoutobjects = Set.fromList $ words $ "Accidental AccidentalCautionary AccidentalPlacement AccidentalSuggestion Ambitus AmbitusAccidental AmbitusLine AmbitusNoteHead Arpeggio BalloonTextItem BarLine BarNumber BassFigure BassFigureAlignment BassFigureAlignmentPositioning BassFigureBracket BassFigureContinuation BassFigureLine Beam BendAfter BreakAlignGroup BreakAlignment BreathingSign ChordName Clef ClusterSpanner ClusterSpannerBeacon CombineTextScript Custos DotColumn Dots DoublePercentRepeat DoublePercentRepeatCounter DynamicLineSpanner DynamicText DynamicTextSpanner Episema Fingering FretBoard Glissando GraceSpacing GridLine GridPoint Hairpin HarmonicParenthesesItem HorizontalBracket InstrumentName InstrumentSwitch KeyCancellation KeySignature LaissezVibrerTie LaissezVibrerTieColumn LedgerLineSpanner LeftEdge LigatureBracket LyricExtender LyricHyphen LyricSpace LyricText MeasureGrouping MelodyItem MensuralLigature MetronomeMark MultiMeasureRest MultiMeasureRestNumber MultiMeasureRestText NonMusicalPaperColumn NoteCollision NoteColumn NoteHead NoteName NoteSpacing OctavateEight OttavaBracket PaperColumn ParenthesesItem PercentRepeat PercentRepeatCounter PhrasingSlur PianoPedalBracket RehearsalMark RepeatSlash RepeatTie RepeatTieColumn Rest RestCollision Script ScriptColumn ScriptRow SeparationItem Slur SostenutoPedal SostenutoPedalLineSpanner SpacingSpanner SpanBar StaffGrouper StaffSpacing StaffSymbol StanzaNumber Stem StemTremolo StringNumber StrokeFinger SustainPedal SustainPedalLineSpanner System SystemStartBar SystemStartBrace SystemStartBracket SystemStartSquare TabNoteHead TextScript TextSpanner Tie TieColumn TimeSignature TrillPitchAccidental TrillPitchGroup TrillPitchHead TrillSpanner TupletBracket TupletNumber UnaCordaPedal UnaCordaPedalLineSpanner VaticanaLigature VerticalAlignment VerticalAxisGroup VoiceFollower VoltaBracket VoltaBracketSpanner" +list_properties = Set.fromList $ words $ "aDueText alignAboveContext alignBassFigureAccidentals alignBelowContext allowBeamBreak associatedVoice autoAccidentals autoBeamCheck autoBeamSettings autoBeaming autoCautionaries automaticBars barAlways barCheckSynchronize barNumberVisibility baseMoment bassFigureFormatFunction bassStaffProperties beamExceptions beatGrouping beatLength beatStructure chordChanges chordNameExceptions chordNameExceptionsFull chordNameExceptionsPartial chordNameFunction chordNameSeparator chordNoteNamer chordPrefixSpacer chordRootNamer clefGlyph clefOctavation clefPosition connectArpeggios countPercentRepeats createKeyOnClefChange createSpacing crescendoSpanner crescendoText currentBarNumber decrescendoSpanner decrescendoText defaultBarType doubleSlurs doubleRepeatType drumPitchTable drumStyleTable dynamicAbsoluteVolumeFunction explicitClefVisibility explicitKeySignatureVisibility extendersOverRests extraNatural figuredBassAlterationDirection figuredBassCenterContinuations figuredBassFormatter figuredBassPlusDirection fingeringOrientations firstClef followVoice fontSize forbidBreak forceClef gridInterval hairpinToBarline harmonicAccidentals highStringOne ignoreBarChecks ignoreFiguredBassRest ignoreMelismata implicitBassFigures implicitTimeSignatureVisibility instrumentCueName instrumentEqualizer instrumentName instrumentTransposition internalBarNumber keepAliveInterfaces keyAlterationOrder keySignature lyricMelismaAlignment majorSevenSymbol markFormatter maximumFretStretch measureLength measurePosition melismaBusyProperties metronomeMarkFormatter middleCClefPosition middleCOffset middleCPosition midiInstrument midiMaximumVolume midiMinimumVolume minimumFret minimumPageTurnLength minimumRepeatLengthForPageTurn noteToFretFunction ottavation output pedalSostenutoStrings pedalSostenutoStyle pedalSustainStrings pedalSustainStyle pedalUnaCordaStrings pedalUnaCordaStyle printKeyCancellation printOctaveNames printPartCombineTexts proportionalNotationDuration recordEventSequence rehearsalMark repeatCommands restNumberThreshold scriptDefinitions shapeNoteStyles shortInstrumentName shortVocalName skipBars skipTypesetting soloIIText soloText squashedPosition staffLineLayoutFunction stanza stemLeftBeamCount stemRightBeamCount stringNumberOrientations stringOneTopmost stringTunings strokeFingerOrientations subdivideBeams suggestAccidentals systemStartDelimiter systemStartDelimiterHierarchy tablatureFormat tempoUnitCount tempoUnitDuration tempoWholesPerMinute tieWaitForNote timeSignatureFraction timing tonic topLevelAlignment trebleStaffProperties tremoloFlags tupletFullLength tupletFullLengthNote tupletSpannerDuration useBassFigureExtenders verticallySpacedContexts vocalName voltaOnThisStaff voltaSpannerDuration whichBar" +list_deprecatedproperties = Set.fromList $ words $ "barNumberAlignSymbol centralCPosition extraVerticalExtent fingerHorizontalDirection instr instrument keyAccidentalOrder minimumVerticalExtent rehearsalMarkAlignSymbol soloADue tupletNumberFormatFunction vocNam" +list_musicexpressions = Set.fromList $ words $ "AbsoluteDynamicEvent AnnotateOutputEvent ApplyContext ApplyOutputEvent ArpeggioEvent ArticulationEvent AutoChangeMusic BarCheck BassFigureEvent BeamEvent BeamForbidEvent BendAfterEvent BreathingEvent ClusterNoteEvent ContextChange ContextSpeccedMusic CrescendoEvent DecrescendoEvent Event EventChord ExtenderEvent FingeringEvent GlissandoEvent GraceMusic HarmonicEvent HyphenEvent KeyChangeEvent LabelEvent LaissezVibrerEvent LigatureEvent LineBreakEvent LyricCombineMusic LyricEvent MarkEvent MultiMeasureRestEvent MultiMeasureRestMusic MultiMeasureTextEvent Music NoteEvent NoteGroupingEvent OverrideProperty PageBreakEvent PageTurnEvent PartCombineMusic PercentEvent PercentRepeatedMusic PesOrFlexaEvent PhrasingSlurEvent PropertySet PropertyUnset QuoteMusic RelativeOctaveCheck RelativeOctaveMusic RepeatTieEvent RepeatedMusic RestEvent RevertProperty ScriptEvent SequentialMusic SimultaneousMusic SkipEvent SkipMusic SlurEvent SoloOneEvent SoloTwoEvent SostenutoEvent SpacingSectionEvent SpanEvent StaffSpanEvent StringNumberEvent StrokeFingerEvent SustainEvent TextScriptEvent TextSpanEvent TieEvent TimeScaledMusic TransposedMusic TremoloEvent TremoloRepeatedMusic TremoloSpanEvent TrillSpanEvent TupletSpanEvent UnaCordaEvent UnfoldedRepeatedMusic UnisonoEvent UnrelativableMusic VoiceSeparator VoltaRepeatedMusic" +list_drumpitchnames = Set.fromList $ words $ "acousticbassdrum acousticsnare agh agl bassdrum bd bda boh bohm boho bol bolm bolo cab cabasa cb cgh cghm cgho cgl cglm cglo chinesecymbal cl claves closedhihat cowbell crashcymbal crashcymbala crashcymbalb cuim cuio cymc cymca cymcb cymch cymr cymra cymrb cyms da db dc dd de electricsnare fivedown fiveup fourdown fourup gui guil guiro guis halfopenhihat handclap hc hh hhc hhho hho hhp hiagogo hibongo hiconga highfloortom hightom hihat himidtom hisidestick hitimbale hiwoodblock loagogo lobongo loconga longguiro longwhistle losidestick lotimbale lowfloortom lowmidtom lowoodblock lowtom mar maracas mutecuica mutehibongo mutehiconga mutelobongo muteloconga mutetriangle onedown oneup opencuica openhibongo openhiconga openhihat openlobongo openloconga opentriangle pedalhihat rb ridebell ridecymbal ridecymbala ridecymbalb shortguiro shortwhistle sidestick sn sna snare sne splashcymbal ss ssh ssl tamb tambourine tamtam threedown threeup timh timl tomfh tomfl tomh toml tommh tomml tri triangle trim trio tt twodown twoup ua ub uc ud ue vibraslap vibs wbh wbl whl whs" + +regex_'5cb'5ba'2dz'5d'2b'5cs'2a'3d = compileRegex True "\\b[a-z]+\\s*=" +regex_'5ba'2dz'5d'2b'5cd'2b'5c'2e'2a'5b'2c'27'5d'2b = compileRegex True "[a-z]+\\d+\\.*[,']+" +regex_'28'5cb'5bsrR'5d'28'3f'21'5bA'2dZa'2dz'5d'29'7c'5cb'28'5ba'2dh'5d'28'28iss'29'7b1'2c2'7d'7c'28ess'29'7b1'2c2'7d'7c'28is'29'7b1'2c2'7d'7c'28es'29'7b1'2c2'7d'7c'28sharp'29'7b1'2c2'7d'7c'28flat'29'7b1'2c2'7d'7css'3f'7cff'3f'29'3f'7c'28do'7cre'7cmi'7cfa'7csol'7cla'7csi'29'28dd'3f'7cbb'3f'7css'3f'7ckk'3f'29'3f'7cq'29'28'27'2b'7c'2c'2b'7c'28'3f'21'5bA'2dZa'2dz'5d'29'29'29 = compileRegex True "(\\b[srR](?![A-Za-z])|\\b([a-h]((iss){1,2}|(ess){1,2}|(is){1,2}|(es){1,2}|(sharp){1,2}|(flat){1,2}|ss?|ff?)?|(do|re|mi|fa|sol|la|si)(dd?|bb?|ss?|kk?)?|q)('+|,+|(?![A-Za-z])))" +regex_'3a'5cd'2a = compileRegex True ":\\d*" +regex_'5c'5c'28p'7b1'2c5'7d'7cmp'7cmf'7cf'7b1'2c5'7d'7cs'3ffp'7csff'3f'7cspp'3f'7c'5bsr'5d'3ffz'7ccresc'7cdecresc'7cdim'29'28'3f'21'5bA'2dZa'2dz'5d'29 = compileRegex True "\\\\(p{1,5}|mp|mf|f{1,5}|s?fp|sff?|spp?|[sr]?fz|cresc|decresc|dim)(?![A-Za-z])" +regex_'5c'5c'5b'3c'21'3e'5d = compileRegex True "\\\\[]" +regex_'5c'5c'28'5cd'2b'7caccent'7cmarcato'7cstaccat'28issim'29'3fo'7cespressivo'7ctenuto'7cportato'7c'28up'7cdown'29'28bow'7cmordent'7cprall'29'7cflageolet'7cthumb'7c'5blr'5d'28heel'7ctoe'29'7copen'7cstopped'7cturn'7creverseturn'7ctrill'7cmordent'7cprall'28prall'7cmordent'7cdown'7cup'29'3f'7clineprall'7csignumcongruentiae'7c'28short'7clong'7cverylong'29'3ffermata'7csegno'7c'28var'29'3fcoda'7csnappizzicato'7chalfopen'29'28'3f'21'5bA'2dZa'2dz'5d'29 = compileRegex True "\\\\(\\d+|accent|marcato|staccat(issim)?o|espressivo|tenuto|portato|(up|down)(bow|mordent|prall)|flageolet|thumb|[lr](heel|toe)|open|stopped|turn|reverseturn|trill|mordent|prall(prall|mordent|down|up)?|lineprall|signumcongruentiae|(short|long|verylong)?fermata|segno|(var)?coda|snappizzicato|halfopen)(?![A-Za-z])" +regex_'5c'5c'5b'28'29'5d = compileRegex True "\\\\[()]" +regex_'5c'5c'5b'5d'5b'5d = compileRegex True "\\\\[][]" +regex_'5c'5cnote'28mode'7cs'29'28'3f'21'5bA'2dZa'2dz'5d'29 = compileRegex True "\\\\note(mode|s)(?![A-Za-z])" +regex_'5c'5cdrum'28mode'7cs'29'28'3f'21'5bA'2dZa'2dz'5d'29 = compileRegex True "\\\\drum(mode|s)(?![A-Za-z])" +regex_'5c'5cchord'28mode'7cs'29'28'3f'21'5bA'2dZa'2dz'5d'29 = compileRegex True "\\\\chord(mode|s)(?![A-Za-z])" +regex_'5c'5cfigure'28mode'7cs'29'28'3f'21'5bA'2dZa'2dz'5d'29 = compileRegex True "\\\\figure(mode|s)(?![A-Za-z])" +regex_'5c'5c'28lyric'28mode'7cs'29'7caddlyrics'29'28'3f'21'5bA'2dZa'2dz'5d'29 = compileRegex True "\\\\(lyric(mode|s)|addlyrics)(?![A-Za-z])" +regex_'5c'5clyricsto'28'3f'21'5bA'2dZa'2dz'5d'29 = compileRegex True "\\\\lyricsto(?![A-Za-z])" +regex_'5c'5cmarkup'28lines'29'3f'28'3f'21'5bA'2dZa'2dz'5d'29 = compileRegex True "\\\\markup(lines)?(?![A-Za-z])" +regex_'5c'5c'28header'7cpaper'7clayout'7cmidi'7cwith'29'5cb = compileRegex True "\\\\(header|paper|layout|midi|with)\\b" +regex_'5c'5c'28new'7ccontext'7cchange'29'5cb = compileRegex True "\\\\(new|context|change)\\b" +regex_'5c'5c'28un'29'3fset'5cb = compileRegex True "\\\\(un)?set\\b" +regex_'5c'5c'28override'28Property'29'3f'7crevert'29'28'3f'21'5bA'2dZa'2dz'5d'29 = compileRegex True "\\\\(override(Property)?|revert)(?![A-Za-z])" +regex_'5c'5cskip'28'3f'21'5bA'2dZa'2dz'5d'29 = compileRegex True "\\\\skip(?![A-Za-z])" +regex_'5c'5ctempo'28'3f'21'5bA'2dZa'2dz'5d'29 = compileRegex True "\\\\tempo(?![A-Za-z])" +regex_'5c'5c'28accepts'7calias'7cconsists'7cdefaultchild'7cdenies'7cdescription'7cgrobdescriptions'7cinclude'7cinvalid'7clanguage'7cname'7cobjectid'7conce'7cremove'7csequential'7csimultaneous'7ctype'7cversion'7cscore'7cbook'7cbookpart'29'28'3f'21'5bA'2dZa'2dz'5d'29 = compileRegex True "\\\\(accepts|alias|consists|defaultchild|denies|description|grobdescriptions|include|invalid|language|name|objectid|once|remove|sequential|simultaneous|type|version|score|book|bookpart)(?![A-Za-z])" +regex_'5c'5c'28'28aiken'7cfunk'7csacredHarp'7csouthernHarmony'7cwalker'29Heads'28Minor'29'3f'29'28'3f'21'5bA'2dZa'2dz'5d'29 = compileRegex True "\\\\((aiken|funk|sacredHarp|southernHarmony|walker)Heads(Minor)?)(?![A-Za-z])" +regex_'5c'5c'28acciaccatura'7caddQuote'7cafterGrace'7callowPageTurn'7calternative'7capply'28Context'7cMusic'7cOutput'29'7cappoggiatura'7carpeggio'28Arrow'28Down'7cUp'29'7cBracket'7cNormal'7cParenthesis'29'3f'7c'28a'7cde'29scendens'7cauctum'7caugmentum'7cautoBeamO'28ff'7cn'29'7cautochange'7cballoon'28Grob'29'3fText'7cbar'7cbarNumberCheck'7cbendAfter'7cbreathe'7cbreak'7ccadenzaO'28ff'7cn'29'7ccavum'7cclef'28'5cs'2b'28treble'7cviolin'7cG'7calto'7cC'7ctenor'7c'28sub'29'3fbass'7cF'7cfrench'7c'28mezzo'29'3fsoprano'7c'28var'29'3fbaritone'7cpercussion'7ctab'29'29'3f'7c'28end'29'3f'28de'29'3fcr'7ccresc'28TextCresc'7cHairpin'29'29'28'3f'21'5bA'2dZa'2dz'5d'29 = compileRegex True "\\\\(acciaccatura|addQuote|afterGrace|allowPageTurn|alternative|apply(Context|Music|Output)|appoggiatura|arpeggio(Arrow(Down|Up)|Bracket|Normal|Parenthesis)?|(a|de)scendens|auctum|augmentum|autoBeamO(ff|n)|autochange|balloon(Grob)?Text|bar|barNumberCheck|bendAfter|breathe|break|cadenzaO(ff|n)|cavum|clef(\\s+(treble|violin|G|alto|C|tenor|(sub)?bass|F|french|(mezzo)?soprano|(var)?baritone|percussion|tab))?|(end)?(de)?cr|cresc(TextCresc|Hairpin))(?![A-Za-z])" +regex_'5c'5c'28'28cue'7ctransposedCue'29During'7cdefault'7cdeminutum'7cdim'28Text'28Decresc'7cDecr'7cDim'29'7cHairpin'29'7cdisplay'28Lily'29'3fMusic'7cdivisio'28Maior'7cMaxima'7cMinima'29'7c'28dynamic'7cdots'7cphrasingSlur'7cslur'7cstem'7ctie'7ctuplet'29'28Down'7cNeutral'7cUp'29'7c'28balloon'7ctext'29LengthO'28ff'7cn'29'7cfeatherDurations'7cfigure'28mode'7cs'29'7cfinalis'7cflexa'7c'28french'7cgerman'7citalian'7csemiGerman'29Chords'7cglissando'7cgrace'7charmonic'7c'28unH'7ch'29ideNotes'7c'28hide'7cshow'29StaffSwitch'7cinclinatum'7c'28keep'7cremove'29WithTag'7ckey'28'5cs'2b'5cb'28'5ba'2dh'5d'28'28iss'29'7b1'2c2'7d'7c'28ess'29'7b1'2c2'7d'7c'28is'29'7b1'2c2'7d'7c'28es'29'7b1'2c2'7d'7c'28sharp'29'7b1'2c2'7d'7c'28flat'29'7b1'2c2'7d'7css'3f'7cff'3f'29'3f'7c'28do'7cre'7cmi'7cfa'7csol'7cla'7csi'29'28dd'3f'7cbb'3f'7css'3f'7ckk'3f'29'3f'7cq'29'28'27'2b'7c'2c'2b'7c'28'3f'21'5bA'2dZa'2dz'5d'29'29'29'3f'7ckillCues'29'28'3f'21'5bA'2dZa'2dz'5d'29 = compileRegex True "\\\\((cue|transposedCue)During|default|deminutum|dim(Text(Decresc|Decr|Dim)|Hairpin)|display(Lily)?Music|divisio(Maior|Maxima|Minima)|(dynamic|dots|phrasingSlur|slur|stem|tie|tuplet)(Down|Neutral|Up)|(balloon|text)LengthO(ff|n)|featherDurations|figure(mode|s)|finalis|flexa|(french|german|italian|semiGerman)Chords|glissando|grace|harmonic|(unH|h)ideNotes|(hide|show)StaffSwitch|inclinatum|(keep|remove)WithTag|key(\\s+\\b([a-h]((iss){1,2}|(ess){1,2}|(is){1,2}|(es){1,2}|(sharp){1,2}|(flat){1,2}|ss?|ff?)?|(do|re|mi|fa|sol|la|si)(dd?|bb?|ss?|kk?)?|q)('+|,+|(?![A-Za-z])))?|killCues)(?![A-Za-z])" +regex_'5c'5c'28label'7claissezVibrer'7clinea'7cmakeClusters'7cmark'7cmaxima'7cmelisma'28End'29'3f'7cmergeDifferently'28Head'7cDott'29edO'28ff'7cn'29'7cnewSpacingSection'7cno'28Beam'7cBreak'7cPageBreak'7cPageTurn'29'7cnormalsize'7cnumericTimeSignature'7coctaveCheck'7coneVoice'7coriscus'7cottava'7cpage'28'2dref'7cBreak'7cTurn'29'7cparallelMusic'7cparenthesize'7cpartcombine'7cpartial'28'5cs'2a'28'5c'5c'28longa'7cbreve'29'5cb'7c'281'7c2'7c4'7c8'7c16'7c32'7c64'7c128'7c256'7c512'7c1024'7c2048'29'28'3f'21'5cd'29'29'28'5cs'2a'5c'2e'2b'29'3f'28'5cs'2a'5c'2a'5cs'2a'5cd'2b'28'2f'5cd'2b'29'3f'29'2a'29'3f'7cpes'7cpitchedTrill'29'28'3f'21'5bA'2dZa'2dz'5d'29 = compileRegex True "\\\\(label|laissezVibrer|linea|makeClusters|mark|maxima|melisma(End)?|mergeDifferently(Head|Dott)edO(ff|n)|newSpacingSection|no(Beam|Break|PageBreak|PageTurn)|normalsize|numericTimeSignature|octaveCheck|oneVoice|oriscus|ottava|page(-ref|Break|Turn)|parallelMusic|parenthesize|partcombine|partial(\\s*(\\\\(longa|breve)\\b|(1|2|4|8|16|32|64|128|256|512|1024|2048)(?!\\d))(\\s*\\.+)?(\\s*\\*\\s*\\d+(/\\d+)?)*)?|pes|pitchedTrill)(?![A-Za-z])" +regex_'5c'5c'28pointAndClickO'28ff'7cn'29'7cquilisma'7cquoteDuring'7crelative'28'5cs'2b'5cb'28'5ba'2dh'5d'28'28iss'29'7b1'2c2'7d'7c'28ess'29'7b1'2c2'7d'7c'28is'29'7b1'2c2'7d'7c'28es'29'7b1'2c2'7d'7c'28sharp'29'7b1'2c2'7d'7c'28flat'29'7b1'2c2'7d'7css'3f'7cff'3f'29'3f'7c'28do'7cre'7cmi'7cfa'7csol'7cla'7csi'29'28dd'3f'7cbb'3f'7css'3f'7ckk'3f'29'3f'7cq'29'28'27'2b'7c'2c'2b'7c'28'3f'21'5bA'2dZa'2dz'5d'29'29'29'3f'7cRemoveEmptyStaffContext'7crepeat'28'5cs'2b'28unfold'7cvolta'7ctremolo'7cpercent'29'28'5cs'2b'5cd'2b'29'3f'29'3f'7crepeatTie'7cresetRelativeOctave'7crest'7cscaleDurations'7cscoreTweak'7ceasyHeadsO'28ff'7cn'29'7cshift'28Durations'7cOff'7cOn'7b1'2c3'7d'29'7c'28slur'7ctie'29'28Both'7cDashed'7cDotted'7cSolid'29'7csmall'7cspacingTweaks'29'28'3f'21'5bA'2dZa'2dz'5d'29 = compileRegex True "\\\\(pointAndClickO(ff|n)|quilisma|quoteDuring|relative(\\s+\\b([a-h]((iss){1,2}|(ess){1,2}|(is){1,2}|(es){1,2}|(sharp){1,2}|(flat){1,2}|ss?|ff?)?|(do|re|mi|fa|sol|la|si)(dd?|bb?|ss?|kk?)?|q)('+|,+|(?![A-Za-z])))?|RemoveEmptyStaffContext|repeat(\\s+(unfold|volta|tremolo|percent)(\\s+\\d+)?)?|repeatTie|resetRelativeOctave|rest|scaleDurations|scoreTweak|easyHeadsO(ff|n)|shift(Durations|Off|On{1,3})|(slur|tie)(Both|Dashed|Dotted|Solid)|small|spacingTweaks)(?![A-Za-z])" +regex_'5c'5c'28'28start'7cstop'29'28Group'7c'28Text'7cTrill'29Span'7cStaff'29'7cstemBoth'7cstropha'7csuper'7c'28sustain'7csostenuto'29O'28ff'7cn'29'7ctable'2dof'2dcontents'7ctag'7ctimes'3f'28'5cs'2a'5cd'2b'2f'5cd'2b'29'3f'7ctiny'7ctocItem'29'28'3f'21'5bA'2dZa'2dz'5d'29 = compileRegex True "\\\\((start|stop)(Group|(Text|Trill)Span|Staff)|stemBoth|stropha|super|(sustain|sostenuto)O(ff|n)|table-of-contents|tag|times?(\\s*\\d+/\\d+)?|tiny|tocItem)(?![A-Za-z])" +regex_'5c'5c'28transpose'28'5cs'2b'5cb'28'5ba'2dh'5d'28'28iss'29'7b1'2c2'7d'7c'28ess'29'7b1'2c2'7d'7c'28is'29'7b1'2c2'7d'7c'28es'29'7b1'2c2'7d'7c'28sharp'29'7b1'2c2'7d'7c'28flat'29'7b1'2c2'7d'7css'3f'7cff'3f'29'3f'7c'28do'7cre'7cmi'7cfa'7csol'7cla'7csi'29'28dd'3f'7cbb'3f'7css'3f'7ckk'3f'29'3f'7cq'29'28'27'2b'7c'2c'2b'7c'28'3f'21'5bA'2dZa'2dz'5d'29'29'5cs'2a'5cb'28'5ba'2dh'5d'28'28iss'29'7b1'2c2'7d'7c'28ess'29'7b1'2c2'7d'7c'28is'29'7b1'2c2'7d'7c'28es'29'7b1'2c2'7d'7c'28sharp'29'7b1'2c2'7d'7c'28flat'29'7b1'2c2'7d'7css'3f'7cff'3f'29'3f'7c'28do'7cre'7cmi'7cfa'7csol'7cla'7csi'29'28dd'3f'7cbb'3f'7css'3f'7ckk'3f'29'3f'7cq'29'28'27'2b'7c'2c'2b'7c'28'3f'21'5bA'2dZa'2dz'5d'29'29'29'3f'7ctransposition'28'5cs'2b'5cb'28'5ba'2dh'5d'28'28iss'29'7b1'2c2'7d'7c'28ess'29'7b1'2c2'7d'7c'28is'29'7b1'2c2'7d'7c'28es'29'7b1'2c2'7d'7c'28sharp'29'7b1'2c2'7d'7c'28flat'29'7b1'2c2'7d'7css'3f'7cff'3f'29'3f'7c'28do'7cre'7cmi'7cfa'7csol'7cla'7csi'29'28dd'3f'7cbb'3f'7css'3f'7ckk'3f'29'3f'7cq'29'28'27'2b'7c'2c'2b'7c'28'3f'21'5bA'2dZa'2dz'5d'29'29'29'29'28'3f'21'5bA'2dZa'2dz'5d'29 = compileRegex True "\\\\(transpose(\\s+\\b([a-h]((iss){1,2}|(ess){1,2}|(is){1,2}|(es){1,2}|(sharp){1,2}|(flat){1,2}|ss?|ff?)?|(do|re|mi|fa|sol|la|si)(dd?|bb?|ss?|kk?)?|q)('+|,+|(?![A-Za-z]))\\s*\\b([a-h]((iss){1,2}|(ess){1,2}|(is){1,2}|(es){1,2}|(sharp){1,2}|(flat){1,2}|ss?|ff?)?|(do|re|mi|fa|sol|la|si)(dd?|bb?|ss?|kk?)?|q)('+|,+|(?![A-Za-z])))?|transposition(\\s+\\b([a-h]((iss){1,2}|(ess){1,2}|(is){1,2}|(es){1,2}|(sharp){1,2}|(flat){1,2}|ss?|ff?)?|(do|re|mi|fa|sol|la|si)(dd?|bb?|ss?|kk?)?|q)('+|,+|(?![A-Za-z]))))(?![A-Za-z])" +regex_'5c'5c'28tweak'7cunfoldRepeats'7cvirg'28ul'29'3fa'7cvoice'28One'7cTwo'7cThree'7cFour'29'7cwithMusicProperty'7ccm'7cmm'7cin'7cpt'7cmajor'7cminor'7cionian'7clocrian'7caeolian'7cmixolydian'7clydian'7cphrygian'7cdorian'29'28'3f'21'5bA'2dZa'2dz'5d'29 = compileRegex True "\\\\(tweak|unfoldRepeats|virg(ul)?a|voice(One|Two|Three|Four)|withMusicProperty|cm|mm|in|pt|major|minor|ionian|locrian|aeolian|mixolydian|lydian|phrygian|dorian)(?![A-Za-z])" +regex_'5c'5c'28dash'28Hat'7cPlus'7cDash'7cBar'7cLarger'7cDot'7cUnderscore'29'7cfermataMarkup'7cpipeSymbol'7cslashSeparator'29'28'3f'21'5bA'2dZa'2dz'5d'29 = compileRegex True "\\\\(dash(Hat|Plus|Dash|Bar|Larger|Dot|Underscore)|fermataMarkup|pipeSymbol|slashSeparator)(?![A-Za-z])" +regex_'5c'5c'28consistsend'29'28'3f'21'5bA'2dZa'2dz'5d'29 = compileRegex True "\\\\(consistsend)(?![A-Za-z])" +regex_'5c'5c'28arpeggio'28Up'7cDown'7cNeutral'29'7cnewpage'7cscript'28Up'7cDown'7cBoth'29'7c'28empty'7cfat'29Text'7csetEasyHeads'7c'28default'7cvoice'7cmodernVoice'7cpiano'7cforget'29Accidentals'7c'28modern'28Voice'29'3f'7cpiano'29Cautionaries'7cnoResetKey'7ccompressMusic'7coctave'7c'28sustain'7csostenuto'29'28Down'7cUp'29'7cset'28Hairpin'7cText'29'28Cresc'7cDecresc'7cDim'29'7csetTextDecr'29'28'3f'21'5bA'2dZa'2dz'5d'29 = compileRegex True "\\\\(arpeggio(Up|Down|Neutral)|newpage|script(Up|Down|Both)|(empty|fat)Text|setEasyHeads|(default|voice|modernVoice|piano|forget)Accidentals|(modern(Voice)?|piano)Cautionaries|noResetKey|compressMusic|octave|(sustain|sostenuto)(Down|Up)|set(Hairpin|Text)(Cresc|Decresc|Dim)|setTextDecr)(?![A-Za-z])" +regex_'5c'5c'28translator'7cnewcontext'29'5cb = compileRegex True "\\\\(translator|newcontext)\\b" +regex_'5c'5cproperty'28'3f'21'5bA'2dZa'2dz'5d'29 = compileRegex True "\\\\property(?![A-Za-z])" +regex_'5c'5c'5bA'2dZa'2dz'5d'2b = compileRegex True "\\\\[A-Za-z]+" +regex_'5cb'28dash'28Hat'7cPlus'7cDash'7cBar'7cLarger'7cDot'7cUnderscore'29'7cfermataMarkup'7cpipeSymbol'7cslashSeparator'29'5cb = compileRegex True "\\b(dash(Hat|Plus|Dash|Bar|Larger|Dot|Underscore)|fermataMarkup|pipeSymbol|slashSeparator)\\b" +regex_'5ba'2dz'5d'2b = compileRegex True "[a-z]+" +regex_'3d'5cs'2a'28'27'2b'7c'2c'2b'29'3f = compileRegex True "=\\s*('+|,+)?" +regex_'28'5c'5c'28longa'7cbreve'29'5cb'7c'281'7c2'7c4'7c8'7c16'7c32'7c64'7c128'7c256'7c512'7c1024'7c2048'29'28'3f'21'5cd'29'29'28'5cs'2a'5c'2e'2b'29'3f'28'5cs'2a'5c'2a'5cs'2a'5cd'2b'28'2f'5cd'2b'29'3f'29'2a = compileRegex True "(\\\\(longa|breve)\\b|(1|2|4|8|16|32|64|128|256|512|1024|2048)(?!\\d))(\\s*\\.+)?(\\s*\\*\\s*\\d+(/\\d+)?)*" +regex_'5cd'2b = compileRegex True "\\d+" +regex_'5cb'28'5ba'2dh'5d'28'28iss'29'7b1'2c2'7d'7c'28ess'29'7b1'2c2'7d'7c'28is'29'7b1'2c2'7d'7c'28es'29'7b1'2c2'7d'7c'28sharp'29'7b1'2c2'7d'7c'28flat'29'7b1'2c2'7d'7css'3f'7cff'3f'29'3f'7c'28do'7cre'7cmi'7cfa'7csol'7cla'7csi'29'28dd'3f'7cbb'3f'7css'3f'7ckk'3f'29'3f'7cq'29'28'27'2b'7c'2c'2b'7c'28'3f'21'5bA'2dZa'2dz'5d'29'29 = compileRegex True "\\b([a-h]((iss){1,2}|(ess){1,2}|(is){1,2}|(es){1,2}|(sharp){1,2}|(flat){1,2}|ss?|ff?)?|(do|re|mi|fa|sol|la|si)(dd?|bb?|ss?|kk?)?|q)('+|,+|(?![A-Za-z]))" +regex_'5b'2d'2b'5d'3f'28'5cd'2b'28'5c'2e'5cd'2b'29'3f'7c'5c'2e'5cd'2b'29 = compileRegex True "[-+]?(\\d+(\\.\\d+)?|\\.\\d+)" +regex_'23'28t'7cf'7cb'5b'2d'2b'5d'3f'5b01'2e'5d'2b'7co'5b'2d'2b'5d'3f'5b0'2d7'2e'5d'2b'7cd'5b'2d'2b'5d'3f'5b0'2d9'2e'5d'2b'7cx'5b'2d'2b'5d'3f'5b0'2d9a'2df'2e'5d'2b'29 = compileRegex True "#(t|f|b[-+]?[01.]+|o[-+]?[0-7.]+|d[-+]?[0-9.]+|x[-+]?[0-9a-f.]+)" +regex_'5b'2b'2d'5d'28inf'7cnan'29'5c'2e0 = compileRegex True "[+-](inf|nan)\\.0" +regex_'5cb'28define'7cdefined'5c'3f'7cdefine'5c'2a'28'2dpublic'29'3f'7cdefine'2d'28'5c'2a'7cbuiltin'2dmarkup'2d'28list'2d'29'3fcommand'7cclass'7c'28extra'2d'29'3fdisplay'2dmethod'7cfonts'3f'7cgrob'2dproperty'7cly'2dsyntax'28'2dloc'7c'2dsimple'29'3f'7cmacro'28'2dpublic'29'3f'7cmarkup'2d'28list'2d'29command'7cmethod'7cmodule'7cmusic'2dfunction'7cpost'2devent'2ddisplay'2dmethod'7cpublic'28'2dmacro'7c'2dtoplevel'29'3f'7csafe'2dpublic'7cspan'2devent'2ddisplay'2dmethod'29'7cdefmacro'28'5c'2a'28'2dpublic'29'3f'29'3f'7clambda'5c'2a'3f'7cand'7cor'7cif'7ccond'7ccase'7clet'5c'2a'3f'7cletrec'7cbegin'7cdo'7cdelay'7cset'21'7celse'7c'28quasi'29'3fquote'7cunquote'28'2dsplicing'29'3f'7c'28define'7clet'7cletrec'29'2dsyntax'7csyntax'2drules'29'28'3f'3d'28'24'7c'5cs'7c'5c'29'29'29 = compileRegex True "\\b(define|defined\\?|define\\*(-public)?|define-(\\*|builtin-markup-(list-)?command|class|(extra-)?display-method|fonts?|grob-property|ly-syntax(-loc|-simple)?|macro(-public)?|markup-(list-)command|method|module|music-function|post-event-display-method|public(-macro|-toplevel)?|safe-public|span-event-display-method)|defmacro(\\*(-public)?)?|lambda\\*?|and|or|if|cond|case|let\\*?|letrec|begin|do|delay|set!|else|(quasi)?quote|unquote(-splicing)?|(define|let|letrec)-syntax|syntax-rules)(?=($|\\s|\\)))" +regex_'5cb'28not'7cboolean'5c'3f'7ceq'5c'3f'7ceqv'5c'3f'7cequal'5c'3f'7cpair'5c'3f'7ccons'7cset'2dc'5bad'5dr'21'7cc'5bad'5d'7b1'2c4'7dr'7cnull'5c'3f'7clist'5c'3f'7clist'7clength'7cappend'7creverse'7clist'2dref'7cmem'5bqv'5d'7cmember'7cass'5bqv'5d'7cassoc'7csymbol'5c'3f'7csymbol'2d'3estring'7cstring'2d'3esymbol'7cnumber'5c'3f'7ccomplex'5c'3f'7creal'5c'3f'7crational'5c'3f'7cinteger'5c'3f'7cexact'5c'3f'7cinexact'5c'3f'7czero'5c'3f'7cpositive'5c'3f'7cnegative'5c'3f'7codd'5c'3f'7ceven'5c'3f'7cmax'7cmin'7cabs'7cquotient'7cremainder'7cmodulo'7cgcd'7clcm'7cnumerator'7cdenominator'7cfloor'7cceiling'7ctruncate'7cround'7crationalize'7cexp'7clog'7csin'7ccos'7ctan'7casin'7cacos'7catan'7csqrt'7cexpt'7cmake'2drectangular'7cmake'2dpolar'7creal'2dpart'7cimag'2dpart'7cmagnitude'7cangle'7cexact'2d'3einexact'7cinexact'2d'3eexact'7cnumber'2d'3estring'7cstring'2d'3enumber'29'28'3f'3d'28'24'7c'5cs'7c'5c'29'29'29 = compileRegex True "\\b(not|boolean\\?|eq\\?|eqv\\?|equal\\?|pair\\?|cons|set-c[ad]r!|c[ad]{1,4}r|null\\?|list\\?|list|length|append|reverse|list-ref|mem[qv]|member|ass[qv]|assoc|symbol\\?|symbol->string|string->symbol|number\\?|complex\\?|real\\?|rational\\?|integer\\?|exact\\?|inexact\\?|zero\\?|positive\\?|negative\\?|odd\\?|even\\?|max|min|abs|quotient|remainder|modulo|gcd|lcm|numerator|denominator|floor|ceiling|truncate|round|rationalize|exp|log|sin|cos|tan|asin|acos|atan|sqrt|expt|make-rectangular|make-polar|real-part|imag-part|magnitude|angle|exact->inexact|inexact->exact|number->string|string->number)(?=($|\\s|\\)))" +regex_'5cb'28char'28'28'2dci'29'3f'28'3d'5c'3f'7c'3c'5c'3f'7c'3e'5c'3f'7c'3c'3d'5c'3f'7c'3e'3d'5c'3f'29'7c'2dalphabetic'5c'3f'7c'5c'3f'7c'2dnumeric'5c'3f'7c'2dwhitespace'5c'3f'7c'2dupper'2dcase'5c'3f'7c'2dlower'2dcase'5c'3f'7c'2d'3einteger'7c'2dupcase'7c'2ddowncase'7c'2dready'5c'3f'29'7cinteger'2d'3echar'7cmake'2dstring'7cstring'28'5c'3f'7c'2dcopy'7c'2dfill'21'7c'2dlength'7c'2dref'7c'2dset'21'7c'28'2dci'29'3f'28'3d'5c'3f'7c'3c'5c'3f'7c'3e'5c'3f'7c'3c'3d'5c'3f'7c'3e'3d'5c'3f'29'7c'2dappend'29'7csubstring'7cmake'2dvector'7cvector'28'5c'3f'7c'2dlength'7c'2dref'7c'2dset'21'7c'2dfill'21'29'3f'7cprocedure'5c'3f'7capply'7cmap'7cfor'2deach'7cforce'7ccall'2dwith'2d'28current'2dcontinuation'7c'28in'7cout'29put'2dfile'29'7c'28in'7cout'29put'2dport'5c'3f'7ccurrent'2d'28in'7cout'29put'2dport'7copen'2d'28in'7cout'29put'2dfile'7cclose'2d'28in'7cout'29put'2dport'7ceof'2dobject'5c'3f'7cread'7c'28read'7cpeek'29'2dchar'7cwrite'28'2dchar'29'3f'7cdisplay'7cnewline'7ccall'2fcc'7clist'2dtail'7cstring'2d'3elist'7clist'2d'3estring'7cvector'2d'3elist'7clist'2d'3evector'7cwith'2dinput'2dfrom'2dfile'7cwith'2doutput'2dto'2dfile'7cload'7ctranscript'2d'28on'7coff'29'7ceval'7cdynamic'2dwind'7cport'5c'3f'7cvalues'7ccall'2dwith'2dvalues'7c'28scheme'2dreport'2d'7cnull'2d'7cinteraction'2d'29environment'29'28'3f'3d'28'24'7c'5cs'7c'5c'29'29'29 = compileRegex True "\\b(char((-ci)?(=\\?|<\\?|>\\?|<=\\?|>=\\?)|-alphabetic\\?|\\?|-numeric\\?|-whitespace\\?|-upper-case\\?|-lower-case\\?|->integer|-upcase|-downcase|-ready\\?)|integer->char|make-string|string(\\?|-copy|-fill!|-length|-ref|-set!|(-ci)?(=\\?|<\\?|>\\?|<=\\?|>=\\?)|-append)|substring|make-vector|vector(\\?|-length|-ref|-set!|-fill!)?|procedure\\?|apply|map|for-each|force|call-with-(current-continuation|(in|out)put-file)|(in|out)put-port\\?|current-(in|out)put-port|open-(in|out)put-file|close-(in|out)put-port|eof-object\\?|read|(read|peek)-char|write(-char)?|display|newline|call/cc|list-tail|string->list|list->string|vector->list|list->vector|with-input-from-file|with-output-to-file|load|transcript-(on|off)|eval|dynamic-wind|port\\?|values|call-with-values|(scheme-report-|null-|interaction-)environment)(?=($|\\s|\\)))" +regex_'5ba'2dzA'2dZ'23'5d'5b'5e'5cs'28'29'7b'7d'5b'5c'5d'3b'24'22'5d'2a = compileRegex True "[a-zA-Z#][^\\s(){}[\\];$\"]*" +regex_'5c'5c'5b0fnrtav'5c'5c'22'5d = compileRegex True "\\\\[0fnrtav\\\\\"]" +regex_'3c'28'3f'21'3c'29 = compileRegex True "<(?!<)" +regex_'3a'3f'28'5b'5c'2e'5e'5d'3f'5cd'2b'5b'2d'2b'5d'3f'7c'28m'7cdim'7caug'7cmaj'7csus'29'28'3f'21'5bA'2dZa'2dz'5d'29'29'2a'28'2f'5c'2b'3f'5cb'28'5ba'2dh'5d'28'28iss'29'7b1'2c2'7d'7c'28ess'29'7b1'2c2'7d'7c'28is'29'7b1'2c2'7d'7c'28es'29'7b1'2c2'7d'7c'28sharp'29'7b1'2c2'7d'7c'28flat'29'7b1'2c2'7d'7css'3f'7cff'3f'29'3f'7c'28do'7cre'7cmi'7cfa'7csol'7cla'7csi'29'28dd'3f'7cbb'3f'7css'3f'7ckk'3f'29'3f'7cq'29'28'27'2b'7c'2c'2b'7c'28'3f'21'5bA'2dZa'2dz'5d'29'29'29'3f = compileRegex True ":?([\\.^]?\\d+[-+]?|(m|dim|aug|maj|sus)(?![A-Za-z]))*(/\\+?\\b([a-h]((iss){1,2}|(ess){1,2}|(is){1,2}|(es){1,2}|(sharp){1,2}|(flat){1,2}|ss?|ff?)?|(do|re|mi|fa|sol|la|si)(dd?|bb?|ss?|kk?)?|q)('+|,+|(?![A-Za-z])))?" +regex_'5cb'5bsrR'5d'28'3f'21'5bA'2dZa'2dz'5d'29 = compileRegex True "\\b[srR](?![A-Za-z])" +regex_'22'28'5c'5c'5b'22'5c'5c'5d'7c'5b'5e'22'5c'5c'5d'29'2b'22 = compileRegex True "\"(\\\\[\"\\\\]|[^\"\\\\])+\"" +regex_'5bA'2dZa'2dz'5d'2b = compileRegex True "[A-Za-z]+" +regex_'28'5cw'2b'2d'7b2'2c'7d'7c'5cw'2b'5f'7b2'2c'7d'7c'2d'7b2'2c'7d'5cw'2b'7c'5f'7b2'2c'7d'5cw'2b'29 = compileRegex True "(\\w+-{2,}|\\w+_{2,}|-{2,}\\w+|_{2,}\\w+)" +regex_'28'2d'2d'7c'5f'5f'7c'5f'29 = compileRegex True "(--|__|_)" +regex_'5cS'2b'5c'7d = compileRegex True "\\S+\\}" +regex_'5c'5cscore'5cb = compileRegex True "\\\\score\\b" +regex_'5c'5c'28markup'7cbold'7c'28rounded'2d'29'3fbox'7cbracket'7ccaps'7c'28center'7cgeneral'7cleft'7cright'29'2dalign'7ccircle'7c'28'28center'7cdir'7cleft'7cright'29'2d'29'3fcolumn'7ccombine'7cconcat'7cdynamic'7cfill'2dline'7cfinger'7cfontCaps'7c'28abs'2d'29'3ffontsize'7cfraction'7chalign'7chbracket'7chcenter'2din'7chcenter'7chspace'7chuge'7citalic'7cjustify'7clarger'3f'7cline'7clower'7cmagnify'7cmedium'7cnormal'2dsize'2d'28sub'7csuper'29'7cnormal'2dtext'7cnormalsize'7cnumber'7con'2dthe'2dfly'7coverride'7cpad'2d'28around'7cmarkup'7cto'2dbox'7cx'29'7cpage'2dref'7cpostscript'7cput'2dadjacent'7craise'7croman'7crotate'7csans'7csmall'28er'29'3f'7csmallCaps'7csub'7csuper'7cteeny'7ctext'7ctiny'7ctranslate'28'2dscaled'29'3f'7ctransparent'7ctypewriter'7cunderline'7cupright'7cvcenter'7cwhiteout'7cwith'2d'28color'7cdimensions'7curl'29'7cwordwrap'7c'28markup'7ccolumn'2d'7cjustified'2d'7coverride'2d'7cwordwrap'2d'29lines'7cwordwrap'2d'28string'2d'29'3finternal'29'28'3f'21'5bA'2dZa'2dz'5d'29 = compileRegex True "\\\\(markup|bold|(rounded-)?box|bracket|caps|(center|general|left|right)-align|circle|((center|dir|left|right)-)?column|combine|concat|dynamic|fill-line|finger|fontCaps|(abs-)?fontsize|fraction|halign|hbracket|hcenter-in|hcenter|hspace|huge|italic|justify|larger?|line|lower|magnify|medium|normal-size-(sub|super)|normal-text|normalsize|number|on-the-fly|override|pad-(around|markup|to-box|x)|page-ref|postscript|put-adjacent|raise|roman|rotate|sans|small(er)?|smallCaps|sub|super|teeny|text|tiny|translate(-scaled)?|transparent|typewriter|underline|upright|vcenter|whiteout|with-(color|dimensions|url)|wordwrap|(markup|column-|justified-|override-|wordwrap-)lines|wordwrap-(string-)?internal)(?![A-Za-z])" +regex_'5c'5c'28arrow'2dhead'7cbeam'7cchar'7c'28semi'7csesqui'7cdouble'29'3f'28flat'7csharp'29'7cdraw'2d'28circle'7cline'29'7cepsfile'7ceyeglasses'7cfilled'2dbox'7cfret'2ddiagram'28'2dterse'7c'2dverbose'29'3f'7cfromproperty'7charp'2dpedal'7c'28justify'7cwordwrap'29'2d'28field'7cstring'29'7cleft'2dbrace'7clookup'7cmarkalphabet'7cmarkletter'7cmusicglyph'7cnatural'7cnote'2dby'2dnumber'7cnote'7cnull'7cpath'7cright'2dbrace'7csimple'7c'28back'29'3fslashed'2ddigit'7cstencil'7cstrut'7ctied'2dlyric'7ctriangle'7cverbatim'2dfile'29'28'3f'21'5bA'2dZa'2dz'5d'29 = compileRegex True "\\\\(arrow-head|beam|char|(semi|sesqui|double)?(flat|sharp)|draw-(circle|line)|epsfile|eyeglasses|filled-box|fret-diagram(-terse|-verbose)?|fromproperty|harp-pedal|(justify|wordwrap)-(field|string)|left-brace|lookup|markalphabet|markletter|musicglyph|natural|note-by-number|note|null|path|right-brace|simple|(back)?slashed-digit|stencil|strut|tied-lyric|triangle|verbatim-file)(?![A-Za-z])" +regex_'5b'5e'22'5cs'5c'5c'23'25'7b'7d'24'5d'2b = compileRegex True "[^\"\\s\\\\#%{}$]+" +regex_'5c'5c'28arrow'2dhead'7cbeam'7cchar'7c'28semi'7csesqui'7cdouble'29'3f'28flat'7csharp'29'7cdraw'2d'28circle'7cline'29'7cepsfile'7ceyeglasses'7cfilled'2dbox'7cfret'2ddiagram'28'2dterse'7c'2dverbose'29'3f'7cfromproperty'7charp'2dpedal'7c'28justify'7cwordwrap'29'2d'28field'7cstring'29'7cleft'2dbrace'7clookup'7cmarkalphabet'7cmarkletter'7cmusicglyph'7cnatural'7cnote'2dby'2dnumber'7cnote'7cnull'7cpath'7cright'2dbrace'7csimple'7c'28back'29'3fslashed'2ddigit'7cstencil'7cstrut'7ctied'2dlyric'7ctriangle'7cverbatim'2dfile'7cmarkup'7cbold'7c'28rounded'2d'29'3fbox'7cbracket'7ccaps'7c'28center'7cgeneral'7cleft'7cright'29'2dalign'7ccircle'7c'28'28center'7cdir'7cleft'7cright'29'2d'29'3fcolumn'7ccombine'7cconcat'7cdynamic'7cfill'2dline'7cfinger'7cfontCaps'7c'28abs'2d'29'3ffontsize'7cfraction'7chalign'7chbracket'7chcenter'2din'7chcenter'7chspace'7chuge'7citalic'7cjustify'7clarger'3f'7cline'7clower'7cmagnify'7cmedium'7cnormal'2dsize'2d'28sub'7csuper'29'7cnormal'2dtext'7cnormalsize'7cnumber'7con'2dthe'2dfly'7coverride'7cpad'2d'28around'7cmarkup'7cto'2dbox'7cx'29'7cpage'2dref'7cpostscript'7cput'2dadjacent'7craise'7croman'7crotate'7csans'7csmall'28er'29'3f'7csmallCaps'7csub'7csuper'7cteeny'7ctext'7ctiny'7ctranslate'28'2dscaled'29'3f'7ctransparent'7ctypewriter'7cunderline'7cupright'7cvcenter'7cwhiteout'7cwith'2d'28color'7cdimensions'7curl'29'7cwordwrap'7c'28markup'7ccolumn'2d'7cjustified'2d'7coverride'2d'7cwordwrap'2d'29lines'7cwordwrap'2d'28string'2d'29'3finternal'29'28'3f'21'5bA'2dZa'2dz'5d'29 = compileRegex True "\\\\(arrow-head|beam|char|(semi|sesqui|double)?(flat|sharp)|draw-(circle|line)|epsfile|eyeglasses|filled-box|fret-diagram(-terse|-verbose)?|fromproperty|harp-pedal|(justify|wordwrap)-(field|string)|left-brace|lookup|markalphabet|markletter|musicglyph|natural|note-by-number|note|null|path|right-brace|simple|(back)?slashed-digit|stencil|strut|tied-lyric|triangle|verbatim-file|markup|bold|(rounded-)?box|bracket|caps|(center|general|left|right)-align|circle|((center|dir|left|right)-)?column|combine|concat|dynamic|fill-line|finger|fontCaps|(abs-)?fontsize|fraction|halign|hbracket|hcenter-in|hcenter|hspace|huge|italic|justify|larger?|line|lower|magnify|medium|normal-size-(sub|super)|normal-text|normalsize|number|on-the-fly|override|pad-(around|markup|to-box|x)|page-ref|postscript|put-adjacent|raise|roman|rotate|sans|small(er)?|smallCaps|sub|super|teeny|text|tiny|translate(-scaled)?|transparent|typewriter|underline|upright|vcenter|whiteout|with-(color|dimensions|url)|wordwrap|(markup|column-|justified-|override-|wordwrap-)lines|wordwrap-(string-)?internal)(?![A-Za-z])" +regex_'5c'5c'28bigger'7ch'3fcenter'29'28'3f'21'5bA'2dZa'2dz'5d'29 = compileRegex True "\\\\(bigger|h?center)(?![A-Za-z])" +regex_'5c'5c'5bA'2dZa'2dz'5d'2b'28'2d'5bA'2dZa'2dz'5d'2b'29'2a = compileRegex True "\\\\[A-Za-z]+(-[A-Za-z]+)*" +regex_'28'22'3f'29'5cb'28'28Accidental'7cAmbitus'7cArpeggio'7cAuto'5fbeam'7cAxis'5fgroup'7cBalloon'7cBar'7cBar'5fnumber'7cBeam'7cBend'7cBreak'5falign'7cBreathing'5fsign'7cChord'5fname'7cChord'5ftremolo'7cClef'7cCluster'5fspanner'7cCollision'7cCompletion'5fheads'7cCustos'7cDefault'5fbar'5fline'7cDot'5fcolumn'7cDots'7cDrum'5fnotes'7cDynami'5falign'7cDynamic'7cEpisema'7cExtender'7cFigured'5fbass'7cFigured'5fbass'5fposition'7cFingering'7cFont'5fsize'7cForbid'5fline'5fbreak'7cFretboard'7cGlissando'7cGrace'5fbeam'7cGrace'7cGrace'5fspacing'7cGrid'5fline'5fspan'7cGrid'5fpoint'7cGrob'5fpq'7cHara'5fkiri'7cHorizontal'5fbracket'29'5fengraver'29'5cb'5c1 = compileRegex True "(\"?)\\b((Accidental|Ambitus|Arpeggio|Auto_beam|Axis_group|Balloon|Bar|Bar_number|Beam|Bend|Break_align|Breathing_sign|Chord_name|Chord_tremolo|Clef|Cluster_spanner|Collision|Completion_heads|Custos|Default_bar_line|Dot_column|Dots|Drum_notes|Dynami_align|Dynamic|Episema|Extender|Figured_bass|Figured_bass_position|Fingering|Font_size|Forbid_line_break|Fretboard|Glissando|Grace_beam|Grace|Grace_spacing|Grid_line_span|Grid_point|Grob_pq|Hara_kiri|Horizontal_bracket)_engraver)\\b\\1" +regex_'28'22'3f'29'5cb'28'28Hyphen'7cInstrument'5fname'7cInstrument'5fswitch'7cKey'7cLaissez'5fvibrer'7cLedger'5fline'7cLigature'5fbracket'7cLyric'7cMark'7cMeasure'5fgrouping'7cMelody'7cMensural'5fligature'7cMetronome'5fmark'7cMulti'5fmeasure'5frest'7cNew'5fdynamic'7cNew'5ffingering'7cNote'5fhead'5fline'7cNote'5fheads'7cNote'5fname'7cNote'5fspacing'7cOttava'5fspanner'7cOutput'5fproperty'7cPage'5fturn'7cPaper'5fcolumn'7cParenthesis'7cPart'5fcombine'7cPercent'5frepeat'7cPhrasing'5fslur'7cPiano'5fpedal'5falign'7cPiano'5fpedal'7cPitch'5fsquash'7cPitched'5ftrill'7cRepeat'5facknowledge'7cRepeat'5ftie'7cRest'5fcollision'7cRest'7cRhythmic'5fcolumn'7cScheme'7cScript'5fcolumn'7cScript'7cScript'5frow'29'5fengraver'29'5cb'5c1 = compileRegex True "(\"?)\\b((Hyphen|Instrument_name|Instrument_switch|Key|Laissez_vibrer|Ledger_line|Ligature_bracket|Lyric|Mark|Measure_grouping|Melody|Mensural_ligature|Metronome_mark|Multi_measure_rest|New_dynamic|New_fingering|Note_head_line|Note_heads|Note_name|Note_spacing|Ottava_spanner|Output_property|Page_turn|Paper_column|Parenthesis|Part_combine|Percent_repeat|Phrasing_slur|Piano_pedal_align|Piano_pedal|Pitch_squash|Pitched_trill|Repeat_acknowledge|Repeat_tie|Rest_collision|Rest|Rhythmic_column|Scheme|Script_column|Script|Script_row)_engraver)\\b\\1" +regex_'28'22'3f'29'5cb'28'28Separating'5fline'5fgroup'7cSlash'5frepeat'7cSlur'7cSpacing'7cSpan'5farpeggio'7cSpan'5fbar'7cSpanner'5fbreak'5fforbid'7cStaff'5fcollecting'7cStaff'5fsymbol'7cStanza'5fnumber'5falign'7cStanza'5fnumber'7cStem'7cString'5fnumber'7cSwallow'7cSystem'5fstart'5fdelimiter'7cTab'5fharmonic'7cTab'5fnote'5fheads'7cTab'5fstaff'5fsymbol'7cText'7cText'5fspanner'7cTie'7cTime'5fsignature'7cTrill'5fspanner'7cTuplet'7cTweak'7cVaticana'5fligature'7cVertical'5falign'7cVertically'5fspaced'5fcontexts'7cVolta'29'5fengraver'29'5cb'5c1 = compileRegex True "(\"?)\\b((Separating_line_group|Slash_repeat|Slur|Spacing|Span_arpeggio|Span_bar|Spanner_break_forbid|Staff_collecting|Staff_symbol|Stanza_number_align|Stanza_number|Stem|String_number|Swallow|System_start_delimiter|Tab_harmonic|Tab_note_heads|Tab_staff_symbol|Text|Text_spanner|Tie|Time_signature|Trill_spanner|Tuplet|Tweak|Vaticana_ligature|Vertical_align|Vertically_spaced_contexts|Volta)_engraver)\\b\\1" +regex_'28'22'3f'29'5cb'28'28Beam'7cControl'5ftrack'7cDrum'5fnote'7cDynamic'7cKey'7cLyric'7cNote'7cPiano'5fpedal'7cSlur'7cStaff'7cSwallow'7cTempo'7cTie'7cTime'5fsignature'29'5fperformer'29'5cb'5c1 = compileRegex True "(\"?)\\b((Beam|Control_track|Drum_note|Dynamic|Key|Lyric|Note|Piano_pedal|Slur|Staff|Swallow|Tempo|Tie|Time_signature)_performer)\\b\\1" +regex_'28'22'3f'29'5cb'28'28Note'5fswallow'7cRest'5fswallow'7cSkip'5fevent'5fswallow'7cTiming'29'5ftranslator'29'5cb'5c1 = compileRegex True "(\"?)\\b((Note_swallow|Rest_swallow|Skip_event_swallow|Timing)_translator)\\b\\1" +regex_'5cb'28dedication'7c'28sub'29'7b'2c2'7dtitle'7cpoet'7ccomposer'7cmeter'7copus'7carranger'7cinstrument'7cpiece'7cbreakbefore'7ccopyright'7ctagline'7cmutopia'28title'7ccomposer'7cpoet'7copus'7cinstrument'29'7cdate'7centeredby'7csource'7cstyle'7cmaintainer'28Email'7cWeb'29'3f'7cmoreInfo'7clastupdated'7ctexidoc'7cfooter'7c'28top'7cbottom'7cleft'7cright'29'2dmargin'7c'28foot'7chead'29'2dseparation'7cindent'7cshort'2dindent'7cpaper'2d'28height'7cwidth'29'7chorizontal'2dshift'7cline'2dwidth'7c'28inner'7couter'29'2dmargin'7ctwo'2dsided'7cbinding'2doffset'7c'28after'7cbefore'7cbetween'29'2dtitle'2dspace'7cbetween'2dsystem'2d'28space'7cpadding'29'7cpage'2dtop'2dspace'7cpage'2dbreaking'2dbetween'2dsystem'2dpadding'7c'28after'7cbefore'7cbetween'29'2dtitle'2dspacing'7cbetween'2d'28scores'2d'29'3fsystem'2dspacing'7cbottom'2dsystem'2dspacing'7ctop'2dtitle'2dspacing'7ctop'2dsystem'2dspacing'7cpage'2dbreaking'2dbetween'2dsystem'2dspacing'7csystem'2dcount'7c'28min'2d'7cmax'2d'29'3fsystems'2dper'2dpage'7cannotate'2dspacing'7cauto'2dfirst'2dpage'2dnumber'7cblank'2d'28last'2d'29'3fpage'2dforce'7cfirst'2dpage'2dnumber'7cpage'2dcount'7cpage'2dlimit'2dinter'2dsystem'2dspace'7cpage'2dlimit'2dinter'2dsystem'2dspace'2dfactor'7cpage'2dspacing'2dweight'7cprint'2dall'2dheaders'7cprint'2dfirst'2dpage'2dnumber'7cprint'2dpage'2dnumber'7cragged'2d'28bottom'7cright'29'7cragged'2dlast'28'2dbottom'29'3f'7csystem'2dseparator'2dmarkup'7cforce'2dassignment'7cinput'2dencoding'7coutput'2dscale'7c'28'28even'7codd'29'28Footer'7cHeader'29'7c'28book'7cscore'7ctoc'29Title'7ctocItem'29Markup'7csystem'2dcount'7c'28short'2d'29'3findent'29'5cb = compileRegex True "\\b(dedication|(sub){,2}title|poet|composer|meter|opus|arranger|instrument|piece|breakbefore|copyright|tagline|mutopia(title|composer|poet|opus|instrument)|date|enteredby|source|style|maintainer(Email|Web)?|moreInfo|lastupdated|texidoc|footer|(top|bottom|left|right)-margin|(foot|head)-separation|indent|short-indent|paper-(height|width)|horizontal-shift|line-width|(inner|outer)-margin|two-sided|binding-offset|(after|before|between)-title-space|between-system-(space|padding)|page-top-space|page-breaking-between-system-padding|(after|before|between)-title-spacing|between-(scores-)?system-spacing|bottom-system-spacing|top-title-spacing|top-system-spacing|page-breaking-between-system-spacing|system-count|(min-|max-)?systems-per-page|annotate-spacing|auto-first-page-number|blank-(last-)?page-force|first-page-number|page-count|page-limit-inter-system-space|page-limit-inter-system-space-factor|page-spacing-weight|print-all-headers|print-first-page-number|print-page-number|ragged-(bottom|right)|ragged-last(-bottom)?|system-separator-markup|force-assignment|input-encoding|output-scale|((even|odd)(Footer|Header)|(book|score|toc)Title|tocItem)Markup|system-count|(short-)?indent)\\b" +regex_'3d'28'5cs'2a'5bA'2dZa'2dz'5d'2b'29'3f = compileRegex True "=(\\s*[A-Za-z]+)?" +regex_'5bA'2dZa'2dz'5d'2b'28'3f'3d'5cs'2a'5c'2e'29 = compileRegex True "[A-Za-z]+(?=\\s*\\.)" +regex_'5cd'2b'5c'2e'2a'5cs'2a'3d'5cs'2a'5cd'2b = compileRegex True "\\d+\\.*\\s*=\\s*\\d+" + +parseRules ("LilyPond","lilypond") = + (((parseRules ("LilyPond","music"))) + <|> + ((lookAhead (pRegExpr regex_'5cb'5ba'2dz'5d'2b'5cs'2a'3d) >> pushContext ("LilyPond","assignment") >> currentContext >>= parseRules)) + <|> + (currentContext >>= \x -> guard (x == ("LilyPond","lilypond")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("LilyPond","music") = + (((pAnyChar "()~" >>= withAttribute CharTok)) + <|> + ((pAnyChar "[]" >>= withAttribute DataTypeTok)) + <|> + ((pAnyChar "-_^" >>= withAttribute NormalTok) >>~ pushContext ("LilyPond","connect")) + <|> + ((lookAhead (pDetectChar False '\\') >> pushContext ("LilyPond","musiccommand") >> currentContext >>= parseRules)) + <|> + ((parseRules ("LilyPond","default"))) + <|> + ((pDetectChar False '<' >>= withAttribute DataTypeTok) >>~ pushContext ("LilyPond","chord")) + <|> + ((pDetectChar False '>' >>= withAttribute ErrorTok)) + <|> + ((pRegExpr regex_'5ba'2dz'5d'2b'5cd'2b'5c'2e'2a'5b'2c'27'5d'2b >>= withAttribute ErrorTok)) + <|> + ((pRegExpr regex_'28'5cb'5bsrR'5d'28'3f'21'5bA'2dZa'2dz'5d'29'7c'5cb'28'5ba'2dh'5d'28'28iss'29'7b1'2c2'7d'7c'28ess'29'7b1'2c2'7d'7c'28is'29'7b1'2c2'7d'7c'28es'29'7b1'2c2'7d'7c'28sharp'29'7b1'2c2'7d'7c'28flat'29'7b1'2c2'7d'7css'3f'7cff'3f'29'3f'7c'28do'7cre'7cmi'7cfa'7csol'7cla'7csi'29'28dd'3f'7cbb'3f'7css'3f'7ckk'3f'29'3f'7cq'29'28'27'2b'7c'2c'2b'7c'28'3f'21'5bA'2dZa'2dz'5d'29'29'29 >>= withAttribute NormalTok) >>~ pushContext ("LilyPond","pitch")) + <|> + ((pRegExpr regex_'3a'5cd'2a >>= withAttribute NormalTok)) + <|> + (currentContext >>= \x -> guard (x == ("LilyPond","music")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("LilyPond","default") = + (((pDetect2Chars False '<' '<' >>= withAttribute KeywordTok)) + <|> + ((pDetect2Chars False '>' '>' >>= withAttribute KeywordTok)) + <|> + ((pDetectChar False '{' >>= withAttribute KeywordTok)) + <|> + ((pDetectChar False '}' >>= withAttribute KeywordTok)) + <|> + ((pDetectChar False '|' >>= withAttribute DecValTok)) + <|> + ((lookAhead (pDetectChar False '\\') >> pushContext ("LilyPond","command") >> currentContext >>= parseRules)) + <|> + ((parseRules ("LilyPond","basic"))) + <|> + (currentContext >>= \x -> guard (x == ("LilyPond","default")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("LilyPond","basic") = + (((pDetect2Chars False '%' '{' >>= withAttribute NormalTok) >>~ pushContext ("LilyPond","commentblock")) + <|> + ((pDetectChar False '%' >>= withAttribute NormalTok) >>~ pushContext ("LilyPond","commentline")) + <|> + ((pDetectChar False '"' >>= withAttribute NormalTok) >>~ pushContext ("LilyPond","string")) + <|> + ((pDetectChar False '#' >>= withAttribute NormalTok) >>~ pushContext ("LilyPond","scheme")) + <|> + ((pDetectChar False '$' >>= withAttribute NormalTok) >>~ pushContext ("LilyPond","schemesub")) + <|> + (currentContext >>= \x -> guard (x == ("LilyPond","basic")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("LilyPond","musiccommand") = + (((pRegExpr regex_'5c'5c'28p'7b1'2c5'7d'7cmp'7cmf'7cf'7b1'2c5'7d'7cs'3ffp'7csff'3f'7cspp'3f'7c'5bsr'5d'3ffz'7ccresc'7cdecresc'7cdim'29'28'3f'21'5bA'2dZa'2dz'5d'29 >>= withAttribute StringTok)) + <|> + ((pRegExpr regex_'5c'5c'5b'3c'21'3e'5d >>= withAttribute StringTok)) + <|> + ((pRegExpr regex_'5c'5c'28'5cd'2b'7caccent'7cmarcato'7cstaccat'28issim'29'3fo'7cespressivo'7ctenuto'7cportato'7c'28up'7cdown'29'28bow'7cmordent'7cprall'29'7cflageolet'7cthumb'7c'5blr'5d'28heel'7ctoe'29'7copen'7cstopped'7cturn'7creverseturn'7ctrill'7cmordent'7cprall'28prall'7cmordent'7cdown'7cup'29'3f'7clineprall'7csignumcongruentiae'7c'28short'7clong'7cverylong'29'3ffermata'7csegno'7c'28var'29'3fcoda'7csnappizzicato'7chalfopen'29'28'3f'21'5bA'2dZa'2dz'5d'29 >>= withAttribute StringTok)) + <|> + ((pRegExpr regex_'5c'5c'5b'28'29'5d >>= withAttribute CharTok)) + <|> + ((pRegExpr regex_'5c'5c'5b'5d'5b'5d >>= withAttribute DataTypeTok)) + <|> + ((parseRules ("LilyPond","command"))) + <|> + ((popContext) >> currentContext >>= parseRules)) + +parseRules ("LilyPond","command") = + (((pDetect2Chars False '\\' '\\' >>= withAttribute KeywordTok)) + <|> + ((pRegExpr regex_'5c'5cnote'28mode'7cs'29'28'3f'21'5bA'2dZa'2dz'5d'29 >>= withAttribute NormalTok) >>~ pushContext ("LilyPond","notemode")) + <|> + ((pRegExpr regex_'5c'5cdrum'28mode'7cs'29'28'3f'21'5bA'2dZa'2dz'5d'29 >>= withAttribute NormalTok) >>~ pushContext ("LilyPond","drummode")) + <|> + ((pRegExpr regex_'5c'5cchord'28mode'7cs'29'28'3f'21'5bA'2dZa'2dz'5d'29 >>= withAttribute NormalTok) >>~ pushContext ("LilyPond","chordmode")) + <|> + ((pRegExpr regex_'5c'5cfigure'28mode'7cs'29'28'3f'21'5bA'2dZa'2dz'5d'29 >>= withAttribute NormalTok) >>~ pushContext ("LilyPond","figuremode")) + <|> + ((pRegExpr regex_'5c'5c'28lyric'28mode'7cs'29'7caddlyrics'29'28'3f'21'5bA'2dZa'2dz'5d'29 >>= withAttribute NormalTok) >>~ pushContext ("LilyPond","lyricmode")) + <|> + ((pRegExpr regex_'5c'5clyricsto'28'3f'21'5bA'2dZa'2dz'5d'29 >>= withAttribute NormalTok) >>~ pushContext ("LilyPond","lyricsto")) + <|> + ((pRegExpr regex_'5c'5cmarkup'28lines'29'3f'28'3f'21'5bA'2dZa'2dz'5d'29 >>= withAttribute BaseNTok) >>~ pushContext ("LilyPond","markup")) + <|> + ((pRegExpr regex_'5c'5c'28header'7cpaper'7clayout'7cmidi'7cwith'29'5cb >>= withAttribute NormalTok) >>~ pushContext ("LilyPond","section")) + <|> + ((pRegExpr regex_'5c'5c'28new'7ccontext'7cchange'29'5cb >>= withAttribute KeywordTok) >>~ pushContext ("LilyPond","context")) + <|> + ((pRegExpr regex_'5c'5c'28un'29'3fset'5cb >>= withAttribute KeywordTok) >>~ pushContext ("LilyPond","set")) + <|> + ((pRegExpr regex_'5c'5c'28override'28Property'29'3f'7crevert'29'28'3f'21'5bA'2dZa'2dz'5d'29 >>= withAttribute KeywordTok) >>~ pushContext ("LilyPond","override")) + <|> + ((pRegExpr regex_'5c'5cskip'28'3f'21'5bA'2dZa'2dz'5d'29 >>= withAttribute FunctionTok) >>~ pushContext ("LilyPond","duration")) + <|> + ((pRegExpr regex_'5c'5ctempo'28'3f'21'5bA'2dZa'2dz'5d'29 >>= withAttribute FunctionTok) >>~ pushContext ("LilyPond","tempo")) + <|> + ((pRegExpr regex_'5c'5c'28accepts'7calias'7cconsists'7cdefaultchild'7cdenies'7cdescription'7cgrobdescriptions'7cinclude'7cinvalid'7clanguage'7cname'7cobjectid'7conce'7cremove'7csequential'7csimultaneous'7ctype'7cversion'7cscore'7cbook'7cbookpart'29'28'3f'21'5bA'2dZa'2dz'5d'29 >>= withAttribute KeywordTok)) + <|> + ((pRegExpr regex_'5c'5c'28'28aiken'7cfunk'7csacredHarp'7csouthernHarmony'7cwalker'29Heads'28Minor'29'3f'29'28'3f'21'5bA'2dZa'2dz'5d'29 >>= withAttribute FunctionTok)) + <|> + ((pRegExpr regex_'5c'5c'28acciaccatura'7caddQuote'7cafterGrace'7callowPageTurn'7calternative'7capply'28Context'7cMusic'7cOutput'29'7cappoggiatura'7carpeggio'28Arrow'28Down'7cUp'29'7cBracket'7cNormal'7cParenthesis'29'3f'7c'28a'7cde'29scendens'7cauctum'7caugmentum'7cautoBeamO'28ff'7cn'29'7cautochange'7cballoon'28Grob'29'3fText'7cbar'7cbarNumberCheck'7cbendAfter'7cbreathe'7cbreak'7ccadenzaO'28ff'7cn'29'7ccavum'7cclef'28'5cs'2b'28treble'7cviolin'7cG'7calto'7cC'7ctenor'7c'28sub'29'3fbass'7cF'7cfrench'7c'28mezzo'29'3fsoprano'7c'28var'29'3fbaritone'7cpercussion'7ctab'29'29'3f'7c'28end'29'3f'28de'29'3fcr'7ccresc'28TextCresc'7cHairpin'29'29'28'3f'21'5bA'2dZa'2dz'5d'29 >>= withAttribute FunctionTok)) + <|> + ((pRegExpr regex_'5c'5c'28'28cue'7ctransposedCue'29During'7cdefault'7cdeminutum'7cdim'28Text'28Decresc'7cDecr'7cDim'29'7cHairpin'29'7cdisplay'28Lily'29'3fMusic'7cdivisio'28Maior'7cMaxima'7cMinima'29'7c'28dynamic'7cdots'7cphrasingSlur'7cslur'7cstem'7ctie'7ctuplet'29'28Down'7cNeutral'7cUp'29'7c'28balloon'7ctext'29LengthO'28ff'7cn'29'7cfeatherDurations'7cfigure'28mode'7cs'29'7cfinalis'7cflexa'7c'28french'7cgerman'7citalian'7csemiGerman'29Chords'7cglissando'7cgrace'7charmonic'7c'28unH'7ch'29ideNotes'7c'28hide'7cshow'29StaffSwitch'7cinclinatum'7c'28keep'7cremove'29WithTag'7ckey'28'5cs'2b'5cb'28'5ba'2dh'5d'28'28iss'29'7b1'2c2'7d'7c'28ess'29'7b1'2c2'7d'7c'28is'29'7b1'2c2'7d'7c'28es'29'7b1'2c2'7d'7c'28sharp'29'7b1'2c2'7d'7c'28flat'29'7b1'2c2'7d'7css'3f'7cff'3f'29'3f'7c'28do'7cre'7cmi'7cfa'7csol'7cla'7csi'29'28dd'3f'7cbb'3f'7css'3f'7ckk'3f'29'3f'7cq'29'28'27'2b'7c'2c'2b'7c'28'3f'21'5bA'2dZa'2dz'5d'29'29'29'3f'7ckillCues'29'28'3f'21'5bA'2dZa'2dz'5d'29 >>= withAttribute FunctionTok)) + <|> + ((pRegExpr regex_'5c'5c'28label'7claissezVibrer'7clinea'7cmakeClusters'7cmark'7cmaxima'7cmelisma'28End'29'3f'7cmergeDifferently'28Head'7cDott'29edO'28ff'7cn'29'7cnewSpacingSection'7cno'28Beam'7cBreak'7cPageBreak'7cPageTurn'29'7cnormalsize'7cnumericTimeSignature'7coctaveCheck'7coneVoice'7coriscus'7cottava'7cpage'28'2dref'7cBreak'7cTurn'29'7cparallelMusic'7cparenthesize'7cpartcombine'7cpartial'28'5cs'2a'28'5c'5c'28longa'7cbreve'29'5cb'7c'281'7c2'7c4'7c8'7c16'7c32'7c64'7c128'7c256'7c512'7c1024'7c2048'29'28'3f'21'5cd'29'29'28'5cs'2a'5c'2e'2b'29'3f'28'5cs'2a'5c'2a'5cs'2a'5cd'2b'28'2f'5cd'2b'29'3f'29'2a'29'3f'7cpes'7cpitchedTrill'29'28'3f'21'5bA'2dZa'2dz'5d'29 >>= withAttribute FunctionTok)) + <|> + ((pRegExpr regex_'5c'5c'28pointAndClickO'28ff'7cn'29'7cquilisma'7cquoteDuring'7crelative'28'5cs'2b'5cb'28'5ba'2dh'5d'28'28iss'29'7b1'2c2'7d'7c'28ess'29'7b1'2c2'7d'7c'28is'29'7b1'2c2'7d'7c'28es'29'7b1'2c2'7d'7c'28sharp'29'7b1'2c2'7d'7c'28flat'29'7b1'2c2'7d'7css'3f'7cff'3f'29'3f'7c'28do'7cre'7cmi'7cfa'7csol'7cla'7csi'29'28dd'3f'7cbb'3f'7css'3f'7ckk'3f'29'3f'7cq'29'28'27'2b'7c'2c'2b'7c'28'3f'21'5bA'2dZa'2dz'5d'29'29'29'3f'7cRemoveEmptyStaffContext'7crepeat'28'5cs'2b'28unfold'7cvolta'7ctremolo'7cpercent'29'28'5cs'2b'5cd'2b'29'3f'29'3f'7crepeatTie'7cresetRelativeOctave'7crest'7cscaleDurations'7cscoreTweak'7ceasyHeadsO'28ff'7cn'29'7cshift'28Durations'7cOff'7cOn'7b1'2c3'7d'29'7c'28slur'7ctie'29'28Both'7cDashed'7cDotted'7cSolid'29'7csmall'7cspacingTweaks'29'28'3f'21'5bA'2dZa'2dz'5d'29 >>= withAttribute FunctionTok)) + <|> + ((pRegExpr regex_'5c'5c'28'28start'7cstop'29'28Group'7c'28Text'7cTrill'29Span'7cStaff'29'7cstemBoth'7cstropha'7csuper'7c'28sustain'7csostenuto'29O'28ff'7cn'29'7ctable'2dof'2dcontents'7ctag'7ctimes'3f'28'5cs'2a'5cd'2b'2f'5cd'2b'29'3f'7ctiny'7ctocItem'29'28'3f'21'5bA'2dZa'2dz'5d'29 >>= withAttribute FunctionTok)) + <|> + ((pRegExpr regex_'5c'5c'28transpose'28'5cs'2b'5cb'28'5ba'2dh'5d'28'28iss'29'7b1'2c2'7d'7c'28ess'29'7b1'2c2'7d'7c'28is'29'7b1'2c2'7d'7c'28es'29'7b1'2c2'7d'7c'28sharp'29'7b1'2c2'7d'7c'28flat'29'7b1'2c2'7d'7css'3f'7cff'3f'29'3f'7c'28do'7cre'7cmi'7cfa'7csol'7cla'7csi'29'28dd'3f'7cbb'3f'7css'3f'7ckk'3f'29'3f'7cq'29'28'27'2b'7c'2c'2b'7c'28'3f'21'5bA'2dZa'2dz'5d'29'29'5cs'2a'5cb'28'5ba'2dh'5d'28'28iss'29'7b1'2c2'7d'7c'28ess'29'7b1'2c2'7d'7c'28is'29'7b1'2c2'7d'7c'28es'29'7b1'2c2'7d'7c'28sharp'29'7b1'2c2'7d'7c'28flat'29'7b1'2c2'7d'7css'3f'7cff'3f'29'3f'7c'28do'7cre'7cmi'7cfa'7csol'7cla'7csi'29'28dd'3f'7cbb'3f'7css'3f'7ckk'3f'29'3f'7cq'29'28'27'2b'7c'2c'2b'7c'28'3f'21'5bA'2dZa'2dz'5d'29'29'29'3f'7ctransposition'28'5cs'2b'5cb'28'5ba'2dh'5d'28'28iss'29'7b1'2c2'7d'7c'28ess'29'7b1'2c2'7d'7c'28is'29'7b1'2c2'7d'7c'28es'29'7b1'2c2'7d'7c'28sharp'29'7b1'2c2'7d'7c'28flat'29'7b1'2c2'7d'7css'3f'7cff'3f'29'3f'7c'28do'7cre'7cmi'7cfa'7csol'7cla'7csi'29'28dd'3f'7cbb'3f'7css'3f'7ckk'3f'29'3f'7cq'29'28'27'2b'7c'2c'2b'7c'28'3f'21'5bA'2dZa'2dz'5d'29'29'29'29'28'3f'21'5bA'2dZa'2dz'5d'29 >>= withAttribute FunctionTok)) + <|> + ((pRegExpr regex_'5c'5c'28tweak'7cunfoldRepeats'7cvirg'28ul'29'3fa'7cvoice'28One'7cTwo'7cThree'7cFour'29'7cwithMusicProperty'7ccm'7cmm'7cin'7cpt'7cmajor'7cminor'7cionian'7clocrian'7caeolian'7cmixolydian'7clydian'7cphrygian'7cdorian'29'28'3f'21'5bA'2dZa'2dz'5d'29 >>= withAttribute FunctionTok)) + <|> + ((pRegExpr regex_'5c'5c'28dash'28Hat'7cPlus'7cDash'7cBar'7cLarger'7cDot'7cUnderscore'29'7cfermataMarkup'7cpipeSymbol'7cslashSeparator'29'28'3f'21'5bA'2dZa'2dz'5d'29 >>= withAttribute DataTypeTok)) + <|> + ((pRegExpr regex_'5c'5c'28consistsend'29'28'3f'21'5bA'2dZa'2dz'5d'29 >>= withAttribute KeywordTok)) + <|> + ((pRegExpr regex_'5c'5c'28arpeggio'28Up'7cDown'7cNeutral'29'7cnewpage'7cscript'28Up'7cDown'7cBoth'29'7c'28empty'7cfat'29Text'7csetEasyHeads'7c'28default'7cvoice'7cmodernVoice'7cpiano'7cforget'29Accidentals'7c'28modern'28Voice'29'3f'7cpiano'29Cautionaries'7cnoResetKey'7ccompressMusic'7coctave'7c'28sustain'7csostenuto'29'28Down'7cUp'29'7cset'28Hairpin'7cText'29'28Cresc'7cDecresc'7cDim'29'7csetTextDecr'29'28'3f'21'5bA'2dZa'2dz'5d'29 >>= withAttribute FunctionTok)) + <|> + ((pRegExpr regex_'5c'5c'28translator'7cnewcontext'29'5cb >>= withAttribute KeywordTok) >>~ pushContext ("LilyPond","context")) + <|> + ((pRegExpr regex_'5c'5cproperty'28'3f'21'5bA'2dZa'2dz'5d'29 >>= withAttribute KeywordTok) >>~ pushContext ("LilyPond","override")) + <|> + ((pRegExpr regex_'5c'5c'5bA'2dZa'2dz'5d'2b >>= withAttribute FunctionTok)) + <|> + ((pDetectChar False '\\' >>= withAttribute ErrorTok)) + <|> + ((popContext) >> currentContext >>= parseRules)) + +parseRules ("LilyPond","assignment") = + (((pRegExpr regex_'5cb'28dash'28Hat'7cPlus'7cDash'7cBar'7cLarger'7cDot'7cUnderscore'29'7cfermataMarkup'7cpipeSymbol'7cslashSeparator'29'5cb >>= withAttribute DataTypeTok) >>~ (popContext)) + <|> + ((pRegExpr regex_'5ba'2dz'5d'2b >>= withAttribute FunctionTok) >>~ (popContext)) + <|> + (currentContext >>= \x -> guard (x == ("LilyPond","assignment")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("LilyPond","pitch") = + (((pRegExpr regex_'3d'5cs'2a'28'27'2b'7c'2c'2b'29'3f >>= withAttribute DecValTok)) + <|> + ((pAnyChar "!?" >>= withAttribute NormalTok)) + <|> + ((parseRules ("LilyPond","duration"))) + <|> + ((popContext) >> currentContext >>= parseRules)) + +parseRules ("LilyPond","duration") = + (((pDetectSpaces >>= withAttribute NormalTok)) + <|> + ((pRegExpr regex_'28'5c'5c'28longa'7cbreve'29'5cb'7c'281'7c2'7c4'7c8'7c16'7c32'7c64'7c128'7c256'7c512'7c1024'7c2048'29'28'3f'21'5cd'29'29'28'5cs'2a'5c'2e'2b'29'3f'28'5cs'2a'5c'2a'5cs'2a'5cd'2b'28'2f'5cd'2b'29'3f'29'2a >>= withAttribute DataTypeTok) >>~ (popContext)) + <|> + ((pRegExpr regex_'5cd'2b >>= withAttribute ErrorTok) >>~ (popContext)) + <|> + ((popContext) >> currentContext >>= parseRules)) + +parseRules ("LilyPond","chord") = + (((pDetectChar False '>' >>= withAttribute NormalTok) >>~ pushContext ("LilyPond","chordend")) + <|> + ((pRegExpr regex_'5cb'28'5ba'2dh'5d'28'28iss'29'7b1'2c2'7d'7c'28ess'29'7b1'2c2'7d'7c'28is'29'7b1'2c2'7d'7c'28es'29'7b1'2c2'7d'7c'28sharp'29'7b1'2c2'7d'7c'28flat'29'7b1'2c2'7d'7css'3f'7cff'3f'29'3f'7c'28do'7cre'7cmi'7cfa'7csol'7cla'7csi'29'28dd'3f'7cbb'3f'7css'3f'7ckk'3f'29'3f'7cq'29'28'27'2b'7c'2c'2b'7c'28'3f'21'5bA'2dZa'2dz'5d'29'29 >>= withAttribute NormalTok) >>~ pushContext ("LilyPond","chordpitch")) + <|> + ((pAnyChar "<{}srR" >>= withAttribute ErrorTok)) + <|> + ((parseRules ("LilyPond","music"))) + <|> + (currentContext >>= \x -> guard (x == ("LilyPond","chord")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("LilyPond","chordpitch") = + (((pDetectSpaces >>= withAttribute NormalTok)) + <|> + ((pRegExpr regex_'3d'5cs'2a'28'27'2b'7c'2c'2b'29'3f >>= withAttribute DecValTok)) + <|> + ((pRegExpr regex_'28'5c'5c'28longa'7cbreve'29'5cb'7c'281'7c2'7c4'7c8'7c16'7c32'7c64'7c128'7c256'7c512'7c1024'7c2048'29'28'3f'21'5cd'29'29'28'5cs'2a'5c'2e'2b'29'3f'28'5cs'2a'5c'2a'5cs'2a'5cd'2b'28'2f'5cd'2b'29'3f'29'2a >>= withAttribute ErrorTok) >>~ (popContext)) + <|> + ((pRegExpr regex_'5cd'2b >>= withAttribute ErrorTok) >>~ (popContext)) + <|> + ((popContext) >> currentContext >>= parseRules)) + +parseRules ("LilyPond","chordend") = + (((pDetectSpaces >>= withAttribute NormalTok)) + <|> + ((pRegExpr regex_'28'5c'5c'28longa'7cbreve'29'5cb'7c'281'7c2'7c4'7c8'7c16'7c32'7c64'7c128'7c256'7c512'7c1024'7c2048'29'28'3f'21'5cd'29'29'28'5cs'2a'5c'2e'2b'29'3f'28'5cs'2a'5c'2a'5cs'2a'5cd'2b'28'2f'5cd'2b'29'3f'29'2a >>= withAttribute DataTypeTok) >>~ (popContext >> popContext)) + <|> + ((popContext >> popContext) >> currentContext >>= parseRules)) + +parseRules ("LilyPond","commentline") = + (((Text.Highlighting.Kate.Syntax.Alert.parseExpression (Just ("Alerts","")) >>= ((withAttribute CommentTok) . snd))) + <|> + (currentContext >>= \x -> guard (x == ("LilyPond","commentline")) >> pDefault >>= withAttribute CommentTok)) + +parseRules ("LilyPond","commentblock") = + (((pDetect2Chars False '%' '}' >>= withAttribute CommentTok) >>~ (popContext)) + <|> + ((Text.Highlighting.Kate.Syntax.Alert.parseExpression (Just ("Alerts","")) >>= ((withAttribute CommentTok) . snd))) + <|> + (currentContext >>= \x -> guard (x == ("LilyPond","commentblock")) >> pDefault >>= withAttribute CommentTok)) + +parseRules ("LilyPond","string") = + (((pDetectChar False '"' >>= withAttribute StringTok) >>~ (popContext)) + <|> + ((pDetect2Chars False '\\' '\\' >>= withAttribute StringTok)) + <|> + ((pDetect2Chars False '\\' '"' >>= withAttribute StringTok)) + <|> + (currentContext >>= \x -> guard (x == ("LilyPond","string")) >> pDefault >>= withAttribute StringTok)) + +parseRules ("LilyPond","connect") = + (((pAnyChar ".-+|>^_12345" >>= withAttribute StringTok) >>~ (popContext)) + <|> + ((popContext) >> currentContext >>= parseRules)) + +parseRules ("LilyPond","scheme") = + (((pDetectSpaces >>= withAttribute FloatTok)) + <|> + (pushContext ("LilyPond","scheme2") >> currentContext >>= parseRules)) + +parseRules ("LilyPond","scheme2") = + (((pDetectChar False '(' >>= withAttribute FloatTok) >>~ pushContext ("LilyPond","scheme3")) + <|> + ((parseRules ("LilyPond","schemerules"))) + <|> + ((lookAhead (pDetectSpaces) >> (popContext >> popContext) >> currentContext >>= parseRules)) + <|> + (currentContext >>= \x -> guard (x == ("LilyPond","scheme2")) >> pDefault >>= withAttribute FloatTok)) + +parseRules ("LilyPond","scheme3") = + (((pDetectChar False ')' >>= withAttribute FloatTok) >>~ (popContext >> popContext >> popContext)) + <|> + ((parseRules ("LilyPond","schemerules"))) + <|> + (currentContext >>= \x -> guard (x == ("LilyPond","scheme3")) >> pDefault >>= withAttribute FloatTok)) + +parseRules ("LilyPond","schemerules") = + (((pDetectChar False '(' >>= withAttribute FloatTok) >>~ pushContext ("LilyPond","schemerules")) + <|> + ((pDetectChar False ')' >>= withAttribute FloatTok) >>~ (popContext)) + <|> + ((pDetectChar False '"' >>= withAttribute FloatTok) >>~ pushContext ("LilyPond","schemestring")) + <|> + ((pDetectChar False ';' >>= withAttribute FloatTok) >>~ pushContext ("LilyPond","schemecommentline")) + <|> + ((pDetectChar False '$' >>= withAttribute FloatTok) >>~ pushContext ("LilyPond","schemesub")) + <|> + ((pDetectChar False '\'' >>= withAttribute FloatTok) >>~ pushContext ("LilyPond","schemequote")) + <|> + ((pDetect2Chars False '#' '!' >>= withAttribute FloatTok) >>~ pushContext ("LilyPond","schemecommentblock")) + <|> + ((pDetect2Chars False '#' '{' >>= withAttribute FloatTok) >>~ pushContext ("LilyPond","schemelily")) + <|> + ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\'_0123456789" list_musicexpressions >>= withAttribute FloatTok)) + <|> + ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\'_0123456789" list_contexts >>= withAttribute FloatTok)) + <|> + ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\'_0123456789" list_layoutobjects >>= withAttribute FloatTok)) + <|> + ((pRegExpr regex_'5b'2d'2b'5d'3f'28'5cd'2b'28'5c'2e'5cd'2b'29'3f'7c'5c'2e'5cd'2b'29 >>= withAttribute DecValTok)) + <|> + ((pRegExpr regex_'23'28t'7cf'7cb'5b'2d'2b'5d'3f'5b01'2e'5d'2b'7co'5b'2d'2b'5d'3f'5b0'2d7'2e'5d'2b'7cd'5b'2d'2b'5d'3f'5b0'2d9'2e'5d'2b'7cx'5b'2d'2b'5d'3f'5b0'2d9a'2df'2e'5d'2b'29 >>= withAttribute DecValTok)) + <|> + ((pRegExpr regex_'5b'2b'2d'5d'28inf'7cnan'29'5c'2e0 >>= withAttribute DecValTok)) + <|> + ((pRegExpr regex_'5cb'28define'7cdefined'5c'3f'7cdefine'5c'2a'28'2dpublic'29'3f'7cdefine'2d'28'5c'2a'7cbuiltin'2dmarkup'2d'28list'2d'29'3fcommand'7cclass'7c'28extra'2d'29'3fdisplay'2dmethod'7cfonts'3f'7cgrob'2dproperty'7cly'2dsyntax'28'2dloc'7c'2dsimple'29'3f'7cmacro'28'2dpublic'29'3f'7cmarkup'2d'28list'2d'29command'7cmethod'7cmodule'7cmusic'2dfunction'7cpost'2devent'2ddisplay'2dmethod'7cpublic'28'2dmacro'7c'2dtoplevel'29'3f'7csafe'2dpublic'7cspan'2devent'2ddisplay'2dmethod'29'7cdefmacro'28'5c'2a'28'2dpublic'29'3f'29'3f'7clambda'5c'2a'3f'7cand'7cor'7cif'7ccond'7ccase'7clet'5c'2a'3f'7cletrec'7cbegin'7cdo'7cdelay'7cset'21'7celse'7c'28quasi'29'3fquote'7cunquote'28'2dsplicing'29'3f'7c'28define'7clet'7cletrec'29'2dsyntax'7csyntax'2drules'29'28'3f'3d'28'24'7c'5cs'7c'5c'29'29'29 >>= withAttribute FloatTok)) + <|> + ((pRegExpr regex_'5cb'28not'7cboolean'5c'3f'7ceq'5c'3f'7ceqv'5c'3f'7cequal'5c'3f'7cpair'5c'3f'7ccons'7cset'2dc'5bad'5dr'21'7cc'5bad'5d'7b1'2c4'7dr'7cnull'5c'3f'7clist'5c'3f'7clist'7clength'7cappend'7creverse'7clist'2dref'7cmem'5bqv'5d'7cmember'7cass'5bqv'5d'7cassoc'7csymbol'5c'3f'7csymbol'2d'3estring'7cstring'2d'3esymbol'7cnumber'5c'3f'7ccomplex'5c'3f'7creal'5c'3f'7crational'5c'3f'7cinteger'5c'3f'7cexact'5c'3f'7cinexact'5c'3f'7czero'5c'3f'7cpositive'5c'3f'7cnegative'5c'3f'7codd'5c'3f'7ceven'5c'3f'7cmax'7cmin'7cabs'7cquotient'7cremainder'7cmodulo'7cgcd'7clcm'7cnumerator'7cdenominator'7cfloor'7cceiling'7ctruncate'7cround'7crationalize'7cexp'7clog'7csin'7ccos'7ctan'7casin'7cacos'7catan'7csqrt'7cexpt'7cmake'2drectangular'7cmake'2dpolar'7creal'2dpart'7cimag'2dpart'7cmagnitude'7cangle'7cexact'2d'3einexact'7cinexact'2d'3eexact'7cnumber'2d'3estring'7cstring'2d'3enumber'29'28'3f'3d'28'24'7c'5cs'7c'5c'29'29'29 >>= withAttribute FloatTok)) + <|> + ((pRegExpr regex_'5cb'28char'28'28'2dci'29'3f'28'3d'5c'3f'7c'3c'5c'3f'7c'3e'5c'3f'7c'3c'3d'5c'3f'7c'3e'3d'5c'3f'29'7c'2dalphabetic'5c'3f'7c'5c'3f'7c'2dnumeric'5c'3f'7c'2dwhitespace'5c'3f'7c'2dupper'2dcase'5c'3f'7c'2dlower'2dcase'5c'3f'7c'2d'3einteger'7c'2dupcase'7c'2ddowncase'7c'2dready'5c'3f'29'7cinteger'2d'3echar'7cmake'2dstring'7cstring'28'5c'3f'7c'2dcopy'7c'2dfill'21'7c'2dlength'7c'2dref'7c'2dset'21'7c'28'2dci'29'3f'28'3d'5c'3f'7c'3c'5c'3f'7c'3e'5c'3f'7c'3c'3d'5c'3f'7c'3e'3d'5c'3f'29'7c'2dappend'29'7csubstring'7cmake'2dvector'7cvector'28'5c'3f'7c'2dlength'7c'2dref'7c'2dset'21'7c'2dfill'21'29'3f'7cprocedure'5c'3f'7capply'7cmap'7cfor'2deach'7cforce'7ccall'2dwith'2d'28current'2dcontinuation'7c'28in'7cout'29put'2dfile'29'7c'28in'7cout'29put'2dport'5c'3f'7ccurrent'2d'28in'7cout'29put'2dport'7copen'2d'28in'7cout'29put'2dfile'7cclose'2d'28in'7cout'29put'2dport'7ceof'2dobject'5c'3f'7cread'7c'28read'7cpeek'29'2dchar'7cwrite'28'2dchar'29'3f'7cdisplay'7cnewline'7ccall'2fcc'7clist'2dtail'7cstring'2d'3elist'7clist'2d'3estring'7cvector'2d'3elist'7clist'2d'3evector'7cwith'2dinput'2dfrom'2dfile'7cwith'2doutput'2dto'2dfile'7cload'7ctranscript'2d'28on'7coff'29'7ceval'7cdynamic'2dwind'7cport'5c'3f'7cvalues'7ccall'2dwith'2dvalues'7c'28scheme'2dreport'2d'7cnull'2d'7cinteraction'2d'29environment'29'28'3f'3d'28'24'7c'5cs'7c'5c'29'29'29 >>= withAttribute FloatTok)) + <|> + ((pRegExpr regex_'5ba'2dzA'2dZ'23'5d'5b'5e'5cs'28'29'7b'7d'5b'5c'5d'3b'24'22'5d'2a >>= withAttribute FloatTok)) + <|> + (currentContext >>= \x -> guard (x == ("LilyPond","schemerules")) >> pDefault >>= withAttribute FloatTok)) + +parseRules ("LilyPond","schemequote") = + (((pRegExpr regex_'5cb'28define'7cdefined'5c'3f'7cdefine'5c'2a'28'2dpublic'29'3f'7cdefine'2d'28'5c'2a'7cbuiltin'2dmarkup'2d'28list'2d'29'3fcommand'7cclass'7c'28extra'2d'29'3fdisplay'2dmethod'7cfonts'3f'7cgrob'2dproperty'7cly'2dsyntax'28'2dloc'7c'2dsimple'29'3f'7cmacro'28'2dpublic'29'3f'7cmarkup'2d'28list'2d'29command'7cmethod'7cmodule'7cmusic'2dfunction'7cpost'2devent'2ddisplay'2dmethod'7cpublic'28'2dmacro'7c'2dtoplevel'29'3f'7csafe'2dpublic'7cspan'2devent'2ddisplay'2dmethod'29'7cdefmacro'28'5c'2a'28'2dpublic'29'3f'29'3f'7clambda'5c'2a'3f'7cand'7cor'7cif'7ccond'7ccase'7clet'5c'2a'3f'7cletrec'7cbegin'7cdo'7cdelay'7cset'21'7celse'7c'28quasi'29'3fquote'7cunquote'28'2dsplicing'29'3f'7c'28define'7clet'7cletrec'29'2dsyntax'7csyntax'2drules'29'28'3f'3d'28'24'7c'5cs'7c'5c'29'29'29 >>= withAttribute FloatTok)) + <|> + ((pRegExpr regex_'5cb'28not'7cboolean'5c'3f'7ceq'5c'3f'7ceqv'5c'3f'7cequal'5c'3f'7cpair'5c'3f'7ccons'7cset'2dc'5bad'5dr'21'7cc'5bad'5d'7b1'2c4'7dr'7cnull'5c'3f'7clist'5c'3f'7clist'7clength'7cappend'7creverse'7clist'2dref'7cmem'5bqv'5d'7cmember'7cass'5bqv'5d'7cassoc'7csymbol'5c'3f'7csymbol'2d'3estring'7cstring'2d'3esymbol'7cnumber'5c'3f'7ccomplex'5c'3f'7creal'5c'3f'7crational'5c'3f'7cinteger'5c'3f'7cexact'5c'3f'7cinexact'5c'3f'7czero'5c'3f'7cpositive'5c'3f'7cnegative'5c'3f'7codd'5c'3f'7ceven'5c'3f'7cmax'7cmin'7cabs'7cquotient'7cremainder'7cmodulo'7cgcd'7clcm'7cnumerator'7cdenominator'7cfloor'7cceiling'7ctruncate'7cround'7crationalize'7cexp'7clog'7csin'7ccos'7ctan'7casin'7cacos'7catan'7csqrt'7cexpt'7cmake'2drectangular'7cmake'2dpolar'7creal'2dpart'7cimag'2dpart'7cmagnitude'7cangle'7cexact'2d'3einexact'7cinexact'2d'3eexact'7cnumber'2d'3estring'7cstring'2d'3enumber'29'28'3f'3d'28'24'7c'5cs'7c'5c'29'29'29 >>= withAttribute FloatTok)) + <|> + ((pRegExpr regex_'5cb'28char'28'28'2dci'29'3f'28'3d'5c'3f'7c'3c'5c'3f'7c'3e'5c'3f'7c'3c'3d'5c'3f'7c'3e'3d'5c'3f'29'7c'2dalphabetic'5c'3f'7c'5c'3f'7c'2dnumeric'5c'3f'7c'2dwhitespace'5c'3f'7c'2dupper'2dcase'5c'3f'7c'2dlower'2dcase'5c'3f'7c'2d'3einteger'7c'2dupcase'7c'2ddowncase'7c'2dready'5c'3f'29'7cinteger'2d'3echar'7cmake'2dstring'7cstring'28'5c'3f'7c'2dcopy'7c'2dfill'21'7c'2dlength'7c'2dref'7c'2dset'21'7c'28'2dci'29'3f'28'3d'5c'3f'7c'3c'5c'3f'7c'3e'5c'3f'7c'3c'3d'5c'3f'7c'3e'3d'5c'3f'29'7c'2dappend'29'7csubstring'7cmake'2dvector'7cvector'28'5c'3f'7c'2dlength'7c'2dref'7c'2dset'21'7c'2dfill'21'29'3f'7cprocedure'5c'3f'7capply'7cmap'7cfor'2deach'7cforce'7ccall'2dwith'2d'28current'2dcontinuation'7c'28in'7cout'29put'2dfile'29'7c'28in'7cout'29put'2dport'5c'3f'7ccurrent'2d'28in'7cout'29put'2dport'7copen'2d'28in'7cout'29put'2dfile'7cclose'2d'28in'7cout'29put'2dport'7ceof'2dobject'5c'3f'7cread'7c'28read'7cpeek'29'2dchar'7cwrite'28'2dchar'29'3f'7cdisplay'7cnewline'7ccall'2fcc'7clist'2dtail'7cstring'2d'3elist'7clist'2d'3estring'7cvector'2d'3elist'7clist'2d'3evector'7cwith'2dinput'2dfrom'2dfile'7cwith'2doutput'2dto'2dfile'7cload'7ctranscript'2d'28on'7coff'29'7ceval'7cdynamic'2dwind'7cport'5c'3f'7cvalues'7ccall'2dwith'2dvalues'7c'28scheme'2dreport'2d'7cnull'2d'7cinteraction'2d'29environment'29'28'3f'3d'28'24'7c'5cs'7c'5c'29'29'29 >>= withAttribute FloatTok)) + <|> + ((popContext) >> currentContext >>= parseRules)) + +parseRules ("LilyPond","schemelily") = + (((pDetect2Chars False '#' '}' >>= withAttribute FloatTok) >>~ (popContext)) + <|> + ((parseRules ("LilyPond","lilypond"))) + <|> + (currentContext >>= \x -> guard (x == ("LilyPond","schemelily")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("LilyPond","schemecommentline") = + (((Text.Highlighting.Kate.Syntax.Alert.parseExpression (Just ("Alerts","")) >>= ((withAttribute CommentTok) . snd))) + <|> + (currentContext >>= \x -> guard (x == ("LilyPond","schemecommentline")) >> pDefault >>= withAttribute CommentTok)) + +parseRules ("LilyPond","schemecommentblock") = + (((pDetect2Chars False '!' '#' >>= withAttribute CommentTok) >>~ (popContext)) + <|> + ((Text.Highlighting.Kate.Syntax.Alert.parseExpression (Just ("Alerts","")) >>= ((withAttribute CommentTok) . snd))) + <|> + (currentContext >>= \x -> guard (x == ("LilyPond","schemecommentblock")) >> pDefault >>= withAttribute CommentTok)) + +parseRules ("LilyPond","schemesub") = + (((pRegExpr regex_'5ba'2dzA'2dZ'23'5d'5b'5e'5cs'28'29'7b'7d'5b'5c'5d'3b'24'22'5d'2a >>= withAttribute DecValTok) >>~ (popContext)) + <|> + ((popContext) >> currentContext >>= parseRules)) + +parseRules ("LilyPond","schemestring") = + (((pDetectChar False '"' >>= withAttribute StringTok) >>~ (popContext)) + <|> + ((pRegExpr regex_'5c'5c'5b0fnrtav'5c'5c'22'5d >>= withAttribute StringTok)) + <|> + (currentContext >>= \x -> guard (x == ("LilyPond","schemestring")) >> pDefault >>= withAttribute StringTok)) + +parseRules ("LilyPond","notemode") = + (((pDetectChar False '{' >>= withAttribute KeywordTok) >>~ pushContext ("LilyPond","notemode2")) + <|> + ((pDetectSpaces >>= withAttribute KeywordTok)) + <|> + ((popContext) >> currentContext >>= parseRules)) + +parseRules ("LilyPond","notemode2") = + (((pDetectChar False '}' >>= withAttribute KeywordTok) >>~ (popContext >> popContext)) + <|> + ((parseRules ("LilyPond","noterules"))) + <|> + (currentContext >>= \x -> guard (x == ("LilyPond","notemode2")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("LilyPond","noterules") = + (((pDetectChar False '{' >>= withAttribute KeywordTok) >>~ pushContext ("LilyPond","noterules")) + <|> + ((pDetectChar False '}' >>= withAttribute KeywordTok) >>~ (popContext)) + <|> + ((parseRules ("LilyPond","music"))) + <|> + (currentContext >>= \x -> guard (x == ("LilyPond","noterules")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("LilyPond","drummode") = + (((pDetectChar False '{' >>= withAttribute KeywordTok) >>~ pushContext ("LilyPond","drummode2")) + <|> + ((pDetectSpaces >>= withAttribute KeywordTok)) + <|> + ((popContext) >> currentContext >>= parseRules)) + +parseRules ("LilyPond","drummode2") = + (((pDetectChar False '}' >>= withAttribute KeywordTok) >>~ (popContext >> popContext)) + <|> + ((parseRules ("LilyPond","drumrules"))) + <|> + (currentContext >>= \x -> guard (x == ("LilyPond","drummode2")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("LilyPond","drumrules") = + (((pDetectChar False '{' >>= withAttribute KeywordTok) >>~ pushContext ("LilyPond","drumrules")) + <|> + ((pDetectChar False '}' >>= withAttribute KeywordTok) >>~ (popContext)) + <|> + ((pRegExpr regex_'3c'28'3f'21'3c'29 >>= withAttribute DataTypeTok) >>~ pushContext ("LilyPond","drumchord")) + <|> + ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\'_0123456789" list_drumpitchnames >>= withAttribute NormalTok) >>~ pushContext ("LilyPond","duration")) + <|> + ((parseRules ("LilyPond","music"))) + <|> + (currentContext >>= \x -> guard (x == ("LilyPond","drumrules")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("LilyPond","drumchord") = + (((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\'_0123456789" list_drumpitchnames >>= withAttribute NormalTok)) + <|> + ((parseRules ("LilyPond","chord"))) + <|> + (currentContext >>= \x -> guard (x == ("LilyPond","drumchord")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("LilyPond","chordmode") = + (((pDetectChar False '{' >>= withAttribute KeywordTok) >>~ pushContext ("LilyPond","chordmode2")) + <|> + ((pDetectSpaces >>= withAttribute KeywordTok)) + <|> + ((popContext) >> currentContext >>= parseRules)) + +parseRules ("LilyPond","chordmode2") = + (((pDetectChar False '}' >>= withAttribute KeywordTok) >>~ (popContext >> popContext)) + <|> + ((parseRules ("LilyPond","chordrules"))) + <|> + (currentContext >>= \x -> guard (x == ("LilyPond","chordmode2")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("LilyPond","chordrules") = + (((pDetectChar False '{' >>= withAttribute KeywordTok) >>~ pushContext ("LilyPond","chordrules")) + <|> + ((pDetectChar False '}' >>= withAttribute KeywordTok) >>~ (popContext)) + <|> + ((pRegExpr regex_'3a'3f'28'5b'5c'2e'5e'5d'3f'5cd'2b'5b'2d'2b'5d'3f'7c'28m'7cdim'7caug'7cmaj'7csus'29'28'3f'21'5bA'2dZa'2dz'5d'29'29'2a'28'2f'5c'2b'3f'5cb'28'5ba'2dh'5d'28'28iss'29'7b1'2c2'7d'7c'28ess'29'7b1'2c2'7d'7c'28is'29'7b1'2c2'7d'7c'28es'29'7b1'2c2'7d'7c'28sharp'29'7b1'2c2'7d'7c'28flat'29'7b1'2c2'7d'7css'3f'7cff'3f'29'3f'7c'28do'7cre'7cmi'7cfa'7csol'7cla'7csi'29'28dd'3f'7cbb'3f'7css'3f'7ckk'3f'29'3f'7cq'29'28'27'2b'7c'2c'2b'7c'28'3f'21'5bA'2dZa'2dz'5d'29'29'29'3f >>= withAttribute NormalTok)) + <|> + ((parseRules ("LilyPond","music"))) + <|> + (currentContext >>= \x -> guard (x == ("LilyPond","chordrules")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("LilyPond","figuremode") = + (((pDetectChar False '{' >>= withAttribute KeywordTok) >>~ pushContext ("LilyPond","figuremode2")) + <|> + ((pDetectSpaces >>= withAttribute KeywordTok)) + <|> + ((popContext) >> currentContext >>= parseRules)) + +parseRules ("LilyPond","figuremode2") = + (((pDetectChar False '}' >>= withAttribute KeywordTok) >>~ (popContext >> popContext)) + <|> + ((parseRules ("LilyPond","figurerules"))) + <|> + (currentContext >>= \x -> guard (x == ("LilyPond","figuremode2")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("LilyPond","figurerules") = + (((pDetectChar False '{' >>= withAttribute KeywordTok) >>~ pushContext ("LilyPond","figurerules")) + <|> + ((pDetectChar False '}' >>= withAttribute KeywordTok) >>~ (popContext)) + <|> + ((pDetectChar False '<' >>= withAttribute DataTypeTok) >>~ pushContext ("LilyPond","figure")) + <|> + ((pRegExpr regex_'5cb'5bsrR'5d'28'3f'21'5bA'2dZa'2dz'5d'29 >>= withAttribute NormalTok) >>~ pushContext ("LilyPond","duration")) + <|> + ((parseRules ("LilyPond","default"))) + <|> + (currentContext >>= \x -> guard (x == ("LilyPond","figurerules")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("LilyPond","figure") = + (((pDetectChar False '>' >>= withAttribute DataTypeTok) >>~ pushContext ("LilyPond","chordend")) + <|> + ((parseRules ("LilyPond","basic"))) + <|> + ((pRegExpr regex_'5c'5cmarkup'28lines'29'3f'28'3f'21'5bA'2dZa'2dz'5d'29 >>= withAttribute BaseNTok) >>~ pushContext ("LilyPond","markup")) + <|> + ((pRegExpr regex_'5c'5cskip'28'3f'21'5bA'2dZa'2dz'5d'29 >>= withAttribute FunctionTok) >>~ pushContext ("LilyPond","duration")) + <|> + (currentContext >>= \x -> guard (x == ("LilyPond","figure")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("LilyPond","lyricmode") = + (((pDetectChar False '{' >>= withAttribute KeywordTok) >>~ pushContext ("LilyPond","lyricmode2")) + <|> + ((pDetectSpaces >>= withAttribute KeywordTok)) + <|> + ((popContext) >> currentContext >>= parseRules)) + +parseRules ("LilyPond","lyricmode2") = + (((pDetectChar False '}' >>= withAttribute KeywordTok) >>~ (popContext >> popContext)) + <|> + ((parseRules ("LilyPond","lyricrules"))) + <|> + (currentContext >>= \x -> guard (x == ("LilyPond","lyricmode2")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("LilyPond","lyricsto") = + (((pRegExpr regex_'22'28'5c'5c'5b'22'5c'5c'5d'7c'5b'5e'22'5c'5c'5d'29'2b'22 >>= withAttribute StringTok) >>~ pushContext ("LilyPond","lyricsto2")) + <|> + ((pRegExpr regex_'5bA'2dZa'2dz'5d'2b >>= withAttribute NormalTok) >>~ pushContext ("LilyPond","lyricsto2")) + <|> + ((pDetectSpaces >>= withAttribute KeywordTok)) + <|> + ((popContext) >> currentContext >>= parseRules)) + +parseRules ("LilyPond","lyricsto2") = + (((pDetectChar False '{' >>= withAttribute KeywordTok) >>~ pushContext ("LilyPond","lyricsto3")) + <|> + ((pDetectSpaces >>= withAttribute NormalTok)) + <|> + ((popContext >> popContext) >> currentContext >>= parseRules)) + +parseRules ("LilyPond","lyricsto3") = + (((pDetectChar False '}' >>= withAttribute KeywordTok) >>~ (popContext >> popContext >> popContext)) + <|> + ((parseRules ("LilyPond","lyricrules"))) + <|> + (currentContext >>= \x -> guard (x == ("LilyPond","lyricsto3")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("LilyPond","lyricrules") = + (((pDetectChar False '{' >>= withAttribute KeywordTok) >>~ pushContext ("LilyPond","lyricrules")) + <|> + ((pDetectChar False '}' >>= withAttribute KeywordTok) >>~ (popContext)) + <|> + ((pRegExpr regex_'28'5cw'2b'2d'7b2'2c'7d'7c'5cw'2b'5f'7b2'2c'7d'7c'2d'7b2'2c'7d'5cw'2b'7c'5f'7b2'2c'7d'5cw'2b'29 >>= withAttribute ErrorTok)) + <|> + ((pRegExpr regex_'28'5c'5c'28longa'7cbreve'29'5cb'7c'281'7c2'7c4'7c8'7c16'7c32'7c64'7c128'7c256'7c512'7c1024'7c2048'29'28'3f'21'5cd'29'29'28'5cs'2a'5c'2e'2b'29'3f'28'5cs'2a'5c'2a'5cs'2a'5cd'2b'28'2f'5cd'2b'29'3f'29'2a >>= withAttribute DataTypeTok)) + <|> + ((pRegExpr regex_'28'2d'2d'7c'5f'5f'7c'5f'29 >>= withAttribute KeywordTok)) + <|> + ((parseRules ("LilyPond","default"))) + <|> + ((pRegExpr regex_'5cS'2b'5c'7d >>= withAttribute ErrorTok) >>~ (popContext)) + <|> + (currentContext >>= \x -> guard (x == ("LilyPond","lyricrules")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("LilyPond","markup") = + (((pDetectChar False '{' >>= withAttribute KeywordTok) >>~ pushContext ("LilyPond","markup2")) + <|> + ((pDetectSpaces >>= withAttribute NormalTok)) + <|> + ((pRegExpr regex_'5c'5cscore'5cb >>= withAttribute BaseNTok) >>~ pushContext ("LilyPond","notemode")) + <|> + ((pRegExpr regex_'5c'5c'28markup'7cbold'7c'28rounded'2d'29'3fbox'7cbracket'7ccaps'7c'28center'7cgeneral'7cleft'7cright'29'2dalign'7ccircle'7c'28'28center'7cdir'7cleft'7cright'29'2d'29'3fcolumn'7ccombine'7cconcat'7cdynamic'7cfill'2dline'7cfinger'7cfontCaps'7c'28abs'2d'29'3ffontsize'7cfraction'7chalign'7chbracket'7chcenter'2din'7chcenter'7chspace'7chuge'7citalic'7cjustify'7clarger'3f'7cline'7clower'7cmagnify'7cmedium'7cnormal'2dsize'2d'28sub'7csuper'29'7cnormal'2dtext'7cnormalsize'7cnumber'7con'2dthe'2dfly'7coverride'7cpad'2d'28around'7cmarkup'7cto'2dbox'7cx'29'7cpage'2dref'7cpostscript'7cput'2dadjacent'7craise'7croman'7crotate'7csans'7csmall'28er'29'3f'7csmallCaps'7csub'7csuper'7cteeny'7ctext'7ctiny'7ctranslate'28'2dscaled'29'3f'7ctransparent'7ctypewriter'7cunderline'7cupright'7cvcenter'7cwhiteout'7cwith'2d'28color'7cdimensions'7curl'29'7cwordwrap'7c'28markup'7ccolumn'2d'7cjustified'2d'7coverride'2d'7cwordwrap'2d'29lines'7cwordwrap'2d'28string'2d'29'3finternal'29'28'3f'21'5bA'2dZa'2dz'5d'29 >>= withAttribute BaseNTok)) + <|> + ((pRegExpr regex_'5c'5c'28arrow'2dhead'7cbeam'7cchar'7c'28semi'7csesqui'7cdouble'29'3f'28flat'7csharp'29'7cdraw'2d'28circle'7cline'29'7cepsfile'7ceyeglasses'7cfilled'2dbox'7cfret'2ddiagram'28'2dterse'7c'2dverbose'29'3f'7cfromproperty'7charp'2dpedal'7c'28justify'7cwordwrap'29'2d'28field'7cstring'29'7cleft'2dbrace'7clookup'7cmarkalphabet'7cmarkletter'7cmusicglyph'7cnatural'7cnote'2dby'2dnumber'7cnote'7cnull'7cpath'7cright'2dbrace'7csimple'7c'28back'29'3fslashed'2ddigit'7cstencil'7cstrut'7ctied'2dlyric'7ctriangle'7cverbatim'2dfile'29'28'3f'21'5bA'2dZa'2dz'5d'29 >>= withAttribute BaseNTok) >>~ (popContext)) + <|> + ((pDetectChar False '#' >>= withAttribute NormalTok) >>~ pushContext ("LilyPond","scheme")) + <|> + ((pRegExpr regex_'5b'5e'22'5cs'5c'5c'23'25'7b'7d'24'5d'2b >>= withAttribute NormalTok) >>~ (popContext)) + <|> + ((popContext) >> currentContext >>= parseRules)) + +parseRules ("LilyPond","markup2") = + (((pDetectChar False '}' >>= withAttribute KeywordTok) >>~ (popContext >> popContext)) + <|> + ((parseRules ("LilyPond","markuprules"))) + <|> + (currentContext >>= \x -> guard (x == ("LilyPond","markup2")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("LilyPond","markuprules") = + (((pDetectChar False '}' >>= withAttribute KeywordTok) >>~ (popContext)) + <|> + ((pDetectChar False '{' >>= withAttribute KeywordTok) >>~ pushContext ("LilyPond","markuprules")) + <|> + ((pRegExpr regex_'5c'5cscore'5cb >>= withAttribute BaseNTok) >>~ pushContext ("LilyPond","notemode")) + <|> + ((pRegExpr regex_'5c'5c'28arrow'2dhead'7cbeam'7cchar'7c'28semi'7csesqui'7cdouble'29'3f'28flat'7csharp'29'7cdraw'2d'28circle'7cline'29'7cepsfile'7ceyeglasses'7cfilled'2dbox'7cfret'2ddiagram'28'2dterse'7c'2dverbose'29'3f'7cfromproperty'7charp'2dpedal'7c'28justify'7cwordwrap'29'2d'28field'7cstring'29'7cleft'2dbrace'7clookup'7cmarkalphabet'7cmarkletter'7cmusicglyph'7cnatural'7cnote'2dby'2dnumber'7cnote'7cnull'7cpath'7cright'2dbrace'7csimple'7c'28back'29'3fslashed'2ddigit'7cstencil'7cstrut'7ctied'2dlyric'7ctriangle'7cverbatim'2dfile'7cmarkup'7cbold'7c'28rounded'2d'29'3fbox'7cbracket'7ccaps'7c'28center'7cgeneral'7cleft'7cright'29'2dalign'7ccircle'7c'28'28center'7cdir'7cleft'7cright'29'2d'29'3fcolumn'7ccombine'7cconcat'7cdynamic'7cfill'2dline'7cfinger'7cfontCaps'7c'28abs'2d'29'3ffontsize'7cfraction'7chalign'7chbracket'7chcenter'2din'7chcenter'7chspace'7chuge'7citalic'7cjustify'7clarger'3f'7cline'7clower'7cmagnify'7cmedium'7cnormal'2dsize'2d'28sub'7csuper'29'7cnormal'2dtext'7cnormalsize'7cnumber'7con'2dthe'2dfly'7coverride'7cpad'2d'28around'7cmarkup'7cto'2dbox'7cx'29'7cpage'2dref'7cpostscript'7cput'2dadjacent'7craise'7croman'7crotate'7csans'7csmall'28er'29'3f'7csmallCaps'7csub'7csuper'7cteeny'7ctext'7ctiny'7ctranslate'28'2dscaled'29'3f'7ctransparent'7ctypewriter'7cunderline'7cupright'7cvcenter'7cwhiteout'7cwith'2d'28color'7cdimensions'7curl'29'7cwordwrap'7c'28markup'7ccolumn'2d'7cjustified'2d'7coverride'2d'7cwordwrap'2d'29lines'7cwordwrap'2d'28string'2d'29'3finternal'29'28'3f'21'5bA'2dZa'2dz'5d'29 >>= withAttribute BaseNTok)) + <|> + ((pRegExpr regex_'5c'5c'28bigger'7ch'3fcenter'29'28'3f'21'5bA'2dZa'2dz'5d'29 >>= withAttribute BaseNTok)) + <|> + ((pRegExpr regex_'5c'5c'5bA'2dZa'2dz'5d'2b'28'2d'5bA'2dZa'2dz'5d'2b'29'2a >>= withAttribute FunctionTok)) + <|> + ((parseRules ("LilyPond","basic"))) + <|> + (currentContext >>= \x -> guard (x == ("LilyPond","markuprules")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("LilyPond","section") = + (((pDetectChar False '{' >>= withAttribute KeywordTok) >>~ pushContext ("LilyPond","section2")) + <|> + ((pDetectSpaces >>= withAttribute KeywordTok)) + <|> + ((popContext) >> currentContext >>= parseRules)) + +parseRules ("LilyPond","section2") = + (((pDetectChar False '}' >>= withAttribute KeywordTok) >>~ (popContext >> popContext)) + <|> + ((parseRules ("LilyPond","sectionrules"))) + <|> + (currentContext >>= \x -> guard (x == ("LilyPond","section2")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("LilyPond","sectionrules") = + (((pDetectChar False '}' >>= withAttribute KeywordTok) >>~ (popContext)) + <|> + ((pDetectChar False '{' >>= withAttribute KeywordTok) >>~ pushContext ("LilyPond","sectionrules")) + <|> + ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\'_0123456789" list_contexts >>= withAttribute DataTypeTok)) + <|> + ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\'_0123456789" list_deprecatedcontexts >>= withAttribute DataTypeTok)) + <|> + ((pRegExpr regex_'28'22'3f'29'5cb'28'28Accidental'7cAmbitus'7cArpeggio'7cAuto'5fbeam'7cAxis'5fgroup'7cBalloon'7cBar'7cBar'5fnumber'7cBeam'7cBend'7cBreak'5falign'7cBreathing'5fsign'7cChord'5fname'7cChord'5ftremolo'7cClef'7cCluster'5fspanner'7cCollision'7cCompletion'5fheads'7cCustos'7cDefault'5fbar'5fline'7cDot'5fcolumn'7cDots'7cDrum'5fnotes'7cDynami'5falign'7cDynamic'7cEpisema'7cExtender'7cFigured'5fbass'7cFigured'5fbass'5fposition'7cFingering'7cFont'5fsize'7cForbid'5fline'5fbreak'7cFretboard'7cGlissando'7cGrace'5fbeam'7cGrace'7cGrace'5fspacing'7cGrid'5fline'5fspan'7cGrid'5fpoint'7cGrob'5fpq'7cHara'5fkiri'7cHorizontal'5fbracket'29'5fengraver'29'5cb'5c1 >>= withAttribute DataTypeTok)) + <|> + ((pRegExpr regex_'28'22'3f'29'5cb'28'28Hyphen'7cInstrument'5fname'7cInstrument'5fswitch'7cKey'7cLaissez'5fvibrer'7cLedger'5fline'7cLigature'5fbracket'7cLyric'7cMark'7cMeasure'5fgrouping'7cMelody'7cMensural'5fligature'7cMetronome'5fmark'7cMulti'5fmeasure'5frest'7cNew'5fdynamic'7cNew'5ffingering'7cNote'5fhead'5fline'7cNote'5fheads'7cNote'5fname'7cNote'5fspacing'7cOttava'5fspanner'7cOutput'5fproperty'7cPage'5fturn'7cPaper'5fcolumn'7cParenthesis'7cPart'5fcombine'7cPercent'5frepeat'7cPhrasing'5fslur'7cPiano'5fpedal'5falign'7cPiano'5fpedal'7cPitch'5fsquash'7cPitched'5ftrill'7cRepeat'5facknowledge'7cRepeat'5ftie'7cRest'5fcollision'7cRest'7cRhythmic'5fcolumn'7cScheme'7cScript'5fcolumn'7cScript'7cScript'5frow'29'5fengraver'29'5cb'5c1 >>= withAttribute DataTypeTok)) + <|> + ((pRegExpr regex_'28'22'3f'29'5cb'28'28Separating'5fline'5fgroup'7cSlash'5frepeat'7cSlur'7cSpacing'7cSpan'5farpeggio'7cSpan'5fbar'7cSpanner'5fbreak'5fforbid'7cStaff'5fcollecting'7cStaff'5fsymbol'7cStanza'5fnumber'5falign'7cStanza'5fnumber'7cStem'7cString'5fnumber'7cSwallow'7cSystem'5fstart'5fdelimiter'7cTab'5fharmonic'7cTab'5fnote'5fheads'7cTab'5fstaff'5fsymbol'7cText'7cText'5fspanner'7cTie'7cTime'5fsignature'7cTrill'5fspanner'7cTuplet'7cTweak'7cVaticana'5fligature'7cVertical'5falign'7cVertically'5fspaced'5fcontexts'7cVolta'29'5fengraver'29'5cb'5c1 >>= withAttribute DataTypeTok)) + <|> + ((pRegExpr regex_'28'22'3f'29'5cb'28'28Beam'7cControl'5ftrack'7cDrum'5fnote'7cDynamic'7cKey'7cLyric'7cNote'7cPiano'5fpedal'7cSlur'7cStaff'7cSwallow'7cTempo'7cTie'7cTime'5fsignature'29'5fperformer'29'5cb'5c1 >>= withAttribute DataTypeTok)) + <|> + ((pRegExpr regex_'28'22'3f'29'5cb'28'28Note'5fswallow'7cRest'5fswallow'7cSkip'5fevent'5fswallow'7cTiming'29'5ftranslator'29'5cb'5c1 >>= withAttribute DataTypeTok)) + <|> + ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\'_0123456789" list_layoutobjects >>= withAttribute DataTypeTok)) + <|> + ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\'_0123456789" list_properties >>= withAttribute DataTypeTok)) + <|> + ((pRegExpr regex_'5cb'28dedication'7c'28sub'29'7b'2c2'7dtitle'7cpoet'7ccomposer'7cmeter'7copus'7carranger'7cinstrument'7cpiece'7cbreakbefore'7ccopyright'7ctagline'7cmutopia'28title'7ccomposer'7cpoet'7copus'7cinstrument'29'7cdate'7centeredby'7csource'7cstyle'7cmaintainer'28Email'7cWeb'29'3f'7cmoreInfo'7clastupdated'7ctexidoc'7cfooter'7c'28top'7cbottom'7cleft'7cright'29'2dmargin'7c'28foot'7chead'29'2dseparation'7cindent'7cshort'2dindent'7cpaper'2d'28height'7cwidth'29'7chorizontal'2dshift'7cline'2dwidth'7c'28inner'7couter'29'2dmargin'7ctwo'2dsided'7cbinding'2doffset'7c'28after'7cbefore'7cbetween'29'2dtitle'2dspace'7cbetween'2dsystem'2d'28space'7cpadding'29'7cpage'2dtop'2dspace'7cpage'2dbreaking'2dbetween'2dsystem'2dpadding'7c'28after'7cbefore'7cbetween'29'2dtitle'2dspacing'7cbetween'2d'28scores'2d'29'3fsystem'2dspacing'7cbottom'2dsystem'2dspacing'7ctop'2dtitle'2dspacing'7ctop'2dsystem'2dspacing'7cpage'2dbreaking'2dbetween'2dsystem'2dspacing'7csystem'2dcount'7c'28min'2d'7cmax'2d'29'3fsystems'2dper'2dpage'7cannotate'2dspacing'7cauto'2dfirst'2dpage'2dnumber'7cblank'2d'28last'2d'29'3fpage'2dforce'7cfirst'2dpage'2dnumber'7cpage'2dcount'7cpage'2dlimit'2dinter'2dsystem'2dspace'7cpage'2dlimit'2dinter'2dsystem'2dspace'2dfactor'7cpage'2dspacing'2dweight'7cprint'2dall'2dheaders'7cprint'2dfirst'2dpage'2dnumber'7cprint'2dpage'2dnumber'7cragged'2d'28bottom'7cright'29'7cragged'2dlast'28'2dbottom'29'3f'7csystem'2dseparator'2dmarkup'7cforce'2dassignment'7cinput'2dencoding'7coutput'2dscale'7c'28'28even'7codd'29'28Footer'7cHeader'29'7c'28book'7cscore'7ctoc'29Title'7ctocItem'29Markup'7csystem'2dcount'7c'28short'2d'29'3findent'29'5cb >>= withAttribute DataTypeTok)) + <|> + ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\'_0123456789" list_deprecatedproperties >>= withAttribute DataTypeTok)) + <|> + ((parseRules ("LilyPond","default"))) + <|> + (currentContext >>= \x -> guard (x == ("LilyPond","sectionrules")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("LilyPond","context") = + (((pDetectSpaces >>= withAttribute NormalTok)) + <|> + ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\'_0123456789" list_contexts >>= withAttribute DataTypeTok) >>~ pushContext ("LilyPond","context2")) + <|> + ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\'_0123456789" list_deprecatedcontexts >>= withAttribute DataTypeTok) >>~ pushContext ("LilyPond","context2")) + <|> + ((pRegExpr regex_'5bA'2dZa'2dz'5d'2b >>= withAttribute FunctionTok) >>~ pushContext ("LilyPond","context2")) + <|> + ((pDetectChar False '{' >>= withAttribute KeywordTok) >>~ pushContext ("LilyPond","section2")) + <|> + ((popContext) >> currentContext >>= parseRules)) + +parseRules ("LilyPond","context2") = + (((pDetectSpaces >>= withAttribute NormalTok)) + <|> + ((pRegExpr regex_'3d'28'5cs'2a'5bA'2dZa'2dz'5d'2b'29'3f >>= withAttribute NormalTok) >>~ (popContext >> popContext)) + <|> + ((popContext >> popContext) >> currentContext >>= parseRules)) + +parseRules ("LilyPond","set") = + (((pDetectSpaces >>= withAttribute NormalTok)) + <|> + ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\'_0123456789" list_contexts >>= withAttribute DataTypeTok)) + <|> + ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\'_0123456789" list_deprecatedcontexts >>= withAttribute DataTypeTok)) + <|> + ((pDetectChar False '.' >>= withAttribute NormalTok)) + <|> + ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\'_0123456789" list_properties >>= withAttribute DataTypeTok) >>~ (popContext)) + <|> + ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\'_0123456789" list_deprecatedproperties >>= withAttribute DataTypeTok) >>~ (popContext)) + <|> + ((pRegExpr regex_'5bA'2dZa'2dz'5d'2b >>= withAttribute FunctionTok) >>~ (popContext)) + <|> + ((popContext) >> currentContext >>= parseRules)) + +parseRules ("LilyPond","override") = + (((pDetectSpaces >>= withAttribute NormalTok)) + <|> + ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\'_0123456789" list_contexts >>= withAttribute DataTypeTok)) + <|> + ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\'_0123456789" list_deprecatedcontexts >>= withAttribute DataTypeTok)) + <|> + ((pDetectChar False '.' >>= withAttribute NormalTok)) + <|> + ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\'_0123456789" list_layoutobjects >>= withAttribute DataTypeTok) >>~ (popContext)) + <|> + ((pRegExpr regex_'5bA'2dZa'2dz'5d'2b'28'3f'3d'5cs'2a'5c'2e'29 >>= withAttribute FunctionTok)) + <|> + ((pRegExpr regex_'5bA'2dZa'2dz'5d'2b >>= withAttribute FunctionTok) >>~ (popContext)) + <|> + ((popContext) >> currentContext >>= parseRules)) + +parseRules ("LilyPond","tempo") = + (((pRegExpr regex_'5c'5cmarkup'28lines'29'3f'28'3f'21'5bA'2dZa'2dz'5d'29 >>= withAttribute BaseNTok) >>~ pushContext ("LilyPond","markup")) + <|> + ((pRegExpr regex_'5cd'2b'5c'2e'2a'5cs'2a'3d'5cs'2a'5cd'2b >>= withAttribute FunctionTok) >>~ (popContext)) + <|> + ((pDetectSpaces >>= withAttribute NormalTok)) + <|> + ((parseRules ("LilyPond","basic"))) + <|> + ((popContext) >> currentContext >>= parseRules)) + +parseRules ("Alerts", _) = Text.Highlighting.Kate.Syntax.Alert.parseExpression Nothing + +parseRules x = parseRules ("LilyPond","lilypond") <|> fail ("Unknown context" ++ show x) diff --git a/Text/Highlighting/Kate/Syntax/LiterateHaskell.hs b/Text/Highlighting/Kate/Syntax/LiterateHaskell.hs --- a/Text/Highlighting/Kate/Syntax/LiterateHaskell.hs +++ b/Text/Highlighting/Kate/Syntax/LiterateHaskell.hs @@ -1,5 +1,5 @@ {- This module was generated from data in the Kate syntax - highlighting file literate-haskell.xml, version 2.0.2, by Nicolas Wu (zenzike@gmail.com) -} + highlighting file literate-haskell.xml, version 2.1, by Nicolas Wu (zenzike@gmail.com) -} module Text.Highlighting.Kate.Syntax.LiterateHaskell (highlight, parseExpression, syntaxName, syntaxExtensions) diff --git a/Text/Highlighting/Kate/Syntax/M4.hs b/Text/Highlighting/Kate/Syntax/M4.hs new file mode 100644 --- /dev/null +++ b/Text/Highlighting/Kate/Syntax/M4.hs @@ -0,0 +1,103 @@ +{- This module was generated from data in the Kate syntax + highlighting file m4.xml, version 1.1, by Jaak Ristioja -} + +module Text.Highlighting.Kate.Syntax.M4 + (highlight, parseExpression, syntaxName, syntaxExtensions) +where +import Text.Highlighting.Kate.Types +import Text.Highlighting.Kate.Common +import Text.ParserCombinators.Parsec hiding (State) +import Control.Monad.State +import Data.Char (isSpace) +import qualified Data.Set as Set + +-- | Full name of language. +syntaxName :: String +syntaxName = "GNU M4" + +-- | Filename extensions for this language. +syntaxExtensions :: String +syntaxExtensions = "*.m4;" + +-- | Highlight source code using this syntax definition. +highlight :: String -> [SourceLine] +highlight input = evalState (mapM parseSourceLine $ lines input) startingState + +parseSourceLine :: String -> State SyntaxState SourceLine +parseSourceLine = mkParseSourceLine (parseExpression Nothing) + +-- | Parse an expression using appropriate local context. +parseExpression :: Maybe (String,String) + -> KateParser Token +parseExpression mbcontext = do + (lang,cont) <- maybe currentContext return mbcontext + result <- parseRules (lang,cont) + optional $ do eof + updateState $ \st -> st{ synStPrevChar = '\n' } + pEndLine + return result + +startingState = SyntaxState {synStContexts = [("GNU M4","Normal Text")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []} + +pEndLine = do + updateState $ \st -> st{ synStPrevNonspace = False } + context <- currentContext + contexts <- synStContexts `fmap` getState + if length contexts >= 2 + then case context of + ("GNU M4","Normal Text") -> return () + ("GNU M4","inparenthesis") -> return () + _ -> return () + else return () + +withAttribute attr txt = do + when (null txt) $ fail "Parser matched no text" + updateState $ \st -> st { synStPrevChar = last txt + , synStPrevNonspace = synStPrevNonspace st || not (all isSpace txt) } + return (attr, txt) + +list_optbuiltins = Set.fromList $ words $ "__gnu__ __os2__ os2 __unix__ unix __windows__ windows" +list_m4'5foptbuiltins = Set.fromList $ words $ "m4___gnu__ m4___os2__ m4_os2 m4___unix__ m4_unix m4___windows__ m4_windows" +list_builtins = Set.fromList $ words $ "__file__ __line__ __program__ builtin changecom changequote changeword debugfile debugmode decr define defn divert divnum dnl dumpdef errprint esyscmd eval format ifdef ifelse include incr index indir len m4exit m4wrap maketemp mkstemp patsubst popdef pushdef regexp shift sinclude substr syscmd sysval traceon traceoff translit undefine undivert" +list_m4'5fbuiltins = Set.fromList $ words $ "m4___file__ m4___line__ m4___program__ m4_builtin m4_changecom m4_changequote m4_changeword m4_debugfile m4_debugmode m4_decr m4_define m4_defn m4_divert m4_divnum m4_dnl m4_dumpdef m4_errprint m4_esyscmd m4_eval m4_format m4_ifdef m4_ifelse m4_include m4_incr m4_index m4_indir m4_len m4_m4exit m4_m4wrap m4_maketemp m4_mkstemp m4_patsubst m4_popdef m4_pushdef m4_regexp m4_shift m4_sinclude m4_substr m4_syscmd m4_sysval m4_traceon m4_traceoff m4_translit m4_undefine m4_undivert" + +regex_'5ba'2dzA'2dZ'5f'5d'5cw'2b = compileRegex True "[a-zA-Z_]\\w+" +regex_'5c'24'28'5b1'2d9'5d'5cd'2a'7c0'7c'5c'23'7c'5c'2a'7c'5c'40'7c'5c'7b'28'5b1'2d9'5d'5cd'2a'7c0'29'5c'7d'29 = compileRegex True "\\$([1-9]\\d*|0|\\#|\\*|\\@|\\{([1-9]\\d*|0)\\})" +regex_'28'5b1'2d9'5d'5cd'2a'7c0'7c0x'5b0'2d9abcdefABCDEF'5d'2b'29 = compileRegex True "([1-9]\\d*|0|0x[0-9abcdefABCDEF]+)" +regex_'23'2e'2a'24 = compileRegex True "#.*$" +regex_'5b'2b'2a'2f'25'5c'7c'3d'5c'21'3c'3e'21'5e'26'7e'2d'5d = compileRegex True "[+*/%\\|=\\!<>!^&~-]" + +parseRules ("GNU M4","Normal Text") = + (((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_builtins >>= withAttribute KeywordTok)) + <|> + ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_m4'5fbuiltins >>= withAttribute KeywordTok)) + <|> + ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_optbuiltins >>= withAttribute KeywordTok)) + <|> + ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_m4'5foptbuiltins >>= withAttribute KeywordTok)) + <|> + ((pRegExpr regex_'5ba'2dzA'2dZ'5f'5d'5cw'2b >>= withAttribute NormalTok)) + <|> + ((pRegExpr regex_'5c'24'28'5b1'2d9'5d'5cd'2a'7c0'7c'5c'23'7c'5c'2a'7c'5c'40'7c'5c'7b'28'5b1'2d9'5d'5cd'2a'7c0'29'5c'7d'29 >>= withAttribute CharTok)) + <|> + ((pRegExpr regex_'28'5b1'2d9'5d'5cd'2a'7c0'7c0x'5b0'2d9abcdefABCDEF'5d'2b'29 >>= withAttribute DecValTok)) + <|> + ((pRegExpr regex_'23'2e'2a'24 >>= withAttribute CommentTok)) + <|> + ((pDetectChar False ',' >>= withAttribute CharTok)) + <|> + ((pDetectChar False '(' >>= withAttribute CharTok) >>~ pushContext ("GNU M4","inparenthesis")) + <|> + ((pDetectChar False ')' >>= withAttribute CharTok) >>~ (popContext)) + <|> + ((pRegExpr regex_'5b'2b'2a'2f'25'5c'7c'3d'5c'21'3c'3e'21'5e'26'7e'2d'5d >>= withAttribute CharTok)) + <|> + (currentContext >>= \x -> guard (x == ("GNU M4","Normal Text")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("GNU M4","inparenthesis") = + (((parseRules ("GNU M4","Normal Text"))) + <|> + (currentContext >>= \x -> guard (x == ("GNU M4","inparenthesis")) >> pDefault >>= withAttribute NormalTok)) + + +parseRules x = parseRules ("GNU M4","Normal Text") <|> fail ("Unknown context" ++ show x) diff --git a/Text/Highlighting/Kate/Syntax/Markdown.hs b/Text/Highlighting/Kate/Syntax/Markdown.hs --- a/Text/Highlighting/Kate/Syntax/Markdown.hs +++ b/Text/Highlighting/Kate/Syntax/Markdown.hs @@ -1,5 +1,5 @@ {- This module was generated from data in the Kate syntax - highlighting file markdown.xml, version 1.3, by Darrin Yeager, Claes Holmerson -} + highlighting file markdown.xml, version 1.4, by Darrin Yeager, Claes Holmerson -} module Text.Highlighting.Kate.Syntax.Markdown (highlight, parseExpression, syntaxName, syntaxExtensions) @@ -45,9 +45,9 @@ if length contexts >= 2 then case context of ("Markdown","Normal Text") -> return () - ("Markdown","blockquote") -> (popContext) >> pEndLine - ("Markdown","bullet") -> (popContext) >> pEndLine - ("Markdown","numlist") -> (popContext) >> pEndLine + ("Markdown","blockquote") -> return () + ("Markdown","bullet") -> return () + ("Markdown","numlist") -> return () ("Markdown","comment") -> return () ("Markdown","inc") -> return () _ -> return () diff --git a/Text/Highlighting/Kate/Syntax/Mathematica.hs b/Text/Highlighting/Kate/Syntax/Mathematica.hs new file mode 100644 --- /dev/null +++ b/Text/Highlighting/Kate/Syntax/Mathematica.hs @@ -0,0 +1,82 @@ +{- This module was generated from data in the Kate syntax + highlighting file mathematica.xml, version 8.1, by Sven Brauch (svenbrauch@gmail.com) -} + +module Text.Highlighting.Kate.Syntax.Mathematica + (highlight, parseExpression, syntaxName, syntaxExtensions) +where +import Text.Highlighting.Kate.Types +import Text.Highlighting.Kate.Common +import Text.ParserCombinators.Parsec hiding (State) +import Control.Monad.State +import Data.Char (isSpace) +import qualified Data.Set as Set + +-- | Full name of language. +syntaxName :: String +syntaxName = "Mathematica" + +-- | Filename extensions for this language. +syntaxExtensions :: String +syntaxExtensions = "*.nb" + +-- | Highlight source code using this syntax definition. +highlight :: String -> [SourceLine] +highlight input = evalState (mapM parseSourceLine $ lines input) startingState + +parseSourceLine :: String -> State SyntaxState SourceLine +parseSourceLine = mkParseSourceLine (parseExpression Nothing) + +-- | Parse an expression using appropriate local context. +parseExpression :: Maybe (String,String) + -> KateParser Token +parseExpression mbcontext = do + (lang,cont) <- maybe currentContext return mbcontext + result <- parseRules (lang,cont) + optional $ do eof + updateState $ \st -> st{ synStPrevChar = '\n' } + pEndLine + return result + +startingState = SyntaxState {synStContexts = [("Mathematica","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []} + +pEndLine = do + updateState $ \st -> st{ synStPrevNonspace = False } + context <- currentContext + contexts <- synStContexts `fmap` getState + if length contexts >= 2 + then case context of + ("Mathematica","Normal") -> return () + _ -> return () + else return () + +withAttribute attr txt = do + when (null txt) $ fail "Parser matched no text" + updateState $ \st -> st { synStPrevChar = last txt + , synStPrevNonspace = synStPrevNonspace st || not (all isSpace txt) } + return (attr, txt) + +list_functions = Set.fromList $ words $ "a abeliangroup all arcsinh abort allowgroupclose arctan abortkernels allowreversegroupclose arctanh abortprotect alphachannel arg abs alternatinggroup argmax absolutecurrentvalue alternativehypothesis argmin absolutedashing alternatives arithmeticgeometricmean absolutefilename anchoredsearch array absoluteoptions and arraycomponents absolutepointsize andersondarlingtest arraydepth absolutethickness angerj arrayflatten absolutetime anglebracket arraypad absolutetiming animate arrayplot accountingform animationdirection arrayq accumulate animationdisplaytime arrayrules accuracy animationrate arrow accuracygoal animationrepetitions arrowheads actionmenu animationrunning aspectratio activestyle animator assert acyclicgraphq annotation assuming addto annuity assumptions adjacencygraph annuitydue astronomicaldata adjacencymatrix antialiasing asynchronous adjustmentbox apart atomq affinetransform apartsquarefree attributes airyai appearance augmentedsymmetricpolynomial airyaiprime appearanceelements autoaction airyaizero appellf1 autoindent airybi append autoitalicwords airybiprime appendto automatic airybizero apply automultiplicationsymbol algebraicintegerq arccos autorunsequencing algebraicnumber arccosh autoscroll algebraicnumberdenominator arccot autospacing algebraicnumbernorm arccoth axes algebraicnumberpolynomial arccsc axesedge algebraicnumbertrace arccsch axeslabel algebraics arcsec axesorigin algebraicunitq arcsech axesstyle alignment arcsin axis alignmentpoint arcsindistribution b babymonstergroupb betaregularized booleangraph back betweennesscentrality booleanmaxterms background beziercurve booleanminimize backslash bezierfunction booleanminterms backward bilateralfilter booleans band binarize booleantable barabasialbertgraphdistribution binaryformat booleanvariables barchart binaryimageq borderdimensions barchart3d binaryread boreltannerdistribution barnesg binaryreadlist bottom barorigin binarywrite bottomhattransform barspacing bincounts boundarystyle baseform binlists boxdata baseline binomial boxed baselineposition binomialdistribution boxmatrix basestyle binormaldistribution boxratios batesdistribution biorthogonalsplinewavelet boxstyle battlelemariewavelet bipartitegraphq boxwhiskerchart because birnbaumsaundersdistribution bracketingbar beckmanndistribution bitand braycurtisdistance beep bitclear breadthfirstscan begin bitget break begindialogpacket bitlength brown beginpackage bitnot brownforsythetest bellb bitor bsplinebasis belly bitset bsplinecurve benforddistribution bitshiftleft bsplinefunction beninidistribution bitshiftright bsplinesurface benktandergibratdistribution bitxor bubblechart benktanderweibulldistribution black bubblechart3d bernoullib blank bubblescale bernoullidistribution blanknullsequence bubblesizes bernoulligraphdistribution blanksequence butterflygraph bernsteinbasis blend button besseli block buttonbar besselj blockrandom buttonbox besseljzero blue buttondata besselk blur buttonframe bessely bodeplot buttonfunction besselyzero bold buttonminheight beta bookmarks buttonnotebook betabinomialdistribution boole buttonsource betadistribution booleanconvert byte betanegativebinomialdistribution booleancountingfunction bytecount betaprimedistribution booleanfunction byteordering c c citydata continuousaction callpacket clear continuoustimemodelq canberradistance clearall continuouswaveletdata cancel clearattributes continuouswavelettransform cancelbutton clearsystemcache contourdetect candlestickchart clebschgordan contourlabels cap clickpane contourplot capform clip contourplot3d capitaldifferentiald clippingstyle contours carmichaellambda clock contourshading cases close contourstyle cashflow closekernels contraharmonicmean casoratian closenesscentrality control catalan closing controlactive catalannumber clusteringcomponents controllabilitygramian catch cmykcolor controllabilitymatrix cauchydistribution coefficient controllabledecomposition cayleygraph coefficientarrays controllablemodelq cdf coefficientlist controllerinformation cdfwavelet coefficientrules controllerlinking ceiling coifletwavelet controllermanipulate cell collect controllermethod cellautooverwrite colon controllerpath cellbaseline colorcombine controllerstate cellchangetimes colorconvert controlplacement cellcontext colordata controlsrendering celldingbat colordatafunction controltype celldynamicexpression colorfunction convergents celleditduplicate colorfunctionscaling conversionrules cellepilog colorize convolve cellevaluationduplicate colornegate conwaygroupco1 cellevaluationfunction colorquantize conwaygroupco2 celleventactions colorrules conwaygroupco3 cellframe colorseparate coordinatestooloptions cellframemargins colorsetter coprimeq cellgroup colorslider coproduct cellgroupdata colorspace copuladistribution cellgrouping column copyable celllabel columnalignments copydirectory celllabelautodelete columnlines copyfile cellmargins columnsequal copytoclipboard cellopen columnspacings cornerfilter cellprint columnwidths cornerneighbors cellprolog commonest correlation celltags commonestfilter correlationdistance cellularautomaton compilationoptions cos censoreddistribution compilationtarget cosh censoring compile coshintegral center compiled cosinedistance centerdot compiledfunction cosintegral centralmoment complement cot centralmomentgeneratingfunction completegraph coth cform completegraphq count champernownenumber completekarytree countroots chanvesebinarize complex countrydata character complexes covariance characterencoding complexexpand covarianceestimatorfunction characteristicfunction complexinfinity cramervonmisestest characteristicpolynomial complexityfunction createarchive characterrange componentmeasurements createdialog characters composelist createdirectory chartbasestyle composeseries createdocument chartelementfunction composition createintermediatedirectories chartelements compoundexpression createpalette chartlabels compress createscheduledtask chartlayout condition createwindow chartlegends conditionalexpression criticalsection chartstyle conditioned cross chebyshevt cone crossingdetect chebyshevu confidencelevel crossmatrix check congruent csc checkabort conjugate csch checkbox conjugatetranspose cubics checkboxbar conjunction cuboid chemicaldata connectedcomponents cumulant chessboarddistance connectedgraphq cumulantgeneratingfunction chidistribution conovertest cup chineseremainder constant cupcap chisquaredistribution constantarray currentimage choicebuttons constants currentvalue choicedialog contentpadding curvatureflowfilter choleskydecomposition contentselectable curveclosed chop contentsize cyan circle context cyclegraph circledot contexts cycles circleminus contexttofilename cyclicgroup circleplus continue cyclotomic circletimes continuedfraction cylinder circulantgraph continuedfractionk cylindricaldecomposition d d depthfirstscan diskmatrix dagumdistribution derivative dispatch dameraulevenshteindistance derivativefilter dispersionestimatorfunction darker designmatrix displayallsteps dashed det displayendpacket dashing dgaussianwavelet displayform datadistribution diagonal displayfunction datarange diagonalmatrix displaypacket datareversed dialog distancefunction datedifference dialoginput distancetransform datefunction dialognotebook distribute datelist dialogprolog distributed datelistlogplot dialogreturn distributedcontexts datelistplot dialogsymbols distributedefinitions datepattern diamond distributionchart dateplus diamondmatrix distributionfittest datestring dicedissimilarity distributionparameterassumptions dateticksformat dictionarylookup distributionparameterq daubechieswavelet differencedelta divide davisdistribution differenceroot divideby dawsonf differencerootreduce dividers debruijngraph differences divisible declarepackage differentiald divisors decompose differentialroot divisorsigma decrement differentialrootreduce divisorsum dedekindeta digitblock dmslist default digitcharacter dmsstring defaultaxesstyle digitcount do defaultbasestyle digitq dockedcells defaultboxstyle dihedralgroup documentnotebook defaultbutton dilation dot defaultduplicatecellstyle dimensions dotdashed defaultduration diraccomb dotequal defaultelement diracdelta dotted defaultfacegridsstyle directededge doublebracketingbar defaultfieldhintstyle directededges doubledownarrow defaultframestyle directedgraph doubleleftarrow defaultframeticksstyle directedgraphq doubleleftrightarrow defaultgridlinesstyle directedinfinity doublelongleftarrow defaultlabelstyle direction doublelongleftrightarrow defaultmenustyle directive doublelongrightarrow defaultnewcellstyle directory doublerightarrow defaultoptions directoryname doubleuparrow defaultticksstyle directoryq doubleupdownarrow defer directorystack doubleverticalbar definition dirichletcharacter downarrow degree dirichletconvolve downarrowbar degreecentrality dirichletdistribution downarrowuparrow degreegraphdistribution dirichletl downleftrightvector deinitialization dirichlettransform downleftteevector del discreteconvolve downleftvector deletable discretedelta downleftvectorbar delete discreteindicator downrightteevector deletebordercomponents discretelqestimatorgains downrightvector deletecases discretelqregulatorgains downrightvectorbar deletecontents discretelyapunovsolve downteearrow deletedirectory discreteplot downvalues deleteduplicates discreteplot3d draganddrop deletefile discreteratio drop deletesmallcomponents discretericcatisolve dsolve delimiter discreteshift dt delimiterflashtime discretetimemodelq dualsystemsmodel denominator discreteuniformdistribution dumpsave densityhistogram discretewaveletdata dynamic densityplot discretewaveletpackettransform dynamicevaluationtimeout dependentvariables discretewavelettransform dynamicmodule deploy discriminant dynamicmodulevalues deployed disjunction dynamicsetting depth disk dynamicwrapper e e end exactnumberq edgeadd enddialogpacket exampledata edgecount endoffile except edgecoverq endofline excludedforms edgedelete endofstring excludepods edgedetect endpackage exclusions edgeform engineeringform exclusionsstyle edgeindex enterexpressionpacket exists edgelabeling entertextpacket exit edgelabels entropy exp edgelist entropyfilter expand edgeq environment expandall edgerenderingfunction epilog expanddenominator edgerules equal expandfilename edgeshapefunction equaltilde expandnumerator edgestyle equilibrium expectation edgeweight equivalent expgammadistribution editable erf expintegrale editdistance erfc expintegralei effectiveinterest erfi exponent eigensystem erlangdistribution exponentfunction eigenvalues erosion exponentialdistribution eigenvectorcentrality errorbox exponentialfamily eigenvectors estimateddistribution exponentialgeneratingfunction element estimatorgains exponentialmovingaverage elementdata estimatorregulator exponentialpowerdistribution eliminate euclideandistance exponentstep elliptice eulere export ellipticexp eulergamma exportstring ellipticexpprime euleriangraphq expression ellipticf eulerphi expressioncell elliptick evaluatable exptotrig ellipticlog evaluate extendedgcd ellipticnomeq evaluatepacket extension ellipticpi evaluationelements extentelementfunction elliptictheta evaluationmonitor extentmarkers ellipticthetaprime evaluationnotebook extentsize emitsound evaluationobject extract empiricaldistribution evaluator extractarchive emptygraphq evenq extremevaluedistribution enabled eventhandler encode eventlabels f faceform findfit formbox facegrids findgeneratingfunction fortranform facegridsstyle findgeolocation forward factor findgeometrictransform forwardbackward factorial findgraphisomorphism fourier factorial2 findhamiltoniancycle fouriercoefficient factorialmoment findindependentedgeset fouriercoscoefficient factorialmomentgeneratingfunction findindependentvertexset fouriercosseries factorialpower findinstance fouriercostransform factorinteger findintegernullvector fourierdct factorlist findlibrary fourierdst factorsquarefree findlinearrecurrence fourierparameters factorsquarefreelist findlist fouriersequencetransform factorterms findmaximum fourierseries factortermslist findmaxvalue fouriersincoefficient false findminimum fouriersinseries feedbacktype findminvalue fouriersintransform fibonacci findpermutation fouriertransform fieldhint findroot fouriertrigseries fieldhintstyle findsequencefunction fractionalpart fieldmasked findshortestpath fractionbox fieldsize findshortesttour frame filebasename findthreshold framebox filebytecount findvertexcover framed filedate finishdynamic framelabel fileexistsq finiteabeliangroupcount framemargins fileextension finitegroupcount framestyle fileformat finitegroupdata frameticks filehash first frameticksstyle filenamedepth fischergroupfi22 fratiodistribution filenamedrop fischergroupfi23 frechetdistribution filenamejoin fischergroupfi24prime freeq filenames fisherhypergeometricdistribution fresnelc filenamesetter fisherratiotest fresnels filenamesplit fisherzdistribution frobeniusnumber filenametake fit frobeniussolve fileprint fittedmodel fromcharactercode filetype fixedpoint fromcoefficientrules filledcurve fixedpointlist fromcontinuedfraction filling flat fromdigits fillingstyle flatten fromdms fillingtransform flattenat front filterrules flipview frontenddynamicexpression financialbond floor frontendeventactions financialdata fold frontendexecute financialderivative foldlist frontendtoken financialindicator fontcolor frontendtokenexecute find fontfamily full findargmax fontsize fulldefinition findargmin fontslant fullform findclique fontsubstitutions fullgraphics findclusters fonttracking fullsimplify findcurvepath fontvariations function finddistributionparameters fontweight functionexpand finddivisions for functioninterpolation findedgecover forall functionspace findeuleriancycle format findfile formattype g gaborwavelet geopositionxyz graphstyle gainmargins geoprojectiondata graphunion gainphasemargins get gray gamma glaisher graylevel gammadistribution glow greater gammaregularized goldenratio greaterequal gappenalty gompertzmakehamdistribution greaterequalless gather goto greaterfullequal gatherby gradient greatergreater gaussianfilter gradientfilter greaterless gaussianintegers graph greaterslantequal gaussianmatrix graphcenter greatertilde gcd graphcomplement green gegenbauerc graphdata grid general graphdiameter gridbox generalizedlinearmodelfit graphdifference griddefaultelement generateconditions graphdisjointunion gridgraph generatedcell graphdistance gridlines generatedparameters graphdistancematrix gridlinesstyle generatingfunction graphhighlight groebnerbasis genericcylindricaldecomposition graphhighlightstyle groupactionbase genomedata graphics groupcentralizer genomelookup graphics3d groupelementposition geodesicdilation graphicscolumn groupelementq geodesicerosion graphicscomplex groupelements geodestination graphicsgrid groupgenerators geodesydata graphicsgroup groupmultiplicationtable geodirection graphicsrow grouporbits geodistance graphintersection grouporder geogridposition graphlayout grouppagebreakwithin geometricdistribution graphperiphery groupsetwisestabilizer geometricmean graphplot groupstabilizer geometricmeanfilter graphplot3d groupstabilizerchain geometrictransformation graphpower gudermannian geoposition graphq gumbeldistribution geopositionenu graphradius h haarwavelet hermitianmatrixq hue halfnormaldistribution hessenbergdecomposition humpdownhump hamiltoniangraphq hexadecimalcharacter humpequal hammingdistance highlightgraph hurwitzlerchphi hankelh1 higmansimsgrouphs hurwitzzeta hankelh2 hilbertmatrix hyperbolicdistribution hankelmatrix histogram hypercubegraph haradanortongrouphn histogram3d hyperfactorial hararygraph histogramdistribution hypergeometric0f1 harmonicmean histogramlist hypergeometric0f1regularized harmonicmeanfilter hitmisstransform hypergeometric1f1 harmonicnumber hitscentrality hypergeometric1f1regularized hash hold hypergeometric2f1 haversine holdall hypergeometric2f1regularized hazardfunction holdallcomplete hypergeometricdistribution head holdcomplete hypergeometricpfq heads holdfirst hypergeometricpfqregularized heavisidelambda holdform hypergeometricu heavisidepi holdpattern hyperlink heavisidetheta holdrest hyphenation heldgrouphe hornerform hypothesistestdata hermitedecomposition hotellingtsquaredistribution hermiteh hoytdistribution i i importstring interrupt identity in intersection identitymatrix incidencegraph interval if incidencematrix intervalintersection ignorecase includeconstantbasis intervalmemberq im includepods intervalunion image increment inverse imageadd independentedgesetq inversebetaregularized imageadjust independentvertexsetq inversecdf imagealign indeterminate inversechisquaredistribution imageapply indexgraph inversecontinuouswavelettransform imageaspectratio inexactnumberq inversedistancetransform imageassemble infinity inverseellipticnomeq imagecapture infix inverseerf imagechannels information inverseerfc imageclip inherited inversefourier imagecolorspace initialization inversefouriercostransform imagecompose initializationcell inversefouriersequencetransform imageconvolve inner inversefouriersintransform imagecooccurrence inpaint inversefouriertransform imagecorrelate input inversefunction imagecorrespondingpoints inputaliases inversefunctions imagecrop inputassumptions inversegammadistribution imagedata inputautoreplacements inversegammaregularized imagedeconvolve inputfield inversegaussiandistribution imagedifference inputform inversegudermannian imagedimensions inputnamepacket inversehaversine imageeffect inputnotebook inversejacobicd imagefilter inputpacket inversejacobicn imageforestingcomponents inputstream inversejacobics imageforwardtransformation inputstring inversejacobidc imagehistogram inputstringpacket inversejacobidn imagekeypoints insert inversejacobids imagelevels insertresults inversejacobinc imagelines inset inversejacobind imagemargins install inversejacobins imagemultiply installservice inversejacobisc imagepad instring inversejacobisd imagepadding integer inversejacobisn imagepartition integerdigits inverselaplacetransform imageperspectivetransformation integerexponent inversepermutation imageq integerlength inverseradon imagereflect integerpart inverseseries imageresize integerpartitions inversesurvivalfunction imageresolution integerq inversewavelettransform imagerotate integers inverseweierstrassp imagescaled integerstring inverseztransform imagesize integrate invisible imagesizeaction interactivetradingchart irreduciblepolynomialq imagesizemultipliers interleaving isolatinginterval imagesubtract internallybalanceddecomposition isomorphicgraphq imagetake interpolatingfunction isotopedata imagetransformation interpolatingpolynomial italic imagetrim interpolation item imagetype interpolationorder itemaspectratio imagevalue interpretation itemsize implies interpretationbox itemstyle import interquartilerange j jaccarddissimilarity jacobins jankogroupj4 jacobiamplitude jacobip jarqueberaalmtest jacobicd jacobisc johnsondistribution jacobicn jacobisd join jacobics jacobisn joined jacobidc jacobisymbol joinedcurve jacobidn jacobizeta joinform jacobids jankogroupj1 jordandecomposition jacobinc jankogroupj2 jordanmodeldecomposition jacobind jankogroupj3 k kagichart kelvinker kolmogorovsmirnovtest kalmanestimator kernelmixturedistribution kroneckerdelta karhunenloevedecomposition kernelobject kroneckerproduct karytree kernels kroneckersymbol katzcentrality khinchin kuipertest kcorecomponents kirchhoffgraph kumaraswamydistribution kdistribution kirchhoffmatrix kurtosis kelvinbei kleininvariantj kuwaharafilter kelvinber knighttourgraph kelvinkei knotdata l label libraryfunction listdensityplot labeled libraryfunctionerror listinterpolation labelingfunction libraryfunctioninformation listlineintegralconvolutionplot labelstyle libraryfunctionload listlineplot laguerrel libraryfunctionunload listloglinearplot landaudistribution libraryload listloglogplot languagecategory libraryunload listlogplot laplacedistribution liftingfilterdata listplay laplacetransform liftingwavelettransform listplot laplacianfilter lightblue listplot3d laplaciangaussianfilter lightbrown listpointplot3d large lightcyan listpolarplot larger lighter liststreamdensityplot last lightgray liststreamplot latitude lightgreen listsurfaceplot3d latitudelongitude lighting listvectordensityplot latticedata lightingangle listvectorplot latticereduce lightmagenta listvectorplot3d launchkernels lightorange localizevariables layeredgraphplot lightpink locationequivalencetest layersizefunction lightpurple locationtest lcm lightred locator leafcount lightyellow locatorautocreate leastsquares likelihood locatorpane left limit locatorregion leftarrow limitspositioning locked leftarrowbar lindleydistribution log leftarrowrightarrow line log10 leftdownteevector linearfractionaltransform log2 leftdownvector linearmodelfit logbarnesg leftdownvectorbar linearoffsetfunction loggamma leftrightarrow linearprogramming loggammadistribution leftrightvector linearrecurrence logicalexpand leftteearrow linearsolve logintegral leftteevector linearsolvefunction logisticdistribution lefttriangle linebreakchart logitmodelfit lefttrianglebar linegraph loglikelihood lefttriangleequal lineindent loglinearplot leftupdownvector lineindentmaxfraction loglogisticdistribution leftupteevector lineintegralconvolutionplot loglogplot leftupvector lineintegralconvolutionscale lognormaldistribution leftupvectorbar linespacing logplot leftvector linkclose logseriesdistribution leftvectorbar linkconnect longest legendappearance linkcreate longestcommonsequence legended linkfunction longestcommonsubsequence legendrep linkinterrupt longitude legendreq linklaunch longleftarrow length linkobject longleftrightarrow lengthwhile linkpatterns longrightarrow lerchphi linkprotocol loopfreegraphq less linkread lowercaseq lessequal linkreadyq lowerleftarrow lessequalgreater links lowerrightarrow lessfullequal linkwrite lowertriangularize lessgreater liouvillelambda lqestimatorgains lessless list lqgregulator lessslantequal listable lqoutputregulatorgains lesstilde listanimate lqregulatorgains lettercharacter listcontourplot lucasl letterq listcontourplot3d ludecomposition level listconvolve lyapunovsolve levenetest listcorrelate lyonsgrouply levicivitatensor listcurvepathplot levydistribution listdeconvolve m machinenumberq maxdetect mindetect machineprecision maxextrabandwidths minfilter magenta maxextraconditions minimalpolynomial magnification maxfilter minimalstatespacemodel magnify maximize minimize majority maxiterations minors makeboxes maxmemoryused minstabledistribution makeexpression maxmixturekernels minus mangoldtlambda maxplotpoints minusplus manhattandistance maxrecursion minvalue manipulate maxstabledistribution missing manipulator maxstepfraction mixturedistribution mannwhitneytest maxsteps mod mantissaexponent maxstepsize modal manual maxvalue modularlambda map maxwelldistribution module mapall mclaughlingroupmcl modulus mapat mean moebiusmu mapindexed meandeviation moment mapthread meanfilter momentconvert marcumq meanshift momentevaluate mardiacombinedtest meanshiftfilter momentgeneratingfunction mardiakurtosistest median monitor mardiaskewnesstest mediandeviation monomiallist marginaldistribution medianfilter monstergroupm masking medium morletwavelet matchingdissimilarity meijerg morphologicalbinarize matchlocalnames memberq morphologicalbranchpoints matchq memoryconstrained morphologicalcomponents mathieuc memoryinuse morphologicaleulernumber mathieucharacteristica menucommandkey morphologicalgraph mathieucharacteristicb menupacket morphologicalperimeter mathieucharacteristicexponent menusortingvalue morphologicaltransform mathieucprime menustyle most mathieugroupm11 menuview mouseannotation mathieugroupm12 mesh mouseappearance mathieugroupm22 meshfunctions mouseover mathieugroupm23 meshshading mouseposition mathieugroupm24 meshstyle movingaverage mathieus message movingmedian mathieusprime messagedialog moyaldistribution mathmlform messagelist multiedgestyle matrixexp messagename multinomial matrixform messagepacket multinomialdistribution matrixplot messages multinormaldistribution matrixpower method multiplicativeorder matrixq mexicanhatwavelet multivariatehypergeometricdistribution matrixrank meyerwavelet multivariatepoissondistribution max min multivariatetdistribution n n normalizedsquaredeuclideandistance notprecedesslantequal nakagamidistribution normalsfunction notprecedestilde nameq normfunction notreverseelement names not notrighttriangle nand notcongruent notrighttrianglebar nargmax notcupcap notrighttriangleequal nargmin notdoubleverticalbar notsquaresubset ncache notebook notsquaresubsetequal ndsolve notebookapply notsquaresuperset nearest notebookautosave notsquaresupersetequal nearestfunction notebookclose notsubset needlemanwunschsimilarity notebookdelete notsubsetequal needs notebookdirectory notsucceeds negative notebookdynamicexpression notsucceedsequal negativebinomialdistribution notebookevaluate notsucceedsslantequal negativemultinomialdistribution notebookeventactions notsucceedstilde neighborhoodgraph notebookfilename notsuperset nest notebookfind notsupersetequal nestedgreatergreater notebookget nottilde nestedlessless notebookinformation nottildeequal nestlist notebooklocate nottildefullequal nestwhile notebookobject nottildetilde nestwhilelist notebookopen notverticalbar nevillethetac notebookprint nprobability nevillethetad notebookput nproduct nevillethetan notebookread nroots nevillethetas notebooks nsolve nexpectation notebooksave nsum nextprime notebookselection null nholdall notebookwrite nullrecords nholdfirst notelement nullspace nholdrest notequaltilde nullwords nicholsgridlines notexists number nicholsplot notgreater numberfieldclassnumber nintegrate notgreaterequal numberfielddiscriminant nmaximize notgreaterfullequal numberfieldfundamentalunits nmaxvalue notgreatergreater numberfieldintegralbasis nminimize notgreaterless numberfieldnormrepresentatives nminvalue notgreaterslantequal numberfieldregulator nominalvariables notgreatertilde numberfieldrootsofunity noncentralbetadistribution nothumpdownhump numberfieldsignature noncentralchisquaredistribution nothumpequal numberform noncentralfratiodistribution notlefttriangle numberformat noncentralstudenttdistribution notlefttrianglebar numbermarks noncommutativemultiply notlefttriangleequal numbermultiplier nonconstants notless numberpadding none notlessequal numberpoint nonlinearmodelfit notlessfullequal numberq nonnegative notlessgreater numberseparator nonpositive notlessless numbersigns nor notlessslantequal numberstring norlundb notlesstilde numerator norm notnestedgreatergreater numericfunction normal notnestedlessless numericq normaldistribution notprecedes nyquistgridlines normalize notprecedesequal nyquistplot o o operate outputform observabilitygramian operatingsystem outputnamepacket observabilitymatrix optional outputresponse observabledecomposition options outputsizelimit observablemodelq optionspattern outputstream oddq optionvalue overbar off or overdot offset orange overflow on order overhat onangroupon orderdistribution overlaps oneidentity orderedq overlay opacity ordering overscript openappend orderless overscriptbox opener orthogonalize overtilde openerview out overvector opening outer owent openread outputcontrollabilitymatrix ownvalues openwrite outputcontrollablemodelq p packingmethod permutationlist popupmenu paddedform permutationlistq popupview padding permutationmax popupwindow padeapproximant permutationmin position padleft permutationorder positive padright permutationpower positivedefinitematrixq pagebreakabove permutationproduct possiblezeroq pagebreakbelow permutationreplace postfix pagebreakwithin permutations power pagefooters permutationsupport powerdistribution pageheaders permute powerexpand pagerankcentrality peronamalikfilter powermod pagewidth pertdistribution powermodlist pairedbarchart petersengraph powersrepresentations pairedhistogram phasemargins powersymmetricpolynomial pairedttest pi precedenceform pairedztest pick precedes palettenotebook piecewise precedesequal pane piecewiseexpand precedesslantequal panel piechart precedestilde paneled piechart3d precision paneselector pink precisiongoal paraboliccylinderd pixelconstrained predecrement paragraphindent pixelvalue preemptprotect paragraphspacing placed prefix parallelarray placeholder preincrement parallelcombine placeholderreplace prepend paralleldo plain prependto parallelevaluate play preserveimageoptions parallelization playrange pricegraphdistribution parallelize plot prime parallelmap plot3d primenu parallelneeds plotlabel primeomega parallelproduct plotlayout primepi parallelsubmit plotmarkers primepowerq parallelsum plotpoints primeq paralleltable plotrange primes paralleltry plotrangeclipping primezetap parameterestimator plotrangepadding primitiveroot parametermixturedistribution plotregion principalcomponents parametricplot plotstyle principalvalue parametricplot3d plus print parentdirectory plusminus printingstyleenvironment paretodistribution pochhammer printtemporary part podstates probability particledata podwidth probabilitydistribution partition point probabilityplot partitionsp pointfigurechart probabilityscaleplot partitionsq pointsize probitmodelfit pascaldistribution poissonconsuldistribution product passeventsdown poissondistribution productdistribution passeventsup polaraxes productlog paste polaraxesorigin progressindicator pastebutton polargridlines projection path polarplot prolog pathgraph polarticks properties pathgraphq polezeromarkers property pattern polyaaepplidistribution propertylist patternsequence polygamma propertyvalue patterntest polygon proportion paulimatrix polyhedrondata proportional paulwavelet polylog protect pause polynomialextendedgcd protected pdf polynomialgcd proteindata pearsonchisquaretest polynomiallcm pruning pearsondistribution polynomialmod pseudoinverse performancegoal polynomialq purple permutationcycles polynomialquotient put permutationcyclesq polynomialquotientremainder putappend permutationgroup polynomialreduce permutationlength polynomialremainder q qbinomial qrdecomposition quartiles qfactorial quadraticirrationalq quartileskewness qgamma quantile quiet qhypergeometricpfq quantileplot quit qpochhammer quartics quotient qpolygamma quartiledeviation quotientremainder r radicalbox refreshrate rightarrowbar radiobutton regionbinarize rightarrowleftarrow radiobuttonbar regionfunction rightcosetrepresentative radon regionplot rightdownteevector ramanujantau regionplot3d rightdownvector ramanujantaul regularexpression rightdownvectorbar ramanujantautheta regularization rightteearrow ramanujantauz releasehold rightteevector randomchoice reliefimage righttriangle randomcomplex reliefplot righttrianglebar randomgraph remove righttriangleequal randomimage removealphachannel rightupdownvector randominteger removeproperty rightupteevector randompermutation removescheduledtask rightupvector randomprime renamedirectory rightupvectorbar randomreal renamefile rightvector randomsample renkochart rightvectorbar randomvariate repeated rogerstanimotodissimilarity range repeatednull root rangefilter replace rootapproximant rankedmax replaceall rootintervals rankedmin replacelist rootlocusplot raster replacepart rootmeansquare rasterize replacerepeated rootofunityq rastersize resampling rootreduce rational rescale roots rationalize rescalingtransform rootsum rationals resetdirectory rotate ratios resetscheduledtask rotatelabel rawboxes residue rotateleft rawdata resolve rotateright rayleighdistribution rest rotationaction re resultant rotationmatrix read resumepacket rotationtransform readlist return round readprotected returnexpressionpacket roundingradius real returnpacket row realblockdiagonalform returntextpacket rowalignments realdigits reverse rowbox realexponent reversebiorthogonalsplinewavelet rowlines reals reverseelement rowminheight reap reverseequilibrium rowreduce record reversegraph rowsequal recordlists reverseupequilibrium rowspacings recordseparators revolutionaxis rsolve rectangle revolutionplot3d rudvalisgroupru rectanglechart rgbcolor rule rectanglechart3d riccatisolve ruledelayed recurrencetable ricedistribution run red ridgefilter runscheduledtask reduce riemannr runthrough referencelinestyle riemannsiegeltheta runtimeattributes refine riemannsiegelz runtimeoptions reflectionmatrix riffle russellraodissimilarity reflectiontransform right refresh rightarrow s sameq sin stationarywaveletpackettransform sametest sinc stationarywavelettransform sampledepth singhmaddaladistribution statusarea sampledsoundfunction singleletteritalics stepmonitor sampledsoundlist singularvaluedecomposition stieltjesgamma samplerate singularvaluelist stirlings1 samplingperiod singularvalueplot stirlings2 satisfiabilitycount sinh stopscheduledtask satisfiabilityinstances sinhintegral streamcolorfunction satisfiableq sinintegral streamcolorfunctionscaling save sixjsymbol streamdensityplot savedefinitions skeleton streamplot sawtoothwave skeletontransform streampoints scale skellamdistribution streamposition scaled skewness streams scalingfunctions skewnormaldistribution streamscale scalingmatrix skip streamstyle scalingtransform slider string scan slider2d stringcases scheduledtaskobject slideview stringcount scheduledtasks slot stringdrop schurdecomposition slotsequence stringexpression scientificform small stringform screenstyleenvironment smallcircle stringformat scriptbaselineshifts smaller stringfreeq scriptminsize smithwatermansimilarity stringinsert scriptsizemultipliers smoothdensityhistogram stringjoin scrollbars smoothhistogram stringlength scrollposition smoothhistogram3d stringmatchq sec smoothkerneldistribution stringposition sech sokalsneathdissimilarity stringq sechdistribution solve stringreplace sectorchart solvealways stringreplacelist sectorchart3d sort stringreplacepart sectororigin sortby stringreverse sectorspacing sound stringskeleton seedrandom soundnote stringsplit select soundvolume stringtake selectable sow stringtostream selectcomponents spacer stringtrim selectednotebook spacings structuredselection selectionanimate span struveh selectioncreatecell spanfromabove struvel selectionevaluate spanfromboth stub selectionevaluatecreatecell spanfromleft studenttdistribution selectionmove sparsearray style selfloopstyle speak stylebox semialgebraiccomponentinstances specularity styledata sendmail spellingcorrection styledefinitions sequence sphere subfactorial sequencealignment sphericalbesselj subgraph sequencehold sphericalbessely subminus series sphericalhankelh1 subplus seriescoefficient sphericalhankelh2 subresultants seriesdata sphericalharmonicy subscript sessiontime sphericalplot3d subscriptbox set sphericalregion subset setaccuracy spheroidaleigenvalue subsetequal setalphachannel spheroidaljoiningfactor subsets setattributes spheroidalps substar setdelayed spheroidalpsprime subsuperscript setdirectory spheroidalqs subsuperscriptbox setfiledate spheroidalqsprime subtract setoptions spheroidalradialfactor subtractfrom setprecision spheroidals1 succeeds setproperty spheroidals1prime succeedsequal setselectednotebook spheroidals2 succeedsslantequal setsharedfunction spheroidals2prime succeedstilde setsharedvariable splice suchthat setstreamposition splineclosed sum setsystemoptions splinedegree sumconvergence setter splineknots superdagger setterbar splineweights superminus setting split superplus shallow splitby superscript shannonwavelet spokenstring superscriptbox shapirowilktest sqrt superset share sqrtbox supersetequal sharpen square superstar shearingmatrix squaredeuclideandistance survivaldistribution shearingtransform squarefreeq survivalfunction short squareintersection suspendpacket shortdownarrow squaresr suzukidistribution shortest squaresubset suzukigroupsuz shortestpathfunction squaresubsetequal switch shortleftarrow squaresuperset symbol shortrightarrow squaresupersetequal symbolname shortuparrow squareunion symletwavelet show squarewave symmetricgroup showautostyles stabilitymargins symmetricmatrixq showcellbracket stabilitymarginsstyle symmetricpolynomial showcelllabel stabledistribution symmetricreduction showcelltags stack synchronousinitialization showcursortracker stackbegin synchronousupdating showgroupopener stackcomplete syntaxinformation showpagebreaks stackinhibit syntaxlength showselection standarddeviation syntaxpacket showspecialcharacters standarddeviationfilter syntaxq showstringcharacters standardform systemdialoginput shrinkingdelay standardize systeminformation siegeltheta star systemopen siegeltukeytest stargraph systemoptions sign startingstepsize systemsmodeldelete signature startofline systemsmodeldimensions signedranktest startofstring systemsmodelextract significancelevel startscheduledtask systemsmodelfeedbackconnect signpadding statefeedbackgains systemsmodellabels signtest stateoutputestimator systemsmodelorder similarityrules stateresponse systemsmodelparallelconnect simplegraph statespacemodel systemsmodelseriesconnect simplegraphq statespacerealization systemsmodelstatefeedbackconnect simplify statespacetransform t table tilde traceon tablealignments tildeequal traceoriginal tabledepth tildefullequal traceprint tabledirections tildetilde tracescan tableform timeconstrained trackedsymbols tableheadings timeconstraint tradingchart tablespacing times traditionalform tabview timesby transferfunctioncancel tagbox timeused transferfunctionexpand taggingrules timevalue transferfunctionfactor tagset timezone transferfunctionmodel tagsetdelayed timing transferfunctionpoles tagunset tiny transferfunctionzeros take titsgroupt transformationfunction takewhile toboxes transformationfunctions tally tocharactercode transformationmatrix tan tocontinuoustimemodel transformeddistribution tanh todiscretetimemodel translate targetfunctions toeplitzmatrix translationtransform tautologyq toexpression transparent temporary together transpose texform toggler treeform text togglerbar treegraph textalignment tokenwords treegraphq textcell tolerance treeplot textclipboardtype tolowercase trendstyle textdata tonumberfield trianglewave textjustification tooltip triangulardistribution textpacket tooltipdelay trig textrecognize top trigexpand texture tophattransform trigfactor texturecoordinatefunction topologicalsort trigfactorlist texturecoordinatescaling toradicals trigger therefore torules trigreduce thick tostring trigtoexp thickness total trimmedmean thin totalvariationfilter true thinning totalwidth trueq thompsongroupth touppercase truncateddistribution thread tr ttest threejsymbol trace tube threshold traceabove tukeylambdadistribution through tracebackward tuples throw tracedepth turangraph thumbnail tracedialog turingmachine ticks traceforward ticksstyle traceoff u uncompress uniformsumdistribution uparrowbar undefined uninstall uparrowdownarrow underbar union update underflow unionplus updateinterval underlined unique updownarrow underoverscript unitbox upequilibrium underoverscriptbox unitize uppercaseq underscript unitstep upperleftarrow underscriptbox unittriangle upperrightarrow undirectededge unitvector uppertriangularize undirectedgraph unprotect upset undirectedgraphq unsameq upsetdelayed unequal unsavedvariables upteearrow unevaluated unset upvalues uniformdistribution unsetshared usingfrontend uniformgraphdistribution uparrow v validationlength vertexadd vertexreplace valueq vertexcolors vertexshape variables vertexcomponent vertexshapefunction variance vertexcoordinaterules vertexsize varianceequivalencetest vertexcoordinates vertexstyle varianceestimatorfunction vertexcount vertextexturecoordinates variancetest vertexcoverq vertexweight vectorangle vertexdegree verticalbar vectorcolorfunction vertexdelete verticalseparator vectorcolorfunctionscaling vertexeccentricity verticalslider vectordensityplot vertexincomponent verticaltilde vectorplot vertexindegree viewangle vectorplot3d vertexindex viewcenter vectorpoints vertexlabeling viewmatrix vectorq vertexlabels viewpoint vectorscale vertexlist viewrange vectorstyle vertexnormals viewvector vee vertexoutcomponent viewvertical verbatim vertexoutdegree visible verifyconvergence vertexq vonmisesdistribution verifytestassumptions vertexrenderingfunction w waitall weierstrasshalfperiods windowfloating waitnext weierstrassinvariants windowframe wakebydistribution weierstrassp windowmargins walleniushypergeometricdistribution weierstrasspprime windowmovable waringyuledistribution weierstrasssigma windowopacity watershedcomponents weierstrasszeta windowsize watsonusquaretest weightedadjacencygraph windowstatusarea wattsstrogatzgraphdistribution weightedadjacencymatrix windowtitle waveletbestbasis weightedgraphq windowtoolbars waveletfiltercoefficients weights with waveletimageplot wheelgraph wolframalpha waveletlistplot which word waveletmapindexed while wordboundary waveletmatrixplot white wordcharacter waveletphi whitespace worddata waveletpsi whitespacecharacter wordsearch waveletscale whittakerm wordseparators waveletscalogram whittakerw workingprecision waveletthreshold wienerfilter write weatherdata wignerd writestring webere wignersemicircledistribution wronskian wedge windowclickselect weibulldistribution windowelements x xmlelement xnor xmlobject xor y yellow yuledissimilarity z zerniker zetazero ztransform zerotest zipfdistribution zeta ztest $ $aborted $inspector $outputsizelimit $assertfunction $installationdirectory $packages $assumptions $iterationlimit $parentlink $basedirectory $kernelcount $parentprocessid $batchinput $kernelid $path $batchoutput $language $pathnameseparator $byteordering $librarypath $performancegoal $canceled $licenseexpirationdate $post $characterencoding $licenseid $pre $characterencodings $licenseserver $preprint $commandline $line $preread $compilationtarget $linked $processid $configuredkernels $machineaddresses $processorcount $context $machinedomains $processortype $contextpath $machineepsilon $recursionlimit $controlactivesetting $machineid $releasenumber $creationdate $machinename $rootdirectory $currentlink $machineprecision $scheduledtask $datestringformat $machinetype $scriptcommandline $defaultimagingdevice $maxextraprecision $sessionid $display $maxmachinenumber $sharedfunctions $displayfunction $maxnumber $sharedvariables $distributedcontexts $maxpiecewisecases $sounddisplayfunction $dynamicevaluation $maxprecision $syntaxhandler $echo $maxrootdegree $system $epilog $messagegroups $systemcharacterencoding $exportformats $messagelist $systemid $failed $messagepreprint $systemwordlength $frontend $messages $temporarydirectory $frontendsession $minmachinenumber $timedout $geolocation $minnumber $timeunit $historylength $minprecision $timezone $homedirectory $modulenumber $urgent $ignoreeof $newmessage $userbasedirectory $imagingdevices $newsymbol $userdocumentsdirectory $importformats $notebooks $username $initialdirectory $numbermarks $version $input $operatingsystem $versionnumber $inputfilename $output" + +regex_'5ba'2dzA'2dZ'5f0'2d9'5d'2b'5c'5f = compileRegex True "[a-zA-Z_0-9]+\\_" +regex_'28'5c'2d'5c'3e'7c'5c'2f'5c'2e'29 = compileRegex True "(\\-\\>|\\/\\.)" +regex_'28'3a'3d'7c'3d'29 = compileRegex True "(:=|=)" + +parseRules ("Mathematica","Normal") = + (((pKeyword " \n\t.():!+,<=>&*/;?[]^{|}~\\" list_functions >>= withAttribute FunctionTok)) + <|> + ((pInt >>= withAttribute DecValTok)) + <|> + ((pFloat >>= withAttribute FloatTok)) + <|> + ((pRegExpr regex_'5ba'2dzA'2dZ'5f0'2d9'5d'2b'5c'5f >>= withAttribute DataTypeTok)) + <|> + ((pRegExpr regex_'28'5c'2d'5c'3e'7c'5c'2f'5c'2e'29 >>= withAttribute NormalTok)) + <|> + ((pAnyChar "+*/%\\|-^" >>= withAttribute NormalTok)) + <|> + ((pRegExpr regex_'28'3a'3d'7c'3d'29 >>= withAttribute NormalTok)) + <|> + (currentContext >>= \x -> guard (x == ("Mathematica","Normal")) >> pDefault >>= withAttribute NormalTok)) + + +parseRules x = parseRules ("Mathematica","Normal") <|> fail ("Unknown context" ++ show x) diff --git a/Text/Highlighting/Kate/Syntax/Maxima.hs b/Text/Highlighting/Kate/Syntax/Maxima.hs --- a/Text/Highlighting/Kate/Syntax/Maxima.hs +++ b/Text/Highlighting/Kate/Syntax/Maxima.hs @@ -1,5 +1,5 @@ {- This module was generated from data in the Kate syntax - highlighting file maxima.xml, version 0.16, by Alexey Beshenov -} + highlighting file maxima.xml, version 0.17, by Alexey Beshenov -} module Text.Highlighting.Kate.Syntax.Maxima (highlight, parseExpression, syntaxName, syntaxExtensions) @@ -77,7 +77,7 @@ <|> ((pDetectChar False '"' >>= withAttribute StringTok) >>~ pushContext ("Maxima","String")) <|> - ((pDetect2Chars False '/' '*' >>= withAttribute NormalTok) >>~ pushContext ("Maxima","Comment")) + ((pDetect2Chars False '/' '*' >>= withAttribute CommentTok) >>~ pushContext ("Maxima","Comment")) <|> ((pRegExpr regex_'5ba'2dzA'2dZ'5f'5d'5ba'2dzA'2dZ0'2d9'25'5f'5d'2a >>= withAttribute NormalTok)) <|> @@ -89,7 +89,7 @@ <|> ((pRegExpr regex_'5b'2d'2b'5d'3f'5cd'2b >>= withAttribute DecValTok)) <|> - ((pDetectChar False '\'' >>= withAttribute NormalTok)) + ((pDetectChar False '\'' >>= withAttribute CommentTok)) <|> (currentContext >>= \x -> guard (x == ("Maxima","Normal Text")) >> pDefault >>= withAttribute NormalTok)) @@ -101,11 +101,11 @@ parseRules ("Maxima","Comment") = (((pKeyword " \n\t.():!+,-<=>&*/;?[]^{|}~\\@#" list_SpecialComment >>= withAttribute NormalTok)) <|> - ((pDetectSpaces >>= withAttribute NormalTok)) + ((pDetectSpaces >>= withAttribute CommentTok)) <|> - ((pDetect2Chars False '*' '/' >>= withAttribute NormalTok) >>~ (popContext)) + ((pDetect2Chars False '*' '/' >>= withAttribute CommentTok) >>~ (popContext)) <|> - (currentContext >>= \x -> guard (x == ("Maxima","Comment")) >> pDefault >>= withAttribute NormalTok)) + (currentContext >>= \x -> guard (x == ("Maxima","Comment")) >> pDefault >>= withAttribute CommentTok)) parseRules x = parseRules ("Maxima","Normal Text") <|> fail ("Unknown context" ++ show x) diff --git a/Text/Highlighting/Kate/Syntax/Mediawiki.hs b/Text/Highlighting/Kate/Syntax/Mediawiki.hs new file mode 100644 --- /dev/null +++ b/Text/Highlighting/Kate/Syntax/Mediawiki.hs @@ -0,0 +1,1156 @@ +{- This module was generated from data in the Kate syntax + highlighting file mediawiki.xml, version 1.11, by -} + +module Text.Highlighting.Kate.Syntax.Mediawiki + (highlight, parseExpression, syntaxName, syntaxExtensions) +where +import Text.Highlighting.Kate.Types +import Text.Highlighting.Kate.Common +import qualified Text.Highlighting.Kate.Syntax.Javascript +import Text.ParserCombinators.Parsec hiding (State) +import Control.Monad.State +import Data.Char (isSpace) + +-- | Full name of language. +syntaxName :: String +syntaxName = "MediaWiki" + +-- | Filename extensions for this language. +syntaxExtensions :: String +syntaxExtensions = "*.mediawiki" + +-- | Highlight source code using this syntax definition. +highlight :: String -> [SourceLine] +highlight input = evalState (mapM parseSourceLine $ lines input) startingState + +parseSourceLine :: String -> State SyntaxState SourceLine +parseSourceLine = mkParseSourceLine (parseExpression Nothing) + +-- | Parse an expression using appropriate local context. +parseExpression :: Maybe (String,String) + -> KateParser Token +parseExpression mbcontext = do + (lang,cont) <- maybe currentContext return mbcontext + result <- parseRules (lang,cont) + optional $ do eof + updateState $ \st -> st{ synStPrevChar = '\n' } + pEndLine + return result + +startingState = SyntaxState {synStContexts = [("MediaWiki","normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []} + +pEndLine = do + updateState $ \st -> st{ synStPrevNonspace = False } + context <- currentContext + contexts <- synStContexts `fmap` getState + if length contexts >= 2 + then case context of + ("MediaWiki","normal") -> return () + ("MediaWiki","TableHeader") -> pushContext ("MediaWiki","TableContent") >> return () + ("MediaWiki","TableContent") -> return () + ("MediaWiki","Section5") -> (popContext) >> pEndLine + ("MediaWiki","Section4") -> (popContext) >> pEndLine + ("MediaWiki","Section3") -> (popContext) >> pEndLine + ("MediaWiki","Section2") -> (popContext) >> pEndLine + ("MediaWiki","comment") -> return () + ("MediaWiki","DelimitedURL") -> return () + ("MediaWiki","DelimitedUrlLink") -> return () + ("MediaWiki","LooseURL") -> (popContext) >> pEndLine + ("MediaWiki","LooseURLWithinTemplate") -> (popContext) >> pEndLine + ("MediaWiki","URLTag") -> return () + ("MediaWiki","WikiLinkWithoutDescriptionRules") -> return () + ("MediaWiki","WikiLinkWithDescriptionRules") -> return () + ("MediaWiki","WikiLink") -> return () + ("MediaWiki","WikiLinkBoldWithDescription") -> return () + ("MediaWiki","WikiLinkBoldWithoutDescription") -> return () + ("MediaWiki","WikiLinkItalicWithDescription") -> return () + ("MediaWiki","WikiLinkItalicWithoutDescription") -> return () + ("MediaWiki","WikiLinkUnderlinedWithDescription") -> return () + ("MediaWiki","WikiLinkUnderlinedWithoutDescription") -> return () + ("MediaWiki","WikiLinkBoldItalicWithDescription") -> return () + ("MediaWiki","WikiLinkBoldItalicWithoutDescription") -> return () + ("MediaWiki","WikiLinkBoldUnderlinedWithDescription") -> return () + ("MediaWiki","WikiLinkBoldUnderlinedWithoutDescription") -> return () + ("MediaWiki","WikiLinkItalicUnderlinedWithDescription") -> return () + ("MediaWiki","WikiLinkItalicUnderlinedWithoutDescription") -> return () + ("MediaWiki","WikiLinkBoldItalicUnderlinedWithDescription") -> return () + ("MediaWiki","WikiLinkBoldItalicUnderlinedWithoutDescription") -> return () + ("MediaWiki","WikiLinkDescriptionRules") -> return () + ("MediaWiki","WikiLinkDescription") -> return () + ("MediaWiki","WikiLinkDescriptionBold") -> return () + ("MediaWiki","WikiLinkDescriptionItalic") -> return () + ("MediaWiki","WikiLinkDescriptionUnderlined") -> return () + ("MediaWiki","WikiLinkDescriptionBoldItalic") -> return () + ("MediaWiki","WikiLinkDescriptionBoldUnderlined") -> return () + ("MediaWiki","WikiLinkDescriptionItalicUnderlined") -> return () + ("MediaWiki","WikiLinkDescriptionBoldItalicUnderlined") -> return () + ("MediaWiki","Template") -> return () + ("MediaWiki","TemplateParameterSlot") -> return () + ("MediaWiki","TemplateParameterSlotEqual") -> return () + ("MediaWiki","TemplateParameterSlotValue") -> return () + ("MediaWiki","TemplateParameter") -> return () + ("MediaWiki","NoWiki") -> return () + ("MediaWiki","Unformatted") -> (popContext) >> pEndLine + ("MediaWiki","Pre") -> return () + ("MediaWiki","SourceStartTag") -> return () + ("MediaWiki","SyntaxHighlightStartTag") -> return () + ("MediaWiki","UnsupportedLanguageSourceStartTag") -> return () + ("MediaWiki","UnsupportedLanguageSyntaxHighlightStartTag") -> return () + ("MediaWiki","JavaScriptSourceStartTag") -> return () + ("MediaWiki","JavaScriptSyntaxHighlightStartTag") -> return () + ("MediaWiki","UnsupportedLanguageSourceContent") -> return () + ("MediaWiki","UnsupportedLanguageSyntaxHighlightContent") -> return () + ("MediaWiki","JavaScriptSourceContent") -> return () + ("MediaWiki","JavaScriptSyntaxHighlightContent") -> return () + ("MediaWiki","SourceEnd") -> return () + ("MediaWiki","SyntaxHighlightEnd") -> return () + ("MediaWiki","HtmlAttribute") -> return () + ("MediaWiki","HtmlValue") -> return () + ("MediaWiki","ValueWithDoubleQuotes") -> return () + ("MediaWiki","ValueWithSingleQuotes") -> return () + ("MediaWiki","DefinitionListHeader") -> (popContext) >> pEndLine + ("MediaWiki","Bold") -> (popContext) >> pEndLine + ("MediaWiki","Italic") -> (popContext) >> pEndLine + ("MediaWiki","Underlined") -> return () + ("MediaWiki","BoldItalic") -> (popContext) >> pEndLine + ("MediaWiki","ItalicBold") -> (popContext) >> pEndLine + ("MediaWiki","BoldUnderlined") -> (popContext) >> pEndLine + ("MediaWiki","UnderlinedBold") -> (popContext) >> pEndLine + ("MediaWiki","ItalicUnderlined") -> (popContext) >> pEndLine + ("MediaWiki","UnderlinedItalic") -> (popContext) >> pEndLine + ("MediaWiki","BoldItalicUnderlined") -> (popContext) >> pEndLine + ("MediaWiki","BoldUnderlinedItalic") -> (popContext) >> pEndLine + ("MediaWiki","ItalicUnderlinedBold") -> (popContext) >> pEndLine + ("MediaWiki","FindHtmlEntities") -> return () + ("MediaWiki","FindHtmlStartTagAttributes") -> return () + ("MediaWiki","FindListItem") -> return () + ("MediaWiki","FindSyntaxHighlightingHtmlElement") -> return () + ("MediaWiki","FindTable") -> return () + ("MediaWiki","FindTemplate") -> return () + ("MediaWiki","FindTextDecorations") -> return () + ("MediaWiki","FindTextDecorationsInHeader") -> return () + ("MediaWiki","FindUrl") -> return () + ("MediaWiki","FindUrlWithinTemplate") -> return () + ("MediaWiki","FindWikiLink") -> return () + ("MediaWiki","FindWikiLinkBeingBold") -> return () + ("MediaWiki","FindWikiLinkBeingItalic") -> return () + ("MediaWiki","FindWikiLinkBeingUnderlined") -> return () + ("MediaWiki","FindWikiLinkBeingBoldItalic") -> return () + ("MediaWiki","FindWikiLinkBeingBoldUnderlined") -> return () + ("MediaWiki","FindWikiLinkBeingItalicUnderlined") -> return () + ("MediaWiki","FindWikiLinkBeingBoldItalicUnderlined") -> return () + _ -> return () + else return () + +withAttribute attr txt = do + when (null txt) $ fail "Parser matched no text" + updateState $ \st -> st { synStPrevChar = last txt + , synStPrevNonspace = synStPrevNonspace st || not (all isSpace txt) } + return (attr, txt) + + +regex_'5b'3d'5d'7b5'2c5'7d'28'3f'21'3d'29 = compileRegex True "[=]{5,5}(?!=)" +regex_'5b'3d'5d'7b4'2c4'7d'28'3f'21'3d'29 = compileRegex True "[=]{4,4}(?!=)" +regex_'5b'3d'5d'7b3'2c3'7d'28'3f'21'3d'29 = compileRegex True "[=]{3,3}(?!=)" +regex_'5b'3d'5d'7b2'2c2'7d'28'3f'21'3d'29 = compileRegex True "[=]{2,2}(?!=)" +regex_'5b'7e'5d'7b3'2c4'7d = compileRegex True "[~]{3,4}" +regex_'5b'3c'5d'5b'5e'3e'5d'2b'5b'3e'5d = compileRegex True "[<][^>]+[>]" +regex_'5b'5cs'5d = compileRegex True "[\\s]" +regex_'5b'2d'5d'7b4'2c'7d = compileRegex True "[-]{4,}" +regex_'3d'7b6'2c'7d_'2a'24 = compileRegex True "={6,} *$" +regex_'3d'7b5'2c5'7d_'2a'24 = compileRegex True "={5,5} *$" +regex_'3d'7b1'2c4'7d_'2a'24 = compileRegex True "={1,4} *$" +regex_'3d'2a'5b'5e'3d'5d'2b'24 = compileRegex True "=*[^=]+$" +regex_'3d'7b5'2c'7d_'2a'24 = compileRegex True "={5,} *$" +regex_'3d'7b4'2c4'7d_'2a'24 = compileRegex True "={4,4} *$" +regex_'3d'7b1'2c3'7d_'2a'24 = compileRegex True "={1,3} *$" +regex_'3d'7b4'2c'7d_'2a'24 = compileRegex True "={4,} *$" +regex_'3d'7b3'2c3'7d_'2a'24 = compileRegex True "={3,3} *$" +regex_'3d'7b1'2c2'7d_'2a'24 = compileRegex True "={1,2} *$" +regex_'3d'7b3'2c'7d_'2a'24 = compileRegex True "={3,} *$" +regex_'3d'7b2'2c2'7d_'2a'24 = compileRegex True "={2,2} *$" +regex_'3d'7b1'2c1'7d_'2a'24 = compileRegex True "={1,1} *$" +regex_'28http'3a'7chttps'3a'7cftp'3a'7cmailto'3a'29'5b'5e'5d'7c_'5d'2a'28'3f'3d'24'7c'5b'5d'7c'5cs'5d'29 = compileRegex True "(http:|https:|ftp:|mailto:)[^]| ]*(?=$|[]|\\s])" +regex_'3cu_'2a'3e = compileRegex True "" +regex_'5b'5e'7b'7d'7c'3d'5d'2b'28'3f'3d'5b'3d'5d'29 = compileRegex True "[^{}|=]+(?=[=])" +regex_'3c'21'2d'2d'5b'5e'2d'5d'2a'2d'2d'3e = compileRegex True "" +regex_'28'5e'7c'5cs'2b'29lang'5c'3d'28'22javascript'22'7c'27javascript'27'29 = compileRegex True "(^|\\s+)lang\\=(\"javascript\"|'javascript')" +regex_'5cS = compileRegex True "\\S" +regex_'3c'2fu_'2a'3e = compileRegex True "" +regex_'26'28'23'5b0'2d9'5d'2b'7c'23'5bxX'5d'5b0'2d9A'2dFa'2df'5d'2b'7c'28'3f'21'5b0'2d9'5d'29'5b'5cw'5f'3a'5d'5b'5cw'2e'3a'5f'2d'5d'2a'29'3b = compileRegex True "&(#[0-9]+|#[xX][0-9A-Fa-f]+|(?![0-9])[\\w_:][\\w.:_-]*);" +regex_'28'3f'21'5b0'2d9'5d'29'5b'5cw'5f'3a'5d'5b'5cw'2e'3a'5f'2d'5d'2a = compileRegex True "(?![0-9])[\\w_:][\\w.:_-]*" +regex_'5cs'2b'28'3f'21'5b0'2d9'5d'29'5b'5cw'5f'3a'5d'5b'5cw'2e'3a'5f'2d'5d'2a = compileRegex True "\\s+(?![0-9])[\\w_:][\\w.:_-]*" +regex_'5b'2a'23'3b'3a'5cs'5d'2a'5b'2a'23'3a'5d'2b = compileRegex True "[*#;:\\s]*[*#:]+" +regex_'3csource'28'3f'3d'5cs'29 = compileRegex True ">= withAttribute CommentTok) >>~ pushContext ("MediaWiki","comment")) + <|> + ((pColumn 0 >> pRegExpr regex_'5b'3d'5d'7b5'2c5'7d'28'3f'21'3d'29 >>= withAttribute KeywordTok) >>~ pushContext ("MediaWiki","Section5")) + <|> + ((pColumn 0 >> pRegExpr regex_'5b'3d'5d'7b4'2c4'7d'28'3f'21'3d'29 >>= withAttribute KeywordTok) >>~ pushContext ("MediaWiki","Section4")) + <|> + ((pColumn 0 >> pRegExpr regex_'5b'3d'5d'7b3'2c3'7d'28'3f'21'3d'29 >>= withAttribute KeywordTok) >>~ pushContext ("MediaWiki","Section3")) + <|> + ((pColumn 0 >> pRegExpr regex_'5b'3d'5d'7b2'2c2'7d'28'3f'21'3d'29 >>= withAttribute KeywordTok) >>~ pushContext ("MediaWiki","Section2")) + <|> + ((pRegExpr regex_'5b'7e'5d'7b3'2c4'7d >>= withAttribute DecValTok)) + <|> + ((pColumn 0 >> pDetectChar False ';' >>= withAttribute DecValTok) >>~ pushContext ("MediaWiki","DefinitionListHeader")) + <|> + ((parseRules ("MediaWiki","FindListItem"))) + <|> + ((parseRules ("MediaWiki","FindUrl"))) + <|> + ((parseRules ("MediaWiki","FindTextDecorations"))) + <|> + ((parseRules ("MediaWiki","FindTable"))) + <|> + ((pString False "{{{" >>= withAttribute DecValTok) >>~ pushContext ("MediaWiki","TemplateParameter")) + <|> + ((parseRules ("MediaWiki","FindTemplate"))) + <|> + ((parseRules ("MediaWiki","FindWikiLink"))) + <|> + ((parseRules ("MediaWiki","FindHtmlEntities"))) + <|> + ((pString False "" >>= withAttribute DecValTok) >>~ pushContext ("MediaWiki","NoWiki")) + <|> + ((pString False "
" >>= withAttribute KeywordTok) >>~ pushContext ("MediaWiki","Pre"))
+   <|>
+   ((parseRules ("MediaWiki","FindSyntaxHighlightingHtmlElement")))
+   <|>
+   ((pRegExpr regex_'5b'3c'5d'5b'5e'3e'5d'2b'5b'3e'5d >>= withAttribute KeywordTok))
+   <|>
+   ((pColumn 0 >> pRegExpr regex_'5b'5cs'5d >>= withAttribute NormalTok) >>~ pushContext ("MediaWiki","Unformatted"))
+   <|>
+   (currentContext >>= \x -> guard (x == ("MediaWiki","normal")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("MediaWiki","TableHeader") =
+  (((pDetect2Chars False '{' '|' >>= withAttribute DecValTok))
+   <|>
+   ((parseRules ("MediaWiki","FindHtmlStartTagAttributes")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("MediaWiki","TableHeader")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("MediaWiki","TableContent") =
+  (((pString False "" >>= withAttribute CommentTok) >>~ (popContext))
+   <|>
+   (currentContext >>= \x -> guard (x == ("MediaWiki","comment")) >> pDefault >>= withAttribute CommentTok))
+
+parseRules ("MediaWiki","DelimitedURL") =
+  (((pDetectChar False ']' >>= withAttribute DecValTok) >>~ (popContext))
+   <|>
+   ((pDetectChar False '[' >>= withAttribute DecValTok))
+   <|>
+   ((lookAhead (pRegExpr regex_'28http'3a'7chttps'3a'7cftp'3a'7cmailto'3a'29'5b'5e'5d'7c_'5d'2a'28'3f'3d'24'7c'5b'5d'7c'5cs'5d'29) >> pushContext ("MediaWiki","DelimitedUrlLink") >> currentContext >>= parseRules))
+   <|>
+   ((pDetectChar False ' ' >>= withAttribute DecValTok) >>~ pushContext ("MediaWiki","URLTag"))
+   <|>
+   (currentContext >>= \x -> guard (x == ("MediaWiki","DelimitedURL")) >> pDefault >>= withAttribute OtherTok))
+
+parseRules ("MediaWiki","DelimitedUrlLink") =
+  (((parseRules ("MediaWiki","FindTemplate")))
+   <|>
+   ((lookAhead (pDetectChar False ' ') >> (popContext) >> currentContext >>= parseRules))
+   <|>
+   ((lookAhead (pDetectChar False ']') >> (popContext) >> currentContext >>= parseRules))
+   <|>
+   (currentContext >>= \x -> guard (x == ("MediaWiki","DelimitedUrlLink")) >> pDefault >>= withAttribute OtherTok))
+
+parseRules ("MediaWiki","LooseURL") =
+  (((parseRules ("MediaWiki","FindTemplate")))
+   <|>
+   ((pDetectChar False ' ' >>= withAttribute DecValTok) >>~ (popContext))
+   <|>
+   (currentContext >>= \x -> guard (x == ("MediaWiki","LooseURL")) >> pDefault >>= withAttribute OtherTok))
+
+parseRules ("MediaWiki","LooseURLWithinTemplate") =
+  (((parseRules ("MediaWiki","FindTemplate")))
+   <|>
+   ((lookAhead (pDetect2Chars False '}' '}') >> (popContext) >> currentContext >>= parseRules))
+   <|>
+   ((pDetectChar False ' ' >>= withAttribute DecValTok) >>~ (popContext))
+   <|>
+   (currentContext >>= \x -> guard (x == ("MediaWiki","LooseURLWithinTemplate")) >> pDefault >>= withAttribute OtherTok))
+
+parseRules ("MediaWiki","URLTag") =
+  (((parseRules ("MediaWiki","FindTextDecorations")))
+   <|>
+   ((parseRules ("MediaWiki","FindTemplate")))
+   <|>
+   ((lookAhead (pDetectChar False ']') >> (popContext) >> currentContext >>= parseRules))
+   <|>
+   (currentContext >>= \x -> guard (x == ("MediaWiki","URLTag")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("MediaWiki","WikiLinkWithoutDescriptionRules") =
+  (((parseRules ("MediaWiki","FindTemplate")))
+   <|>
+   ((parseRules ("MediaWiki","FindHtmlEntities")))
+   <|>
+   ((pDetect2Chars False '[' '[' >>= withAttribute DecValTok))
+   <|>
+   ((pDetect2Chars False ']' ']' >>= withAttribute DecValTok) >>~ (popContext))
+   <|>
+   (currentContext >>= \x -> guard (x == ("MediaWiki","WikiLinkWithoutDescriptionRules")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("MediaWiki","WikiLinkWithDescriptionRules") =
+  (((parseRules ("MediaWiki","WikiLinkWithoutDescriptionRules")))
+   <|>
+   ((pDetectChar False '#' >>= withAttribute DecValTok))
+   <|>
+   (currentContext >>= \x -> guard (x == ("MediaWiki","WikiLinkWithDescriptionRules")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("MediaWiki","WikiLink") =
+  (((parseRules ("MediaWiki","WikiLinkWithDescriptionRules")))
+   <|>
+   ((pDetectChar False '|' >>= withAttribute DecValTok) >>~ pushContext ("MediaWiki","WikiLinkDescription"))
+   <|>
+   (currentContext >>= \x -> guard (x == ("MediaWiki","WikiLink")) >> pDefault >>= withAttribute OtherTok))
+
+parseRules ("MediaWiki","WikiLinkBoldWithDescription") =
+  (((parseRules ("MediaWiki","WikiLinkWithDescriptionRules")))
+   <|>
+   ((pDetectChar False '|' >>= withAttribute DecValTok) >>~ pushContext ("MediaWiki","WikiLinkDescriptionBold"))
+   <|>
+   (currentContext >>= \x -> guard (x == ("MediaWiki","WikiLinkBoldWithDescription")) >> pDefault >>= withAttribute OtherTok))
+
+parseRules ("MediaWiki","WikiLinkBoldWithoutDescription") =
+  (((parseRules ("MediaWiki","WikiLinkWithoutDescriptionRules")))
+   <|>
+   ((pDetectChar False '#' >>= withAttribute DecValTok))
+   <|>
+   (currentContext >>= \x -> guard (x == ("MediaWiki","WikiLinkBoldWithoutDescription")) >> pDefault >>= withAttribute OtherTok))
+
+parseRules ("MediaWiki","WikiLinkItalicWithDescription") =
+  (((parseRules ("MediaWiki","WikiLinkWithDescriptionRules")))
+   <|>
+   ((pDetectChar False '|' >>= withAttribute DecValTok) >>~ pushContext ("MediaWiki","WikiLinkDescriptionItalic"))
+   <|>
+   (currentContext >>= \x -> guard (x == ("MediaWiki","WikiLinkItalicWithDescription")) >> pDefault >>= withAttribute OtherTok))
+
+parseRules ("MediaWiki","WikiLinkItalicWithoutDescription") =
+  (((parseRules ("MediaWiki","WikiLinkWithoutDescriptionRules")))
+   <|>
+   ((pDetectChar False '#' >>= withAttribute DecValTok))
+   <|>
+   (currentContext >>= \x -> guard (x == ("MediaWiki","WikiLinkItalicWithoutDescription")) >> pDefault >>= withAttribute OtherTok))
+
+parseRules ("MediaWiki","WikiLinkUnderlinedWithDescription") =
+  (((parseRules ("MediaWiki","WikiLinkWithDescriptionRules")))
+   <|>
+   ((pDetectChar False '|' >>= withAttribute DecValTok) >>~ pushContext ("MediaWiki","WikiLinkDescriptionUnderlined"))
+   <|>
+   (currentContext >>= \x -> guard (x == ("MediaWiki","WikiLinkUnderlinedWithDescription")) >> pDefault >>= withAttribute OtherTok))
+
+parseRules ("MediaWiki","WikiLinkUnderlinedWithoutDescription") =
+  (((parseRules ("MediaWiki","WikiLinkWithoutDescriptionRules")))
+   <|>
+   ((pDetectChar False '#' >>= withAttribute DecValTok))
+   <|>
+   (currentContext >>= \x -> guard (x == ("MediaWiki","WikiLinkUnderlinedWithoutDescription")) >> pDefault >>= withAttribute OtherTok))
+
+parseRules ("MediaWiki","WikiLinkBoldItalicWithDescription") =
+  (((parseRules ("MediaWiki","WikiLinkWithDescriptionRules")))
+   <|>
+   ((pDetectChar False '|' >>= withAttribute DecValTok) >>~ pushContext ("MediaWiki","WikiLinkDescriptionBoldItalic"))
+   <|>
+   (currentContext >>= \x -> guard (x == ("MediaWiki","WikiLinkBoldItalicWithDescription")) >> pDefault >>= withAttribute OtherTok))
+
+parseRules ("MediaWiki","WikiLinkBoldItalicWithoutDescription") =
+  (((parseRules ("MediaWiki","WikiLinkWithoutDescriptionRules")))
+   <|>
+   ((pDetectChar False '#' >>= withAttribute DecValTok))
+   <|>
+   (currentContext >>= \x -> guard (x == ("MediaWiki","WikiLinkBoldItalicWithoutDescription")) >> pDefault >>= withAttribute OtherTok))
+
+parseRules ("MediaWiki","WikiLinkBoldUnderlinedWithDescription") =
+  (((parseRules ("MediaWiki","WikiLinkWithDescriptionRules")))
+   <|>
+   ((pDetectChar False '|' >>= withAttribute DecValTok) >>~ pushContext ("MediaWiki","WikiLinkDescriptionBoldUnderlined"))
+   <|>
+   (currentContext >>= \x -> guard (x == ("MediaWiki","WikiLinkBoldUnderlinedWithDescription")) >> pDefault >>= withAttribute OtherTok))
+
+parseRules ("MediaWiki","WikiLinkBoldUnderlinedWithoutDescription") =
+  (((parseRules ("MediaWiki","WikiLinkWithoutDescriptionRules")))
+   <|>
+   ((pDetectChar False '#' >>= withAttribute DecValTok))
+   <|>
+   (currentContext >>= \x -> guard (x == ("MediaWiki","WikiLinkBoldUnderlinedWithoutDescription")) >> pDefault >>= withAttribute OtherTok))
+
+parseRules ("MediaWiki","WikiLinkItalicUnderlinedWithDescription") =
+  (((parseRules ("MediaWiki","WikiLinkWithDescriptionRules")))
+   <|>
+   ((pDetectChar False '|' >>= withAttribute DecValTok) >>~ pushContext ("MediaWiki","WikiLinkDescriptionItalicUnderlined"))
+   <|>
+   (currentContext >>= \x -> guard (x == ("MediaWiki","WikiLinkItalicUnderlinedWithDescription")) >> pDefault >>= withAttribute OtherTok))
+
+parseRules ("MediaWiki","WikiLinkItalicUnderlinedWithoutDescription") =
+  (((parseRules ("MediaWiki","WikiLinkWithoutDescriptionRules")))
+   <|>
+   ((pDetectChar False '#' >>= withAttribute DecValTok))
+   <|>
+   (currentContext >>= \x -> guard (x == ("MediaWiki","WikiLinkItalicUnderlinedWithoutDescription")) >> pDefault >>= withAttribute OtherTok))
+
+parseRules ("MediaWiki","WikiLinkBoldItalicUnderlinedWithDescription") =
+  (((parseRules ("MediaWiki","WikiLinkWithDescriptionRules")))
+   <|>
+   ((pDetectChar False '|' >>= withAttribute DecValTok) >>~ pushContext ("MediaWiki","WikiLinkDescriptionBoldItalicUnderlined"))
+   <|>
+   (currentContext >>= \x -> guard (x == ("MediaWiki","WikiLinkBoldItalicUnderlinedWithDescription")) >> pDefault >>= withAttribute OtherTok))
+
+parseRules ("MediaWiki","WikiLinkBoldItalicUnderlinedWithoutDescription") =
+  (((pDetectChar False '#' >>= withAttribute DecValTok))
+   <|>
+   ((parseRules ("MediaWiki","WikiLinkWithoutDescriptionRules")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("MediaWiki","WikiLinkBoldItalicUnderlinedWithoutDescription")) >> pDefault >>= withAttribute OtherTok))
+
+parseRules ("MediaWiki","WikiLinkDescriptionRules") =
+  (((parseRules ("MediaWiki","FindTemplate")))
+   <|>
+   ((parseRules ("MediaWiki","FindHtmlEntities")))
+   <|>
+   ((lookAhead (pDetect2Chars False ']' ']') >> (popContext) >> currentContext >>= parseRules))
+   <|>
+   (currentContext >>= \x -> guard (x == ("MediaWiki","WikiLinkDescriptionRules")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("MediaWiki","WikiLinkDescription") =
+  (((parseRules ("MediaWiki","WikiLinkDescriptionRules")))
+   <|>
+   ((parseRules ("MediaWiki","FindTextDecorations")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("MediaWiki","WikiLinkDescription")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("MediaWiki","WikiLinkDescriptionBold") =
+  (((parseRules ("MediaWiki","WikiLinkDescriptionRules")))
+   <|>
+   ((pString False "''" >>= withAttribute DecValTok) >>~ pushContext ("MediaWiki","BoldItalic"))
+   <|>
+   ((pRegExpr regex_'3cu_'2a'3e >>= withAttribute KeywordTok) >>~ pushContext ("MediaWiki","BoldUnderlined"))
+   <|>
+   (currentContext >>= \x -> guard (x == ("MediaWiki","WikiLinkDescriptionBold")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("MediaWiki","WikiLinkDescriptionItalic") =
+  (((parseRules ("MediaWiki","WikiLinkDescriptionRules")))
+   <|>
+   ((pString False "'''" >>= withAttribute DecValTok) >>~ pushContext ("MediaWiki","ItalicBold"))
+   <|>
+   ((pRegExpr regex_'3cu_'2a'3e >>= withAttribute KeywordTok) >>~ pushContext ("MediaWiki","ItalicUnderlined"))
+   <|>
+   (currentContext >>= \x -> guard (x == ("MediaWiki","WikiLinkDescriptionItalic")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("MediaWiki","WikiLinkDescriptionUnderlined") =
+  (((parseRules ("MediaWiki","WikiLinkDescriptionRules")))
+   <|>
+   ((pString False "'''" >>= withAttribute DecValTok) >>~ pushContext ("MediaWiki","UnderlinedBold"))
+   <|>
+   ((pString False "''" >>= withAttribute DecValTok) >>~ pushContext ("MediaWiki","UnderlinedItalic"))
+   <|>
+   (currentContext >>= \x -> guard (x == ("MediaWiki","WikiLinkDescriptionUnderlined")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("MediaWiki","WikiLinkDescriptionBoldItalic") =
+  (((parseRules ("MediaWiki","WikiLinkDescriptionRules")))
+   <|>
+   ((pRegExpr regex_'3cu_'2a'3e >>= withAttribute KeywordTok) >>~ pushContext ("MediaWiki","BoldItalicUnderlined"))
+   <|>
+   (currentContext >>= \x -> guard (x == ("MediaWiki","WikiLinkDescriptionBoldItalic")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("MediaWiki","WikiLinkDescriptionBoldUnderlined") =
+  (((parseRules ("MediaWiki","WikiLinkDescriptionRules")))
+   <|>
+   ((pString False "''" >>= withAttribute DecValTok) >>~ pushContext ("MediaWiki","BoldUnderlinedItalic"))
+   <|>
+   (currentContext >>= \x -> guard (x == ("MediaWiki","WikiLinkDescriptionBoldUnderlined")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("MediaWiki","WikiLinkDescriptionItalicUnderlined") =
+  (((parseRules ("MediaWiki","WikiLinkDescriptionRules")))
+   <|>
+   ((pString False "'''" >>= withAttribute DecValTok) >>~ pushContext ("MediaWiki","ItalicUnderlinedBold"))
+   <|>
+   (currentContext >>= \x -> guard (x == ("MediaWiki","WikiLinkDescriptionItalicUnderlined")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("MediaWiki","WikiLinkDescriptionBoldItalicUnderlined") =
+  (((parseRules ("MediaWiki","WikiLinkDescriptionRules")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("MediaWiki","WikiLinkDescriptionBoldItalicUnderlined")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("MediaWiki","Template") =
+  (((pString False "|" >>= withAttribute DecValTok) >>~ pushContext ("MediaWiki","TemplateParameterSlot"))
+   <|>
+   ((pDetect2Chars False '}' '}' >>= withAttribute DecValTok) >>~ (popContext))
+   <|>
+   (currentContext >>= \x -> guard (x == ("MediaWiki","Template")) >> pDefault >>= withAttribute OtherTok))
+
+parseRules ("MediaWiki","TemplateParameterSlot") =
+  (((lookAhead (pDetect2Chars False '}' '}') >> (popContext) >> currentContext >>= parseRules))
+   <|>
+   ((pString False "" >>= withAttribute CommentTok) >>~ (popContext))
+   <|>
+   ((pRegExpr regex_'2d'28'2d'28'3f'21'2d'3e'29'29'2b >>= withAttribute NormalTok))
+   <|>
+   ((Text.Highlighting.Kate.Syntax.Alert.parseExpression (Just ("Alerts","")) >>= ((withAttribute CommentTok) . snd)))
+   <|>
+   ((pDetectIdentifier >>= withAttribute CommentTok))
+   <|>
+   (currentContext >>= \x -> guard (x == ("RELAX NG","comment")) >> pDefault >>= withAttribute CommentTok))
+
+parseRules ("Alerts", _) = Text.Highlighting.Kate.Syntax.Alert.parseExpression Nothing
+
+parseRules x = parseRules ("RELAX NG","normalText") <|> fail ("Unknown context" ++ show x)
diff --git a/Text/Highlighting/Kate/Syntax/Rest.hs b/Text/Highlighting/Kate/Syntax/Rest.hs
new file mode 100644
--- /dev/null
+++ b/Text/Highlighting/Kate/Syntax/Rest.hs
@@ -0,0 +1,187 @@
+{- This module was generated from data in the Kate syntax
+   highlighting file rest.xml, version 1.4, by  -}
+
+module Text.Highlighting.Kate.Syntax.Rest
+          (highlight, parseExpression, syntaxName, syntaxExtensions)
+where
+import Text.Highlighting.Kate.Types
+import Text.Highlighting.Kate.Common
+import qualified Text.Highlighting.Kate.Syntax.Alert
+import Text.ParserCombinators.Parsec hiding (State)
+import Control.Monad.State
+import Data.Char (isSpace)
+
+-- | Full name of language.
+syntaxName :: String
+syntaxName = "reStructuredText"
+
+-- | Filename extensions for this language.
+syntaxExtensions :: String
+syntaxExtensions = "*.rst"
+
+-- | Highlight source code using this syntax definition.
+highlight :: String -> [SourceLine]
+highlight input = evalState (mapM parseSourceLine $ lines input) startingState
+
+parseSourceLine :: String -> State SyntaxState SourceLine
+parseSourceLine = mkParseSourceLine (parseExpression Nothing)
+
+-- | Parse an expression using appropriate local context.
+parseExpression :: Maybe (String,String)
+                -> KateParser Token
+parseExpression mbcontext = do
+  (lang,cont) <- maybe currentContext return mbcontext
+  result <- parseRules (lang,cont)
+  optional $ do eof
+                updateState $ \st -> st{ synStPrevChar = '\n' }
+                pEndLine
+  return result
+
+startingState = SyntaxState {synStContexts = [("reStructuredText","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}
+
+pEndLine = do
+  updateState $ \st -> st{ synStPrevNonspace = False }
+  context <- currentContext
+  contexts <- synStContexts `fmap` getState
+  if length contexts >= 2
+    then case context of
+      ("reStructuredText","Normal") -> return ()
+      ("reStructuredText","InlineMarkup") -> return ()
+      ("reStructuredText","Field") -> return ()
+      ("reStructuredText","InterpretedText") -> (popContext) >> pEndLine
+      ("reStructuredText","Role") -> (popContext) >> pEndLine
+      ("reStructuredText","TrailingRole") -> (popContext) >> pEndLine
+      ("reStructuredText","Comment") -> return ()
+      ("reStructuredText","CodeBlock") -> return ()
+      ("reStructuredText","Code") -> return ()
+      _ -> return ()
+    else return ()
+
+withAttribute attr txt = do
+  when (null txt) $ fail "Parser matched no text"
+  updateState $ \st -> st { synStPrevChar = last txt
+                          , synStPrevNonspace = synStPrevNonspace st || not (all isSpace txt) }
+  return (attr, txt)
+
+
+regex_'28'5e'7c'5b'2d'5cs'27'22'5c'28'5c'5b'7b'3c'2f'3a'2018'201c'2019'ab'a1'bf'2010'2011'2012'2013'2014_'5d'29'5c'2a'5c'2a'5b'5e'5cs'5d'2e'2a'5c'2a'5c'2a'28'3f'3d'5b'2d'5cs'2019'201d'bb'2010'2011'2012'2013'2014_'27'22'5c'29'5c'5d'7d'3e'2f'3a'5c'2e'2c'3b'21'5c'3f'5c'5c'5d'7c'24'29 = compileRegex True "(^|[-\\s'\"\\(\\[{/:\\.,;!\\?\\\\]|$)"
+regex_'28'5e'7c'5b'2d'5cs'27'22'5c'28'5c'5b'7b'3c'2f'3a'2018'201c'2019'ab'a1'bf'2010'2011'2012'2013'2014_'5d'29'5c'2a'5b'5e'5cs'5d'2e'2a'5c'2a'28'3f'3d'5b'2d'5cs'2019'201d'bb'2010'2011'2012'2013'2014_'27'22'5c'29'5c'5d'7d'3e'2f'3a'5c'2e'2c'3b'21'5c'3f'5c'5c'5d'7c'24'29 = compileRegex True "(^|[-\\s'\"\\(\\[{/:\\.,;!\\?\\\\]|$)"
+regex_'5cs'2a'5c'2e'5c'2e_'5c'5b'28'5cd'2b'7c'23'7c'5c'2a'7c'23'5b'5cw'5f'5c'2e'3a'5c'2b'2d'5d'2b'29'5c'5d'5cs = compileRegex True "\\s*\\.\\. \\[(\\d+|#|\\*|#[\\w_\\.:\\+-]+)\\]\\s"
+regex_'5cs'2a'5c'2e'5c'2e_'5c'5b'5b'5cw'5f'5c'2e'3a'5c'2b'2d'5d'2b'5c'5d'5cs = compileRegex True "\\s*\\.\\. \\[[\\w_\\.:\\+-]+\\]\\s"
+regex_'5cs'2a'28'5c'2e'5c'2e_'28'5f'5f'3a'7c'5f'5b'5cw'5f'5c'2e'3a'5c'2b'2d_'5d'2b'3a'28'5cs'7c'24'29'29'7c'5f'5f_'29 = compileRegex True "\\s*(\\.\\. (__:|_[\\w_\\.:\\+- ]+:(\\s|$))|__ )"
+regex_'5cs'2a'5c'2e'5c'2e_code'2dblock'3a'3a = compileRegex True "\\s*\\.\\. code-block::"
+regex_'5cs'2a'5c'2e'5c'2e_'5b'5cw'2d'5f'5c'2e'5d'2b'3a'3a'28'5cs'7c'24'29 = compileRegex True "\\s*\\.\\. [\\w-_\\.]+::(\\s|$)"
+regex_'3a'3a'24 = compileRegex True "::$"
+regex_'5cs'2a'5c'2e'5c'2e_'5c'7c'5b'5cw'5f'5c'2e'3a'5c'2b'2d_'5d'2b'5c'7c'5cs'2b'5b'5cw'5f'5c'2e'3a'5c'2b'2d'5d'2b'3a'3a'5cs = compileRegex True "\\s*\\.\\. \\|[\\w_\\.:\\+- ]+\\|\\s+[\\w_\\.:\\+-]+::\\s"
+regex_'3a'28'3f'3d'28'5b'5e'3a'5d'2a'5c'5c'3a'29'2a'5b'5e'3a'5d'2a'3a'28'5cs'7c'24'29'29 = compileRegex True ":(?=([^:]*\\\\:)*[^:]*:(\\s|$))"
+regex_'28'5cs'2a'29'5c'2e'5c'2e'5cs'28'3f'21'5b'5cw'2d'5f'5c'2e'5d'2b'3a'3a'28'5cs'7c'24'29'29 = compileRegex True "(\\s*)\\.\\.\\s(?![\\w-_\\.]+::(\\s|$))"
+regex_'28'5e'7c'5b'2d'5cs'27'22'5c'28'5c'5b'7b'3c'2f'3a'2018'201c'2019'ab'a1'bf'2010'2011'2012'2013'2014_'5d'29'60'60'5b'5e'5cs'5d'2e'2a'60'60'28'3f'3d'5b'2d'5cs'2019'201d'bb'2010'2011'2012'2013'2014_'27'22'5c'29'5c'5d'7d'3e'2f'3a'5c'2e'2c'3b'21'5c'3f'5c'5c'5d'7c'24'29 = compileRegex True "(^|[-\\s'\"\\(\\[{/:\\.,;!\\?\\\\]|$)"
+regex_'28'5e'7c'5b'2d'5cs'27'22'5c'28'5c'5b'7b'3c'2f'3a'2018'201c'2019'ab'a1'bf'2010'2011'2012'2013'2014_'5d'29'5c'7c'5b'5e'5cs'5d'2e'2a'5c'7c'28'3f'3d'5b'2d'5cs'2019'201d'bb'2010'2011'2012'2013'2014_'27'22'5c'29'5c'5d'7d'3e'2f'3a'5c'2e'2c'3b'21'5c'3f'5c'5c'5d'7c'24'29 = compileRegex True "(^|[-\\s'\"\\(\\[{/:\\.,;!\\?\\\\]|$)"
+regex_'28'5e'7c'5b'2d'5cs'27'22'5c'28'5c'5b'7b'3c'2f'3a'2018'201c'2019'ab'a1'bf'2010'2011'2012'2013'2014_'5d'29'5f'60'5b'5e'5cs'5d'2e'2a'60'28'3f'3d'5b'2d'5cs'2019'201d'bb'2010'2011'2012'2013'2014_'27'22'5c'29'5c'5d'7d'3e'2f'3a'5c'2e'2c'3b'21'5c'3f'5c'5c'5d'7c'24'29 = compileRegex True "(^|[-\\s'\"\\(\\[{/:\\.,;!\\?\\\\]|$)"
+regex_'28'5e'7c'5b'2d'5cs'27'22'5c'28'5c'5b'7b'3c'2f'3a'2018'201c'2019'ab'a1'bf'2010'2011'2012'2013'2014_'5d'29'5c'5b'5b'5cw'5f'5c'2e'3a'5c'2b'2d'5d'2b'5c'5d'5f'28'3f'3d'5b'2d'5cs'2019'201d'bb'2010'2011'2012'2013'2014_'27'22'5c'29'5c'5d'7d'3e'2f'3a'5c'2e'2c'3b'21'5c'3f'5c'5c'5d'7c'24'29 = compileRegex True "(^|[-\\s'\"\\(\\[{/:\\.,;!\\?\\\\]|$)"
+regex_'28'5e'7c'5b'2d'5cs'27'22'5c'28'5c'5b'7b'3c'2f'3a'2018'201c'2019'ab'a1'bf'2010'2011'2012'2013'2014_'5d'29'60'5b'5e'5cs'5d'2e'2a'60'5f'28'3f'3d'5b'2d'5cs'2019'201d'bb'2010'2011'2012'2013'2014_'27'22'5c'29'5c'5d'7d'3e'2f'3a'5c'2e'2c'3b'21'5c'3f'5c'5c'5d'7c'24'29 = compileRegex True "(^|[-\\s'\"\\(\\[{/:\\.,;!\\?\\\\]|$)"
+regex_'28'5e'7c'5b'2d'5cs'27'22'5c'28'5c'5b'7b'3c'2f'3a'2018'201c'2019'ab'a1'bf'2010'2011'2012'2013'2014_'5d'29'5cw'2b'5f'28'3f'3d'5b'2d'5cs'2019'201d'bb'2010'2011'2012'2013'2014_'27'22'5c'29'5c'5d'7d'3e'2f'3a'5c'2e'2c'3b'21'5c'3f'5c'5c'5d'7c'24'29 = compileRegex True "(^|[-\\s'\"\\(\\[{/:\\.,;!\\?\\\\]|$)"
+regex_'28'5e'7c'5b'2d'5cs'27'22'5c'28'5c'5b'7b'3c'2f'3a'2018'201c'2019'ab'a1'bf'2010'2011'2012'2013'2014_'5d'29'60'5b'5e'5cs'5d'2e'2a'60'28'3f'3d'3a'5b'5cw'2d'5f'5c'2e'5c'2b'5d'2b'3a'29 = compileRegex True "(^|[-\\s'\"\\(\\[{>= withAttribute NormalTok))
+   <|>
+   ((pRegExpr regex_'28'5e'7c'5b'2d'5cs'27'22'5c'28'5c'5b'7b'3c'2f'3a'2018'201c'2019'ab'a1'bf'2010'2011'2012'2013'2014_'5d'29'5c'2a'5b'5e'5cs'5d'2e'2a'5c'2a'28'3f'3d'5b'2d'5cs'2019'201d'bb'2010'2011'2012'2013'2014_'27'22'5c'29'5c'5d'7d'3e'2f'3a'5c'2e'2c'3b'21'5c'3f'5c'5c'5d'7c'24'29 >>= withAttribute NormalTok))
+   <|>
+   ((parseRules ("reStructuredText","InlineMarkup")))
+   <|>
+   ((pColumn 0 >> pRegExpr regex_'5cs'2a'5c'2e'5c'2e_'5c'5b'28'5cd'2b'7c'23'7c'5c'2a'7c'23'5b'5cw'5f'5c'2e'3a'5c'2b'2d'5d'2b'29'5c'5d'5cs >>= withAttribute DataTypeTok))
+   <|>
+   ((pColumn 0 >> pRegExpr regex_'5cs'2a'5c'2e'5c'2e_'5c'5b'5b'5cw'5f'5c'2e'3a'5c'2b'2d'5d'2b'5c'5d'5cs >>= withAttribute DataTypeTok))
+   <|>
+   ((pColumn 0 >> pRegExpr regex_'5cs'2a'28'5c'2e'5c'2e_'28'5f'5f'3a'7c'5f'5b'5cw'5f'5c'2e'3a'5c'2b'2d_'5d'2b'3a'28'5cs'7c'24'29'29'7c'5f'5f_'29 >>= withAttribute DataTypeTok))
+   <|>
+   ((pColumn 0 >> pRegExpr regex_'5cs'2a'5c'2e'5c'2e_code'2dblock'3a'3a >>= withAttribute DataTypeTok) >>~ pushContext ("reStructuredText","CodeBlock"))
+   <|>
+   ((pColumn 0 >> pRegExpr regex_'5cs'2a'5c'2e'5c'2e_'5b'5cw'2d'5f'5c'2e'5d'2b'3a'3a'28'5cs'7c'24'29 >>= withAttribute DataTypeTok))
+   <|>
+   ((pRegExpr regex_'3a'3a'24 >>= withAttribute DataTypeTok) >>~ pushContext ("reStructuredText","CodeBlock"))
+   <|>
+   ((pColumn 0 >> pRegExpr regex_'5cs'2a'5c'2e'5c'2e_'5c'7c'5b'5cw'5f'5c'2e'3a'5c'2b'2d_'5d'2b'5c'7c'5cs'2b'5b'5cw'5f'5c'2e'3a'5c'2b'2d'5d'2b'3a'3a'5cs >>= withAttribute DataTypeTok))
+   <|>
+   ((pFirstNonSpace >> pRegExpr regex_'3a'28'3f'3d'28'5b'5e'3a'5d'2a'5c'5c'3a'29'2a'5b'5e'3a'5d'2a'3a'28'5cs'7c'24'29'29 >>= withAttribute FunctionTok) >>~ pushContext ("reStructuredText","Field"))
+   <|>
+   ((pColumn 0 >> pRegExpr regex_'28'5cs'2a'29'5c'2e'5c'2e'5cs'28'3f'21'5b'5cw'2d'5f'5c'2e'5d'2b'3a'3a'28'5cs'7c'24'29'29 >>= withAttribute CommentTok) >>~ pushContext ("reStructuredText","Comment"))
+   <|>
+   (currentContext >>= \x -> guard (x == ("reStructuredText","Normal")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("reStructuredText","InlineMarkup") =
+  (((pRegExpr regex_'28'5e'7c'5b'2d'5cs'27'22'5c'28'5c'5b'7b'3c'2f'3a'2018'201c'2019'ab'a1'bf'2010'2011'2012'2013'2014_'5d'29'60'60'5b'5e'5cs'5d'2e'2a'60'60'28'3f'3d'5b'2d'5cs'2019'201d'bb'2010'2011'2012'2013'2014_'27'22'5c'29'5c'5d'7d'3e'2f'3a'5c'2e'2c'3b'21'5c'3f'5c'5c'5d'7c'24'29 >>= withAttribute DataTypeTok))
+   <|>
+   ((pRegExpr regex_'28'5e'7c'5b'2d'5cs'27'22'5c'28'5c'5b'7b'3c'2f'3a'2018'201c'2019'ab'a1'bf'2010'2011'2012'2013'2014_'5d'29'5c'7c'5b'5e'5cs'5d'2e'2a'5c'7c'28'3f'3d'5b'2d'5cs'2019'201d'bb'2010'2011'2012'2013'2014_'27'22'5c'29'5c'5d'7d'3e'2f'3a'5c'2e'2c'3b'21'5c'3f'5c'5c'5d'7c'24'29 >>= withAttribute FunctionTok))
+   <|>
+   ((pRegExpr regex_'28'5e'7c'5b'2d'5cs'27'22'5c'28'5c'5b'7b'3c'2f'3a'2018'201c'2019'ab'a1'bf'2010'2011'2012'2013'2014_'5d'29'5f'60'5b'5e'5cs'5d'2e'2a'60'28'3f'3d'5b'2d'5cs'2019'201d'bb'2010'2011'2012'2013'2014_'27'22'5c'29'5c'5d'7d'3e'2f'3a'5c'2e'2c'3b'21'5c'3f'5c'5c'5d'7c'24'29 >>= withAttribute FunctionTok))
+   <|>
+   ((pRegExpr regex_'28'5e'7c'5b'2d'5cs'27'22'5c'28'5c'5b'7b'3c'2f'3a'2018'201c'2019'ab'a1'bf'2010'2011'2012'2013'2014_'5d'29'5c'5b'5b'5cw'5f'5c'2e'3a'5c'2b'2d'5d'2b'5c'5d'5f'28'3f'3d'5b'2d'5cs'2019'201d'bb'2010'2011'2012'2013'2014_'27'22'5c'29'5c'5d'7d'3e'2f'3a'5c'2e'2c'3b'21'5c'3f'5c'5c'5d'7c'24'29 >>= withAttribute OtherTok))
+   <|>
+   ((pRegExpr regex_'28'5e'7c'5b'2d'5cs'27'22'5c'28'5c'5b'7b'3c'2f'3a'2018'201c'2019'ab'a1'bf'2010'2011'2012'2013'2014_'5d'29'60'5b'5e'5cs'5d'2e'2a'60'5f'28'3f'3d'5b'2d'5cs'2019'201d'bb'2010'2011'2012'2013'2014_'27'22'5c'29'5c'5d'7d'3e'2f'3a'5c'2e'2c'3b'21'5c'3f'5c'5c'5d'7c'24'29 >>= withAttribute OtherTok))
+   <|>
+   ((pRegExpr regex_'28'5e'7c'5b'2d'5cs'27'22'5c'28'5c'5b'7b'3c'2f'3a'2018'201c'2019'ab'a1'bf'2010'2011'2012'2013'2014_'5d'29'5cw'2b'5f'28'3f'3d'5b'2d'5cs'2019'201d'bb'2010'2011'2012'2013'2014_'27'22'5c'29'5c'5d'7d'3e'2f'3a'5c'2e'2c'3b'21'5c'3f'5c'5c'5d'7c'24'29 >>= withAttribute OtherTok))
+   <|>
+   ((pRegExpr regex_'28'5e'7c'5b'2d'5cs'27'22'5c'28'5c'5b'7b'3c'2f'3a'2018'201c'2019'ab'a1'bf'2010'2011'2012'2013'2014_'5d'29'60'5b'5e'5cs'5d'2e'2a'60'28'3f'3d'3a'5b'5cw'2d'5f'5c'2e'5c'2b'5d'2b'3a'29 >>= withAttribute DecValTok) >>~ pushContext ("reStructuredText","TrailingRole"))
+   <|>
+   ((pRegExpr regex_'3a'5b'5cw'2d'5f'5c'2e'5c'2b'5d'2b'3a'28'3f'3d'60'29 >>= withAttribute KeywordTok) >>~ pushContext ("reStructuredText","Role"))
+   <|>
+   (currentContext >>= \x -> guard (x == ("reStructuredText","InlineMarkup")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("reStructuredText","Field") =
+  (((pDetectChar False ':' >>= withAttribute FunctionTok) >>~ (popContext))
+   <|>
+   ((pDetect2Chars False '\\' ':' >>= withAttribute FunctionTok))
+   <|>
+   ((pRegExpr regex_'28'5e'7c'5b'2d'5cs'27'22'5c'28'5c'5b'7b'3c'2f'3a'2018'201c'2019'ab'a1'bf'2010'2011'2012'2013'2014_'5d'29'5c'2a'5c'2a'5b'5e'5cs'5d'2e'2a'5c'2a'5c'2a'28'3f'3d'5b'2d'5cs'2019'201d'bb'2010'2011'2012'2013'2014_'27'22'5c'29'5c'5d'7d'3e'2f'3a'5c'2e'2c'3b'21'5c'3f'5c'5c'5d'7c'24'29 >>= withAttribute FunctionTok))
+   <|>
+   ((pRegExpr regex_'28'5e'7c'5b'2d'5cs'27'22'5c'28'5c'5b'7b'3c'2f'3a'2018'201c'2019'ab'a1'bf'2010'2011'2012'2013'2014_'5d'29'5c'2a'5b'5e'5cs'5d'2e'2a'5c'2a'28'3f'3d'5b'2d'5cs'2019'201d'bb'2010'2011'2012'2013'2014_'27'22'5c'29'5c'5d'7d'3e'2f'3a'5c'2e'2c'3b'21'5c'3f'5c'5c'5d'7c'24'29 >>= withAttribute FunctionTok))
+   <|>
+   ((parseRules ("reStructuredText","InlineMarkup")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("reStructuredText","Field")) >> pDefault >>= withAttribute FunctionTok))
+
+parseRules ("reStructuredText","InterpretedText") =
+  (((pDetectChar False '`' >>= withAttribute DecValTok) >>~ (popContext))
+   <|>
+   (currentContext >>= \x -> guard (x == ("reStructuredText","InterpretedText")) >> pDefault >>= withAttribute DecValTok))
+
+parseRules ("reStructuredText","Role") =
+  (((pDetectChar False '`' >>= withAttribute DecValTok) >>~ (popContext))
+   <|>
+   (currentContext >>= \x -> guard (x == ("reStructuredText","Role")) >> pDefault >>= withAttribute KeywordTok))
+
+parseRules ("reStructuredText","TrailingRole") =
+  (((pRegExpr regex_'3a'5b'5cw'2d'5f'5c'2e'5c'2b'5d'2b'3a >>= withAttribute KeywordTok) >>~ (popContext))
+   <|>
+   (currentContext >>= \x -> guard (x == ("reStructuredText","TrailingRole")) >> pDefault >>= withAttribute KeywordTok))
+
+parseRules ("reStructuredText","Comment") =
+  (((pColumn 0 >> pRegExprDynamic "%1   " >>= withAttribute DataTypeTok))
+   <|>
+   ((pColumn 0 >> lookAhead (pRegExpr regex_'28'2e'7c'24'29) >> (popContext) >> currentContext >>= parseRules))
+   <|>
+   ((Text.Highlighting.Kate.Syntax.Alert.parseExpression (Just ("Alerts","")) >>= ((withAttribute CommentTok) . snd)))
+   <|>
+   (currentContext >>= \x -> guard (x == ("reStructuredText","Comment")) >> pDefault >>= withAttribute CommentTok))
+
+parseRules ("reStructuredText","CodeBlock") =
+  (((pColumn 0 >> pRegExpr regex_'28'5cs'2b'29'28'3f'3d'5cS'29 >>= withAttribute DataTypeTok) >>~ pushContext ("reStructuredText","Code"))
+   <|>
+   (currentContext >>= \x -> guard (x == ("reStructuredText","CodeBlock")) >> pDefault >>= withAttribute DataTypeTok))
+
+parseRules ("reStructuredText","Code") =
+  (((pColumn 0 >> pRegExprDynamic "%1" >>= withAttribute DataTypeTok))
+   <|>
+   ((pColumn 0 >> lookAhead (pRegExpr regex_'28'2e'7c'24'29) >> (popContext >> popContext) >> currentContext >>= parseRules))
+   <|>
+   (currentContext >>= \x -> guard (x == ("reStructuredText","Code")) >> pDefault >>= withAttribute DataTypeTok))
+
+parseRules ("Alerts", _) = Text.Highlighting.Kate.Syntax.Alert.parseExpression Nothing
+
+parseRules x = parseRules ("reStructuredText","Normal") <|> fail ("Unknown context" ++ show x)
diff --git a/Text/Highlighting/Kate/Syntax/Restructuredtext.hs b/Text/Highlighting/Kate/Syntax/Restructuredtext.hs
deleted file mode 100644
--- a/Text/Highlighting/Kate/Syntax/Restructuredtext.hs
+++ /dev/null
@@ -1,126 +0,0 @@
-{- This module was generated from data in the Kate syntax
-   highlighting file restructuredtext.xml, version 1.0, by Massimiliano Torromeo (massimiliano.torromeo@gmail.com) -}
-
-module Text.Highlighting.Kate.Syntax.Restructuredtext
-          (highlight, parseExpression, syntaxName, syntaxExtensions)
-where
-import Text.Highlighting.Kate.Types
-import Text.Highlighting.Kate.Common
-import Text.ParserCombinators.Parsec hiding (State)
-import Control.Monad.State
-import Data.Char (isSpace)
-
--- | Full name of language.
-syntaxName :: String
-syntaxName = "Restructured Text"
-
--- | Filename extensions for this language.
-syntaxExtensions :: String
-syntaxExtensions = "*.rst"
-
--- | Highlight source code using this syntax definition.
-highlight :: String -> [SourceLine]
-highlight input = evalState (mapM parseSourceLine $ lines input) startingState
-
-parseSourceLine :: String -> State SyntaxState SourceLine
-parseSourceLine = mkParseSourceLine (parseExpression Nothing)
-
--- | Parse an expression using appropriate local context.
-parseExpression :: Maybe (String,String)
-                -> KateParser Token
-parseExpression mbcontext = do
-  (lang,cont) <- maybe currentContext return mbcontext
-  result <- parseRules (lang,cont)
-  optional $ do eof
-                updateState $ \st -> st{ synStPrevChar = '\n' }
-                pEndLine
-  return result
-
-startingState = SyntaxState {synStContexts = [("Restructured Text","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}
-
-pEndLine = do
-  updateState $ \st -> st{ synStPrevNonspace = False }
-  context <- currentContext
-  contexts <- synStContexts `fmap` getState
-  if length contexts >= 2
-    then case context of
-      ("Restructured Text","Normal") -> return ()
-      ("Restructured Text","CodeBlock") -> return ()
-      ("Restructured Text","Code") -> return ()
-      ("Restructured Text","Directive") -> (popContext) >> pEndLine
-      ("Restructured Text","Link") -> (popContext) >> pEndLine
-      ("Restructured Text","URL") -> return ()
-      _ -> return ()
-    else return ()
-
-withAttribute attr txt = do
-  when (null txt) $ fail "Parser matched no text"
-  updateState $ \st -> st { synStPrevChar = last txt
-                          , synStPrevNonspace = synStPrevNonspace st || not (all isSpace txt) }
-  return (attr, txt)
-
-
-regex_'5c'2a'5b'5e'2a_'5d'2e'2a'5cS'5c'2a = compileRegex True "\\*[^* ].*\\S\\*"
-regex_'5c'2a'5c'2a'5cS'2e'2a'5cS'5c'2a'5c'2a = compileRegex True "\\*\\*\\S.*\\S\\*\\*"
-regex_'60'60'5cS'2e'2a'5cS'60'60 = compileRegex True "``\\S.*\\S``"
-regex_'5c'2e'5c'2e_ = compileRegex True "\\.\\. "
-regex_'28'23'7b3'2c'7d'7c'5c'2a'7b3'2c'7d'7c'3d'7b3'2c'7d'7c'2d'7b3'2c'7d'7c'5c'5e'7b3'2c'7d'7c'22'7b3'2c'7d'7c'27'7b3'2c'7d'7c'7e'7b3'2c'7d'7c'60'7b3'2c'7d'7c'5c'2b'7b3'2c'7d'29'24 = compileRegex True "(#{3,}|\\*{3,}|={3,}|-{3,}|\\^{3,}|\"{3,}|'{3,}|~{3,}|`{3,}|\\+{3,})$"
-regex_'5b'230'2d9'5d'5c'2e'5cs = compileRegex True "[#0-9]\\.\\s"
-regex_'3a'3a'24 = compileRegex True "::$"
-regex_'5cs = compileRegex True "\\s"
-regex_'5cS = compileRegex True "\\S"
-regex_'5cw'2b = compileRegex True "\\w+"
-regex_'5b'5e'3e'5d'2b = compileRegex True "[^>]+"
-
-parseRules ("Restructured Text","Normal") =
-  (((pRegExpr regex_'5c'2a'5b'5e'2a_'5d'2e'2a'5cS'5c'2a >>= withAttribute NormalTok))
-   <|>
-   ((pRegExpr regex_'5c'2a'5c'2a'5cS'2e'2a'5cS'5c'2a'5c'2a >>= withAttribute NormalTok))
-   <|>
-   ((pRegExpr regex_'60'60'5cS'2e'2a'5cS'60'60 >>= withAttribute DataTypeTok))
-   <|>
-   ((pColumn 0 >> pRegExpr regex_'5c'2e'5c'2e_ >>= withAttribute DecValTok) >>~ pushContext ("Restructured Text","Directive"))
-   <|>
-   ((pColumn 0 >> pRegExpr regex_'28'23'7b3'2c'7d'7c'5c'2a'7b3'2c'7d'7c'3d'7b3'2c'7d'7c'2d'7b3'2c'7d'7c'5c'5e'7b3'2c'7d'7c'22'7b3'2c'7d'7c'27'7b3'2c'7d'7c'7e'7b3'2c'7d'7c'60'7b3'2c'7d'7c'5c'2b'7b3'2c'7d'29'24 >>= withAttribute KeywordTok))
-   <|>
-   ((pFirstNonSpace >> pRegExpr regex_'5b'230'2d9'5d'5c'2e'5cs >>= withAttribute DecValTok))
-   <|>
-   ((pFirstNonSpace >> pAnyChar "*+-" >>= withAttribute FloatTok))
-   <|>
-   ((pDetectChar False '`' >>= withAttribute StringTok) >>~ pushContext ("Restructured Text","Link"))
-   <|>
-   ((pRegExpr regex_'3a'3a'24 >>= withAttribute DataTypeTok) >>~ pushContext ("Restructured Text","CodeBlock"))
-   <|>
-   (currentContext >>= \x -> guard (x == ("Restructured Text","Normal")) >> pDefault >>= withAttribute NormalTok))
-
-parseRules ("Restructured Text","CodeBlock") =
-  (((pColumn 0 >> pRegExpr regex_'5cs >>= withAttribute DataTypeTok) >>~ pushContext ("Restructured Text","Code"))
-   <|>
-   (currentContext >>= \x -> guard (x == ("Restructured Text","CodeBlock")) >> pDefault >>= withAttribute DataTypeTok))
-
-parseRules ("Restructured Text","Code") =
-  (((pColumn 0 >> lookAhead (pRegExpr regex_'5cS) >> (popContext >> popContext) >> currentContext >>= parseRules))
-   <|>
-   (currentContext >>= \x -> guard (x == ("Restructured Text","Code")) >> pDefault >>= withAttribute DataTypeTok))
-
-parseRules ("Restructured Text","Directive") =
-  (((pRegExpr regex_'5cw'2b >>= withAttribute KeywordTok))
-   <|>
-   (currentContext >>= \x -> guard (x == ("Restructured Text","Directive")) >> pDefault >>= withAttribute DecValTok))
-
-parseRules ("Restructured Text","Link") =
-  (((pDetectChar False '<' >>= withAttribute StringTok) >>~ pushContext ("Restructured Text","URL"))
-   <|>
-   ((pDetect2Chars False '`' '_' >>= withAttribute StringTok) >>~ (popContext))
-   <|>
-   (currentContext >>= \x -> guard (x == ("Restructured Text","Link")) >> pDefault >>= withAttribute StringTok))
-
-parseRules ("Restructured Text","URL") =
-  (((pRegExpr regex_'5b'5e'3e'5d'2b >>= withAttribute StringTok))
-   <|>
-   ((pDetectChar False '>' >>= withAttribute StringTok) >>~ (popContext))
-   <|>
-   (currentContext >>= \x -> guard (x == ("Restructured Text","URL")) >> pDefault >>= withAttribute StringTok))
-
-
-parseRules x = parseRules ("Restructured Text","Normal") <|> fail ("Unknown context" ++ show x)
diff --git a/Text/Highlighting/Kate/Syntax/Tcsh.hs b/Text/Highlighting/Kate/Syntax/Tcsh.hs
new file mode 100644
--- /dev/null
+++ b/Text/Highlighting/Kate/Syntax/Tcsh.hs
@@ -0,0 +1,694 @@
+{- This module was generated from data in the Kate syntax
+   highlighting file tcsh.xml, version 0.2, by Matthew Woehlke (mw_triad@users.sourceforge.net) -}
+
+module Text.Highlighting.Kate.Syntax.Tcsh
+          (highlight, parseExpression, syntaxName, syntaxExtensions)
+where
+import Text.Highlighting.Kate.Types
+import Text.Highlighting.Kate.Common
+import qualified Text.Highlighting.Kate.Syntax.Alert
+import Text.ParserCombinators.Parsec hiding (State)
+import Control.Monad.State
+import Data.Char (isSpace)
+import qualified Data.Set as Set
+
+-- | Full name of language.
+syntaxName :: String
+syntaxName = "Tcsh"
+
+-- | Filename extensions for this language.
+syntaxExtensions :: String
+syntaxExtensions = "*.csh;*.tcsh;csh.cshrc;csh.login;.tcshrc;.cshrc;.login"
+
+-- | Highlight source code using this syntax definition.
+highlight :: String -> [SourceLine]
+highlight input = evalState (mapM parseSourceLine $ lines input) startingState
+
+parseSourceLine :: String -> State SyntaxState SourceLine
+parseSourceLine = mkParseSourceLine (parseExpression Nothing)
+
+-- | Parse an expression using appropriate local context.
+parseExpression :: Maybe (String,String)
+                -> KateParser Token
+parseExpression mbcontext = do
+  (lang,cont) <- maybe currentContext return mbcontext
+  result <- parseRules (lang,cont)
+  optional $ do eof
+                updateState $ \st -> st{ synStPrevChar = '\n' }
+                pEndLine
+  return result
+
+startingState = SyntaxState {synStContexts = [("Tcsh","Start")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}
+
+pEndLine = do
+  updateState $ \st -> st{ synStPrevNonspace = False }
+  context <- currentContext
+  contexts <- synStContexts `fmap` getState
+  if length contexts >= 2
+    then case context of
+      ("Tcsh","Start") -> return ()
+      ("Tcsh","FindAll") -> return ()
+      ("Tcsh","FindMost") -> return ()
+      ("Tcsh","FindComments") -> (popContext) >> pEndLine
+      ("Tcsh","Comment") -> (popContext) >> pEndLine
+      ("Tcsh","FindCommentsParen") -> (popContext) >> pEndLine
+      ("Tcsh","CommentParen") -> (popContext) >> pEndLine
+      ("Tcsh","FindCommentsBackq") -> (popContext) >> pEndLine
+      ("Tcsh","CommentBackq") -> (popContext) >> pEndLine
+      ("Tcsh","FindCommands") -> return ()
+      ("Tcsh","FindOthers") -> return ()
+      ("Tcsh","FindStrings") -> return ()
+      ("Tcsh","FindSubstitutions") -> return ()
+      ("Tcsh","FindTests") -> return ()
+      ("Tcsh","ExprDblParen") -> return ()
+      ("Tcsh","ExprDblParenSubst") -> return ()
+      ("Tcsh","ExprSubParen") -> return ()
+      ("Tcsh","ExprBracket") -> return ()
+      ("Tcsh","ExprDblBracket") -> return ()
+      ("Tcsh","Group") -> return ()
+      ("Tcsh","SubShell") -> return ()
+      ("Tcsh","Assign") -> (popContext) >> pEndLine
+      ("Tcsh","AssignArray") -> (popContext) >> pEndLine
+      ("Tcsh","AssignSubscr") -> (popContext) >> pEndLine
+      ("Tcsh","Subscript") -> return ()
+      ("Tcsh","FunctionDef") -> (popContext) >> pEndLine
+      ("Tcsh","CmdSetEnv") -> (popContext) >> pEndLine
+      ("Tcsh","VarName") -> (popContext) >> pEndLine
+      ("Tcsh","ProcessSubst") -> return ()
+      ("Tcsh","StringSQ") -> return ()
+      ("Tcsh","StringDQ") -> return ()
+      ("Tcsh","StringEsc") -> return ()
+      ("Tcsh","VarBrace") -> return ()
+      ("Tcsh","SubstFile") -> return ()
+      ("Tcsh","SubstCommand") -> return ()
+      ("Tcsh","SubstBackq") -> return ()
+      ("Tcsh","Switch") -> return ()
+      ("Tcsh","SwitchCase") -> return ()
+      ("Tcsh","SwitchDefault") -> return ()
+      ("Tcsh","SwitchExpr") -> return ()
+      ("Tcsh","HereDoc") -> return ()
+      ("Tcsh","HereDocRemainder") -> (popContext) >> pEndLine
+      ("Tcsh","HereDocQ") -> return ()
+      ("Tcsh","HereDocNQ") -> return ()
+      ("Tcsh","HereDocIQ") -> return ()
+      ("Tcsh","HereDocINQ") -> return ()
+      _ -> return ()
+    else return ()
+
+withAttribute attr txt = do
+  when (null txt) $ fail "Parser matched no text"
+  updateState $ \st -> st { synStPrevChar = last txt
+                          , synStPrevNonspace = synStPrevNonspace st || not (all isSpace txt) }
+  return (attr, txt)
+
+list_keywords = Set.fromList $ words $ "else for function in select until while . then"
+list_builtins = Set.fromList $ words $ ": alias alloc bg bindkey break builtins bye cd chdir complete continue dirs echo echotc eval exec exit fg filetest glob hashstat history hup inlib jobs kill limit log login logout ls-F migrate newgrp nice nohup notify onintr popd printenv pushd rehash repeat sched settc setty shift source stop suspend telltc time umask unalias uncomplete unhash unlimit ver wait watchlog where which"
+list_builtins'5fvar = Set.fromList $ words $ "unset unsetenv"
+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"
+
+regex_'5b'5cs'3b'5d'28'3f'3d'23'29 = compileRegex True "[\\s;](?=#)"
+regex_'5b'5e'29'5d'28'3f'3d'5c'29'29 = compileRegex True "[^)](?=\\))"
+regex_'5b'5e'60'5d'28'3f'3d'60'29 = compileRegex True "[^`](?=`)"
+regex_'5c'5b'5c'5b'28'3f'3d'28'24'7c'5cs'29'29 = compileRegex True "\\[\\[(?=($|\\s))"
+regex_'5cs'5c'5b'5c'5b'28'3f'3d'28'24'7c'5cs'29'29 = compileRegex True "\\s\\[\\[(?=($|\\s))"
+regex_'5c'5b'28'3f'3d'28'24'7c'5cs'29'29 = compileRegex True "\\[(?=($|\\s))"
+regex_'5cs'5c'5b'28'3f'3d'28'24'7c'5cs'29'29 = compileRegex True "\\s\\[(?=($|\\s))"
+regex_'5c'7b'28'3f'3d'28'24'7c'5cs'29'29 = compileRegex True "\\{(?=($|\\s))"
+regex_'5cbdo'28'3f'21'5b'5cw'24'2b'2d'5d'29 = compileRegex True "\\bdo(?![\\w$+-])"
+regex_'5cbdone'28'3f'21'5b'5cw'24'2b'2d'5d'29 = compileRegex True "\\bdone(?![\\w$+-])"
+regex_'5cbelse'5cs'2bif'28'3f'21'5b'5cw'24'2b'2d'5d'29 = compileRegex True "\\belse\\s+if(?![\\w$+-])"
+regex_'5cbif'28'3f'21'5b'5cw'24'2b'2d'5d'29 = compileRegex True "\\bif(?![\\w$+-])"
+regex_'5cbendif'28'3f'21'5b'5cw'24'2b'2d'5d'29 = compileRegex True "\\bendif(?![\\w$+-])"
+regex_'5cbswitch'28'3f'21'5b'5cw'24'2b'2d'5d'29 = compileRegex True "\\bswitch(?![\\w$+-])"
+regex_'2d'5bA'2dZa'2dz0'2d9'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a = compileRegex True "-[A-Za-z0-9][A-Za-z0-9_]*"
+regex_'2d'2d'5ba'2dz'5d'5bA'2dZa'2dz0'2d9'5f'2d'5d'2a = compileRegex True "--[a-z][A-Za-z0-9_-]*"
+regex_'5cb'40'5cs = compileRegex True "\\b@\\s"
+regex_'5cbset'5cs = compileRegex True "\\bset\\s"
+regex_'5cbsetenv'5cs = compileRegex True "\\bsetenv\\s"
+regex_'5cbfunction'5cb = compileRegex True "\\bfunction\\b"
+regex_'28'3c'3c'3f'7c'3e'3e'3f'26'3f'21'3f'29 = compileRegex True "(<>?&?!?)"
+regex_'28'5b'7c'26'5d'29'5c1'3f = compileRegex True "([|&])\\1?"
+regex_'5bA'2dZa'2dz'5f'3a'5d'5bA'2dZa'2dz0'2d9'5f'3a'23'25'40'2d'5d'2a'5cs'2a'5c'28'5c'29 = compileRegex True "[A-Za-z_:][A-Za-z0-9_:#%@-]*\\s*\\(\\)"
+regex_'5c'5c'5b'3b'22'5c'5c'27'24'60'7b'7d'28'29'7c'26'3c'3e'2a_'5d = compileRegex True "\\\\[;\"\\\\'$`{}()|&<>* ]"
+regex_'28'5b'5cw'5f'40'2e'25'2a'3f'2b'2d'5d'7c'5c'5c_'29'2a'28'3f'3d'2f'29 = compileRegex True "([\\w_@.%*?+-]|\\\\ )*(?=/)"
+regex_'7e'5cw'2a = compileRegex True "~\\w*"
+regex_'2f'28'5b'5cw'5f'40'2e'25'2a'3f'2b'2d'5d'7c'5c'5c_'29'2a'28'3f'3d'28'5b'5cs'2f'29'3a'3b'24'60'27'22'5d'7c'24'29'29 = compileRegex True "/([\\w_@.%*?+-]|\\\\ )*(?=([\\s/):;$`'\"]|$))"
+regex_'5c'24'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'5c'5b = compileRegex True "\\$[A-Za-z_][A-Za-z0-9_]*\\["
+regex_'5c'24'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a = compileRegex True "\\$[A-Za-z_][A-Za-z0-9_]*"
+regex_'5c'24'5b'2a'40'23'3f'24'21'5f0'2d9'2d'5d = compileRegex True "\\$[*@#?$!_0-9-]"
+regex_'5c'24'5c'7b'5b'2a'40'23'3f'24'21'5f0'2d9'2d'5d'5c'7d = compileRegex True "\\$\\{[*@#?$!_0-9-]\\}"
+regex_'5c'24'5c'7b'23'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'5c'7d = compileRegex True "\\$\\{#[A-Za-z_][A-Za-z0-9_]*\\}"
+regex_'5c'24'5c'7b'21'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'5c'2a'3f'5c'7d = compileRegex True "\\$\\{![A-Za-z_][A-Za-z0-9_]*\\*?\\}"
+regex_'5c'24'5c'7b'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a = compileRegex True "\\$\\{[A-Za-z_][A-Za-z0-9_]*"
+regex_'5c'24'5c'7b'5b'2a'40'23'3f'24'21'5f0'2d9'2d'5d'28'3f'3d'5b'3a'23'25'2f'5d'29 = compileRegex True "\\$\\{[*@#?$!_0-9-](?=[:#%/])"
+regex_'5c'5c'5b'60'24'5c'5c'5d = compileRegex True "\\\\[`$\\\\]"
+regex_'2d'5brwxXeozsfdlbcpSugktRLDIFNZ'5d'28'3f'3d'5cs'29 = compileRegex True "-[rwxXeozsfdlbcpSugktRLDIFNZ](?=\\s)"
+regex_'2d'5bAMCUG'5d'3a'3f'28'3f'3d'5cs'29 = compileRegex True "-[AMCUG]:?(?=\\s)"
+regex_'2dP'5b0'2d7'5d'7b'2c3'7d'3a'3f'28'3f'3d'5cs'29 = compileRegex True "-P[0-7]{,3}:?(?=\\s)"
+regex_'28'5b'7c'26'3d'3e'3c'5d'29'5c1 = compileRegex True "([|&=><])\\1"
+regex_'5b'7c'5e'26'3e'3c'2b'5c'2d'2a'2f'25'21'7e'5d = compileRegex True "[|^&><+\\-*/%!~]"
+regex_'28'5b'21'3d'5d'7e'7c'5b'21'3e'3c'5d'3d'29 = compileRegex True "([!=]~|[!><]=)"
+regex_'5cs'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 = compileRegex True "\\s\\](?=($|[\\s;|&]))"
+regex_'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 = compileRegex True "\\](?=($|[\\s;|&]))"
+regex_'5cs'5c'5d'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 = compileRegex True "\\s\\]\\](?=($|[\\s;|&]))"
+regex_'5c'5d'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 = compileRegex True "\\]\\](?=($|[\\s;|&]))"
+regex_'5b'5cw'3a'2c'2b'5f'2e'2f'2d'5d'2b = compileRegex True "[\\w:,+_./-]+"
+regex_'5cs'2b'5bA'2dZa'2dz'5f'3a'5d'5bA'2dZa'2dz0'2d9'5f'3a'23'25'40'2d'5d'2a'28'5cs'2a'5c'28'5c'29'29'3f = compileRegex True "\\s+[A-Za-z_:][A-Za-z0-9_:#%@-]*(\\s*\\(\\))?"
+regex_'5cb'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a = compileRegex True "\\b[A-Za-z_][A-Za-z0-9_]*"
+regex_'2d'5bA'2dZa'2dz0'2d9'5d'2b = compileRegex True "-[A-Za-z0-9]+"
+regex_'5b'5e'5d'7d'29'7c'3b'60'26'3e'3c'5d = compileRegex True "[^]})|;`&><]"
+regex_'5c'5c'5b'60'22'5c'5c'24'5cn'5d = compileRegex True "\\\\[`\"\\\\$\\n]"
+regex_'5c'5c'5babefnrtv'5c'5c'27'5d = compileRegex True "\\\\[abefnrtv\\\\']"
+regex_'5c'5c'28'5b0'2d7'5d'7b1'2c3'7d'7cx'5bA'2dFa'2df0'2d9'5d'7b1'2c2'7d'7cc'2e'29 = compileRegex True "\\\\([0-7]{1,3}|x[A-Fa-f0-9]{1,2}|c.)"
+regex_'5cscase'5cb = compileRegex True "\\scase\\b"
+regex_'5csdefault'5cb = compileRegex True "\\sdefault\\b"
+regex_'5cbendsw'28'3f'3d'24'7c'5b'5cs'3b'29'5d'29 = compileRegex True "\\bendsw(?=$|[\\s;)])"
+regex_'5csbreaksw'5cb = compileRegex True "\\sbreaksw\\b"
+regex_'28'3c'3c'2d'5cs'2a'22'28'5b'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'22'29 = compileRegex True "(<<-\\s*\"([|&;()<>\\s]+)\")"
+regex_'28'3c'3c'2d'5cs'2a'27'28'5b'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'27'29 = compileRegex True "(<<-\\s*'([|&;()<>\\s]+)')"
+regex_'28'3c'3c'2d'5cs'2a'5c'5c'28'5b'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'29 = compileRegex True "(<<-\\s*\\\\([|&;()<>\\s]+))"
+regex_'28'3c'3c'2d'5cs'2a'28'5b'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'29 = compileRegex True "(<<-\\s*([|&;()<>\\s]+))"
+regex_'28'3c'3c'5cs'2a'22'28'5b'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'22'29 = compileRegex True "(<<\\s*\"([|&;()<>\\s]+)\")"
+regex_'28'3c'3c'5cs'2a'27'28'5b'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'27'29 = compileRegex True "(<<\\s*'([|&;()<>\\s]+)')"
+regex_'28'3c'3c'5cs'2a'5c'5c'28'5b'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'29 = compileRegex True "(<<\\s*\\\\([|&;()<>\\s]+))"
+regex_'28'3c'3c'5cs'2a'28'5b'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'29 = compileRegex True "(<<\\s*([|&;()<>\\s]+))"
+
+parseRules ("Tcsh","Start") =
+  (((parseRules ("Tcsh","FindAll")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","Start")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Tcsh","FindAll") =
+  (((parseRules ("Tcsh","FindComments")))
+   <|>
+   ((parseRules ("Tcsh","FindCommands")))
+   <|>
+   ((parseRules ("Tcsh","FindStrings")))
+   <|>
+   ((parseRules ("Tcsh","FindSubstitutions")))
+   <|>
+   ((parseRules ("Tcsh","FindOthers")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","FindAll")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Tcsh","FindMost") =
+  (((parseRules ("Tcsh","FindComments")))
+   <|>
+   ((parseRules ("Tcsh","FindStrings")))
+   <|>
+   ((parseRules ("Tcsh","FindSubstitutions")))
+   <|>
+   ((parseRules ("Tcsh","FindOthers")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","FindMost")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Tcsh","FindComments") =
+  (((pFirstNonSpace >> pDetectChar False '#' >>= withAttribute CommentTok) >>~ pushContext ("Tcsh","Comment"))
+   <|>
+   ((pRegExpr regex_'5b'5cs'3b'5d'28'3f'3d'23'29 >>= withAttribute NormalTok) >>~ pushContext ("Tcsh","Comment"))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","FindComments")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Tcsh","Comment") =
+  (((Text.Highlighting.Kate.Syntax.Alert.parseExpression (Just ("Alerts","")) >>= ((withAttribute CommentTok) . snd)))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","Comment")) >> pDefault >>= withAttribute CommentTok))
+
+parseRules ("Tcsh","FindCommentsParen") =
+  (((pFirstNonSpace >> pDetectChar False '#' >>= withAttribute CommentTok) >>~ pushContext ("Tcsh","CommentParen"))
+   <|>
+   ((pRegExpr regex_'5b'5cs'3b'5d'28'3f'3d'23'29 >>= withAttribute NormalTok) >>~ pushContext ("Tcsh","CommentParen"))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","FindCommentsParen")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Tcsh","CommentParen") =
+  (((pRegExpr regex_'5b'5e'29'5d'28'3f'3d'5c'29'29 >>= withAttribute CommentTok) >>~ (popContext))
+   <|>
+   ((Text.Highlighting.Kate.Syntax.Alert.parseExpression (Just ("Alerts","")) >>= ((withAttribute CommentTok) . snd)))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","CommentParen")) >> pDefault >>= withAttribute CommentTok))
+
+parseRules ("Tcsh","FindCommentsBackq") =
+  (((pFirstNonSpace >> pDetectChar False '#' >>= withAttribute CommentTok) >>~ pushContext ("Tcsh","CommentBackq"))
+   <|>
+   ((pRegExpr regex_'5b'5cs'3b'5d'28'3f'3d'23'29 >>= withAttribute NormalTok) >>~ pushContext ("Tcsh","CommentBackq"))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","FindCommentsBackq")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Tcsh","CommentBackq") =
+  (((pRegExpr regex_'5b'5e'60'5d'28'3f'3d'60'29 >>= withAttribute CommentTok) >>~ (popContext))
+   <|>
+   ((Text.Highlighting.Kate.Syntax.Alert.parseExpression (Just ("Alerts","")) >>= ((withAttribute CommentTok) . snd)))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","CommentBackq")) >> pDefault >>= withAttribute CommentTok))
+
+parseRules ("Tcsh","FindCommands") =
+  (((pDetect2Chars False '(' '(' >>= withAttribute KeywordTok) >>~ pushContext ("Tcsh","ExprDblParen"))
+   <|>
+   ((pColumn 0 >> pRegExpr regex_'5c'5b'5c'5b'28'3f'3d'28'24'7c'5cs'29'29 >>= withAttribute KeywordTok) >>~ pushContext ("Tcsh","ExprDblBracket"))
+   <|>
+   ((pRegExpr regex_'5cs'5c'5b'5c'5b'28'3f'3d'28'24'7c'5cs'29'29 >>= withAttribute KeywordTok) >>~ pushContext ("Tcsh","ExprDblBracket"))
+   <|>
+   ((pColumn 0 >> pRegExpr regex_'5c'5b'28'3f'3d'28'24'7c'5cs'29'29 >>= withAttribute KeywordTok) >>~ pushContext ("Tcsh","ExprBracket"))
+   <|>
+   ((pRegExpr regex_'5cs'5c'5b'28'3f'3d'28'24'7c'5cs'29'29 >>= withAttribute KeywordTok) >>~ pushContext ("Tcsh","ExprBracket"))
+   <|>
+   ((pRegExpr regex_'5c'7b'28'3f'3d'28'24'7c'5cs'29'29 >>= withAttribute KeywordTok) >>~ pushContext ("Tcsh","Group"))
+   <|>
+   ((pDetectChar False '(' >>= withAttribute KeywordTok) >>~ pushContext ("Tcsh","SubShell"))
+   <|>
+   ((pRegExpr regex_'5cbdo'28'3f'21'5b'5cw'24'2b'2d'5d'29 >>= withAttribute KeywordTok))
+   <|>
+   ((pRegExpr regex_'5cbdone'28'3f'21'5b'5cw'24'2b'2d'5d'29 >>= withAttribute KeywordTok))
+   <|>
+   ((pRegExpr regex_'5cbelse'5cs'2bif'28'3f'21'5b'5cw'24'2b'2d'5d'29 >>= withAttribute KeywordTok))
+   <|>
+   ((pRegExpr regex_'5cbif'28'3f'21'5b'5cw'24'2b'2d'5d'29 >>= withAttribute KeywordTok))
+   <|>
+   ((pRegExpr regex_'5cbendif'28'3f'21'5b'5cw'24'2b'2d'5d'29 >>= withAttribute KeywordTok))
+   <|>
+   ((pRegExpr regex_'5cbswitch'28'3f'21'5b'5cw'24'2b'2d'5d'29 >>= withAttribute KeywordTok) >>~ pushContext ("Tcsh","Switch"))
+   <|>
+   ((pRegExpr regex_'2d'5bA'2dZa'2dz0'2d9'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a >>= withAttribute NormalTok))
+   <|>
+   ((pRegExpr regex_'2d'2d'5ba'2dz'5d'5bA'2dZa'2dz0'2d9'5f'2d'5d'2a >>= withAttribute NormalTok))
+   <|>
+   ((pRegExpr regex_'5cb'40'5cs >>= withAttribute KeywordTok))
+   <|>
+   ((pRegExpr regex_'5cbset'5cs >>= withAttribute KeywordTok))
+   <|>
+   ((pRegExpr regex_'5cbsetenv'5cs >>= withAttribute KeywordTok) >>~ pushContext ("Tcsh","CmdSetEnv"))
+   <|>
+   ((pString False ":()" >>= withAttribute FunctionTok))
+   <|>
+   ((pRegExpr regex_'5cbfunction'5cb >>= withAttribute KeywordTok) >>~ pushContext ("Tcsh","FunctionDef"))
+   <|>
+   ((pKeyword " \n\t()!+,<=>&*/;?|~\\`" list_keywords >>= withAttribute KeywordTok))
+   <|>
+   ((pKeyword " \n\t()!+,<=>&*/;?|~\\`" list_builtins >>= withAttribute KeywordTok))
+   <|>
+   ((pKeyword " \n\t()!+,<=>&*/;?|~\\`" list_unixcommands >>= withAttribute KeywordTok))
+   <|>
+   ((pKeyword " \n\t()!+,<=>&*/;?|~\\`" list_builtins'5fvar >>= withAttribute KeywordTok) >>~ pushContext ("Tcsh","VarName"))
+   <|>
+   ((pRegExpr regex_'28'3c'3c'3f'7c'3e'3e'3f'26'3f'21'3f'29 >>= withAttribute KeywordTok))
+   <|>
+   ((pRegExpr regex_'28'5b'7c'26'5d'29'5c1'3f >>= withAttribute KeywordTok))
+   <|>
+   ((pRegExpr regex_'5bA'2dZa'2dz'5f'3a'5d'5bA'2dZa'2dz0'2d9'5f'3a'23'25'40'2d'5d'2a'5cs'2a'5c'28'5c'29 >>= withAttribute FunctionTok))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","FindCommands")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Tcsh","FindOthers") =
+  (((pRegExpr regex_'5c'5c'5b'3b'22'5c'5c'27'24'60'7b'7d'28'29'7c'26'3c'3e'2a_'5d >>= withAttribute DataTypeTok))
+   <|>
+   ((pRegExpr regex_'28'5b'5cw'5f'40'2e'25'2a'3f'2b'2d'5d'7c'5c'5c_'29'2a'28'3f'3d'2f'29 >>= withAttribute NormalTok))
+   <|>
+   ((pRegExpr regex_'7e'5cw'2a >>= withAttribute NormalTok))
+   <|>
+   ((pRegExpr regex_'2f'28'5b'5cw'5f'40'2e'25'2a'3f'2b'2d'5d'7c'5c'5c_'29'2a'28'3f'3d'28'5b'5cs'2f'29'3a'3b'24'60'27'22'5d'7c'24'29'29 >>= withAttribute NormalTok))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","FindOthers")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Tcsh","FindStrings") =
+  (((pDetectChar False '\'' >>= withAttribute StringTok) >>~ pushContext ("Tcsh","StringSQ"))
+   <|>
+   ((pDetectChar False '"' >>= withAttribute StringTok) >>~ pushContext ("Tcsh","StringDQ"))
+   <|>
+   ((pDetect2Chars False '$' '\'' >>= withAttribute StringTok) >>~ pushContext ("Tcsh","StringEsc"))
+   <|>
+   ((pDetect2Chars False '$' '"' >>= withAttribute StringTok) >>~ pushContext ("Tcsh","StringDQ"))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","FindStrings")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Tcsh","FindSubstitutions") =
+  (((pRegExpr regex_'5c'24'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'5c'5b >>= withAttribute OtherTok) >>~ pushContext ("Tcsh","Subscript"))
+   <|>
+   ((pRegExpr regex_'5c'24'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a >>= withAttribute OtherTok))
+   <|>
+   ((pRegExpr regex_'5c'24'5b'2a'40'23'3f'24'21'5f0'2d9'2d'5d >>= withAttribute OtherTok))
+   <|>
+   ((pRegExpr regex_'5c'24'5c'7b'5b'2a'40'23'3f'24'21'5f0'2d9'2d'5d'5c'7d >>= withAttribute OtherTok))
+   <|>
+   ((pRegExpr regex_'5c'24'5c'7b'23'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'5c'7d >>= withAttribute OtherTok))
+   <|>
+   ((pRegExpr regex_'5c'24'5c'7b'21'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'5c'2a'3f'5c'7d >>= withAttribute OtherTok))
+   <|>
+   ((pRegExpr regex_'5c'24'5c'7b'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a >>= withAttribute OtherTok) >>~ pushContext ("Tcsh","VarBrace"))
+   <|>
+   ((pRegExpr regex_'5c'24'5c'7b'5b'2a'40'23'3f'24'21'5f0'2d9'2d'5d'28'3f'3d'5b'3a'23'25'2f'5d'29 >>= withAttribute OtherTok) >>~ pushContext ("Tcsh","VarBrace"))
+   <|>
+   ((pString False "$((" >>= withAttribute OtherTok) >>~ pushContext ("Tcsh","ExprDblParenSubst"))
+   <|>
+   ((pDetectChar False '`' >>= withAttribute KeywordTok) >>~ pushContext ("Tcsh","SubstBackq"))
+   <|>
+   ((pRegExpr regex_'5c'5c'5b'60'24'5c'5c'5d >>= withAttribute DataTypeTok))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","FindSubstitutions")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Tcsh","FindTests") =
+  (((pRegExpr regex_'2d'5brwxXeozsfdlbcpSugktRLDIFNZ'5d'28'3f'3d'5cs'29 >>= withAttribute OtherTok))
+   <|>
+   ((pRegExpr regex_'2d'5bAMCUG'5d'3a'3f'28'3f'3d'5cs'29 >>= withAttribute OtherTok))
+   <|>
+   ((pRegExpr regex_'2dP'5b0'2d7'5d'7b'2c3'7d'3a'3f'28'3f'3d'5cs'29 >>= withAttribute OtherTok))
+   <|>
+   ((pRegExpr regex_'28'5b'7c'26'3d'3e'3c'5d'29'5c1 >>= withAttribute OtherTok))
+   <|>
+   ((pRegExpr regex_'5b'7c'5e'26'3e'3c'2b'5c'2d'2a'2f'25'21'7e'5d >>= withAttribute OtherTok))
+   <|>
+   ((pRegExpr regex_'28'5b'21'3d'5d'7e'7c'5b'21'3e'3c'5d'3d'29 >>= withAttribute OtherTok))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","FindTests")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Tcsh","ExprDblParen") =
+  (((pDetect2Chars False ')' ')' >>= withAttribute KeywordTok) >>~ (popContext))
+   <|>
+   ((pDetectChar False '(' >>= withAttribute NormalTok) >>~ pushContext ("Tcsh","ExprSubParen"))
+   <|>
+   ((parseRules ("Tcsh","FindMost")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","ExprDblParen")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Tcsh","ExprDblParenSubst") =
+  (((pDetect2Chars False ')' ')' >>= withAttribute OtherTok) >>~ (popContext))
+   <|>
+   ((pDetectChar False '(' >>= withAttribute NormalTok) >>~ pushContext ("Tcsh","ExprSubParen"))
+   <|>
+   ((parseRules ("Tcsh","FindMost")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","ExprDblParenSubst")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Tcsh","ExprSubParen") =
+  (((pDetectChar False ')' >>= withAttribute NormalTok) >>~ (popContext))
+   <|>
+   ((pDetectChar False '(' >>= withAttribute NormalTok) >>~ pushContext ("Tcsh","ExprSubParen"))
+   <|>
+   ((parseRules ("Tcsh","FindMost")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","ExprSubParen")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Tcsh","ExprBracket") =
+  (((pRegExpr regex_'5cs'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 >>= withAttribute KeywordTok) >>~ (popContext))
+   <|>
+   ((pColumn 0 >> pRegExpr regex_'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 >>= withAttribute KeywordTok) >>~ (popContext))
+   <|>
+   ((pDetectChar False '(' >>= withAttribute NormalTok) >>~ pushContext ("Tcsh","ExprSubParen"))
+   <|>
+   ((parseRules ("Tcsh","FindTests")))
+   <|>
+   ((parseRules ("Tcsh","FindMost")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","ExprBracket")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Tcsh","ExprDblBracket") =
+  (((pRegExpr regex_'5cs'5c'5d'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 >>= withAttribute KeywordTok) >>~ (popContext))
+   <|>
+   ((pColumn 0 >> pRegExpr regex_'5c'5d'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 >>= withAttribute KeywordTok) >>~ (popContext))
+   <|>
+   ((pDetectChar False '(' >>= withAttribute NormalTok) >>~ pushContext ("Tcsh","ExprSubParen"))
+   <|>
+   ((parseRules ("Tcsh","FindTests")))
+   <|>
+   ((parseRules ("Tcsh","FindMost")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","ExprDblBracket")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Tcsh","Group") =
+  (((pDetectChar False '}' >>= withAttribute KeywordTok) >>~ (popContext))
+   <|>
+   ((parseRules ("Tcsh","FindAll")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","Group")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Tcsh","SubShell") =
+  (((pDetectChar False ')' >>= withAttribute KeywordTok) >>~ (popContext))
+   <|>
+   ((parseRules ("Tcsh","FindAll")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","SubShell")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Tcsh","Assign") =
+  (((pDetectChar False '(' >>= withAttribute OtherTok) >>~ pushContext ("Tcsh","AssignArray"))
+   <|>
+   ((parseRules ("Tcsh","FindStrings")))
+   <|>
+   ((parseRules ("Tcsh","FindSubstitutions")))
+   <|>
+   ((parseRules ("Tcsh","FindOthers")))
+   <|>
+   ((pRegExpr regex_'5b'5cw'3a'2c'2b'5f'2e'2f'2d'5d'2b >>= withAttribute NormalTok))
+   <|>
+   ((popContext) >> currentContext >>= parseRules))
+
+parseRules ("Tcsh","AssignArray") =
+  (((pDetectChar False ')' >>= withAttribute OtherTok) >>~ (popContext))
+   <|>
+   ((pDetectChar False '[' >>= withAttribute OtherTok) >>~ pushContext ("Tcsh","Subscript"))
+   <|>
+   ((pDetectChar False '=' >>= withAttribute OtherTok) >>~ pushContext ("Tcsh","Assign"))
+   <|>
+   ((parseRules ("Tcsh","FindMost")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","AssignArray")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Tcsh","AssignSubscr") =
+  (((pDetectChar False '[' >>= withAttribute OtherTok) >>~ pushContext ("Tcsh","Subscript"))
+   <|>
+   ((pDetectChar False '=' >>= withAttribute OtherTok) >>~ pushContext ("Tcsh","Assign"))
+   <|>
+   ((parseRules ("Tcsh","FindStrings")))
+   <|>
+   ((parseRules ("Tcsh","FindSubstitutions")))
+   <|>
+   ((parseRules ("Tcsh","FindOthers")))
+   <|>
+   ((popContext) >> currentContext >>= parseRules))
+
+parseRules ("Tcsh","Subscript") =
+  (((pDetectChar False ']' >>= withAttribute OtherTok) >>~ (popContext))
+   <|>
+   ((parseRules ("Tcsh","FindStrings")))
+   <|>
+   ((parseRules ("Tcsh","FindSubstitutions")))
+   <|>
+   ((parseRules ("Tcsh","FindOthers")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","Subscript")) >> pDefault >>= withAttribute OtherTok))
+
+parseRules ("Tcsh","FunctionDef") =
+  (((pRegExpr regex_'5cs'2b'5bA'2dZa'2dz'5f'3a'5d'5bA'2dZa'2dz0'2d9'5f'3a'23'25'40'2d'5d'2a'28'5cs'2a'5c'28'5c'29'29'3f >>= withAttribute FunctionTok) >>~ (popContext))
+   <|>
+   ((popContext) >> currentContext >>= parseRules))
+
+parseRules ("Tcsh","CmdSetEnv") =
+  (((pRegExpr regex_'5cb'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a >>= withAttribute OtherTok) >>~ (popContext))
+   <|>
+   ((pDetectChar False ' ' >>= withAttribute OtherTok) >>~ pushContext ("Tcsh","Assign"))
+   <|>
+   ((parseRules ("Tcsh","FindMost")))
+   <|>
+   ((popContext) >> currentContext >>= parseRules))
+
+parseRules ("Tcsh","VarName") =
+  (((pRegExpr regex_'2d'5bA'2dZa'2dz0'2d9'5d'2b >>= withAttribute NormalTok))
+   <|>
+   ((pRegExpr regex_'2d'2d'5ba'2dz'5d'5bA'2dZa'2dz0'2d9'5f'2d'5d'2a >>= withAttribute NormalTok))
+   <|>
+   ((pRegExpr regex_'5cb'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a >>= withAttribute OtherTok))
+   <|>
+   ((pDetectChar False '[' >>= withAttribute OtherTok) >>~ pushContext ("Tcsh","Subscript"))
+   <|>
+   ((pDetectChar False '=' >>= withAttribute OtherTok) >>~ pushContext ("Tcsh","Assign"))
+   <|>
+   ((parseRules ("Tcsh","FindMost")))
+   <|>
+   ((pRegExpr regex_'5b'5e'5d'7d'29'7c'3b'60'26'3e'3c'5d >>= withAttribute NormalTok))
+   <|>
+   ((popContext) >> currentContext >>= parseRules))
+
+parseRules ("Tcsh","ProcessSubst") =
+  (((pDetectChar False ')' >>= withAttribute KeywordTok) >>~ (popContext))
+   <|>
+   ((parseRules ("Tcsh","FindCommentsParen")))
+   <|>
+   ((parseRules ("Tcsh","FindCommands")))
+   <|>
+   ((parseRules ("Tcsh","FindStrings")))
+   <|>
+   ((parseRules ("Tcsh","FindSubstitutions")))
+   <|>
+   ((parseRules ("Tcsh","FindOthers")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","ProcessSubst")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Tcsh","StringSQ") =
+  (((pDetectChar False '\'' >>= withAttribute StringTok) >>~ (popContext))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","StringSQ")) >> pDefault >>= withAttribute StringTok))
+
+parseRules ("Tcsh","StringDQ") =
+  (((pDetectChar False '"' >>= withAttribute StringTok) >>~ (popContext))
+   <|>
+   ((pRegExpr regex_'5c'5c'5b'60'22'5c'5c'24'5cn'5d >>= withAttribute DataTypeTok))
+   <|>
+   ((parseRules ("Tcsh","FindSubstitutions")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","StringDQ")) >> pDefault >>= withAttribute StringTok))
+
+parseRules ("Tcsh","StringEsc") =
+  (((pDetectChar False '\'' >>= withAttribute StringTok) >>~ (popContext))
+   <|>
+   ((pRegExpr regex_'5c'5c'5babefnrtv'5c'5c'27'5d >>= withAttribute DataTypeTok))
+   <|>
+   ((pRegExpr regex_'5c'5c'28'5b0'2d7'5d'7b1'2c3'7d'7cx'5bA'2dFa'2df0'2d9'5d'7b1'2c2'7d'7cc'2e'29 >>= withAttribute DataTypeTok))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","StringEsc")) >> pDefault >>= withAttribute StringTok))
+
+parseRules ("Tcsh","VarBrace") =
+  (((pDetectChar False '}' >>= withAttribute OtherTok) >>~ (popContext))
+   <|>
+   ((pDetectChar False '[' >>= withAttribute OtherTok) >>~ pushContext ("Tcsh","Subscript"))
+   <|>
+   ((parseRules ("Tcsh","FindStrings")))
+   <|>
+   ((parseRules ("Tcsh","FindSubstitutions")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","VarBrace")) >> pDefault >>= withAttribute OtherTok))
+
+parseRules ("Tcsh","SubstFile") =
+  (((pDetectChar False ')' >>= withAttribute KeywordTok) >>~ (popContext))
+   <|>
+   ((parseRules ("Tcsh","FindCommentsParen")))
+   <|>
+   ((parseRules ("Tcsh","FindStrings")))
+   <|>
+   ((parseRules ("Tcsh","FindSubstitutions")))
+   <|>
+   ((parseRules ("Tcsh","FindOthers")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","SubstFile")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Tcsh","SubstCommand") =
+  (((pDetectChar False ')' >>= withAttribute OtherTok) >>~ (popContext))
+   <|>
+   ((parseRules ("Tcsh","FindCommentsParen")))
+   <|>
+   ((parseRules ("Tcsh","FindCommands")))
+   <|>
+   ((parseRules ("Tcsh","FindStrings")))
+   <|>
+   ((parseRules ("Tcsh","FindSubstitutions")))
+   <|>
+   ((parseRules ("Tcsh","FindOthers")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","SubstCommand")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Tcsh","SubstBackq") =
+  (((pDetectChar False '`' >>= withAttribute KeywordTok) >>~ (popContext))
+   <|>
+   ((parseRules ("Tcsh","FindCommentsBackq")))
+   <|>
+   ((parseRules ("Tcsh","FindCommands")))
+   <|>
+   ((parseRules ("Tcsh","FindStrings")))
+   <|>
+   ((parseRules ("Tcsh","FindSubstitutions")))
+   <|>
+   ((parseRules ("Tcsh","FindOthers")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","SubstBackq")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Tcsh","Switch") =
+  (((pRegExpr regex_'5cscase'5cb >>= withAttribute KeywordTok) >>~ pushContext ("Tcsh","SwitchCase"))
+   <|>
+   ((pRegExpr regex_'5csdefault'5cb >>= withAttribute KeywordTok) >>~ pushContext ("Tcsh","SwitchDefault"))
+   <|>
+   ((pRegExpr regex_'5cbendsw'28'3f'3d'24'7c'5b'5cs'3b'29'5d'29 >>= withAttribute KeywordTok) >>~ (popContext))
+   <|>
+   ((parseRules ("Tcsh","FindMost")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","Switch")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Tcsh","SwitchCase") =
+  (((pDetectChar False ':' >>= withAttribute KeywordTok) >>~ pushContext ("Tcsh","SwitchExpr"))
+   <|>
+   ((parseRules ("Tcsh","FindMost")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","SwitchCase")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Tcsh","SwitchDefault") =
+  (((pDetectChar False ':' >>= withAttribute KeywordTok) >>~ pushContext ("Tcsh","SwitchExpr"))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","SwitchDefault")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Tcsh","SwitchExpr") =
+  (((pRegExpr regex_'5csbreaksw'5cb >>= withAttribute KeywordTok) >>~ (popContext >> popContext))
+   <|>
+   ((lookAhead (pRegExpr regex_'5cscase'5cb) >> (popContext >> popContext) >> currentContext >>= parseRules))
+   <|>
+   ((parseRules ("Tcsh","FindAll")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","SwitchExpr")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Tcsh","HereDoc") =
+  (((lookAhead (pRegExpr regex_'28'3c'3c'2d'5cs'2a'22'28'5b'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'22'29) >> pushContext ("Tcsh","HereDocIQ") >> currentContext >>= parseRules))
+   <|>
+   ((lookAhead (pRegExpr regex_'28'3c'3c'2d'5cs'2a'27'28'5b'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'27'29) >> pushContext ("Tcsh","HereDocIQ") >> currentContext >>= parseRules))
+   <|>
+   ((lookAhead (pRegExpr regex_'28'3c'3c'2d'5cs'2a'5c'5c'28'5b'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'29) >> pushContext ("Tcsh","HereDocIQ") >> currentContext >>= parseRules))
+   <|>
+   ((lookAhead (pRegExpr regex_'28'3c'3c'2d'5cs'2a'28'5b'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'29) >> pushContext ("Tcsh","HereDocINQ") >> currentContext >>= parseRules))
+   <|>
+   ((lookAhead (pRegExpr regex_'28'3c'3c'5cs'2a'22'28'5b'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'22'29) >> pushContext ("Tcsh","HereDocQ") >> currentContext >>= parseRules))
+   <|>
+   ((lookAhead (pRegExpr regex_'28'3c'3c'5cs'2a'27'28'5b'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'27'29) >> pushContext ("Tcsh","HereDocQ") >> currentContext >>= parseRules))
+   <|>
+   ((lookAhead (pRegExpr regex_'28'3c'3c'5cs'2a'5c'5c'28'5b'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'29) >> pushContext ("Tcsh","HereDocQ") >> currentContext >>= parseRules))
+   <|>
+   ((lookAhead (pRegExpr regex_'28'3c'3c'5cs'2a'28'5b'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'29) >> pushContext ("Tcsh","HereDocNQ") >> currentContext >>= parseRules))
+   <|>
+   ((pString False "<<" >>= withAttribute KeywordTok) >>~ (popContext))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","HereDoc")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Tcsh","HereDocRemainder") =
+  (((parseRules ("Tcsh","FindAll")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","HereDocRemainder")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Tcsh","HereDocQ") =
+  (((pRegExprDynamic "%1" >>= withAttribute KeywordTok) >>~ pushContext ("Tcsh","HereDocRemainder"))
+   <|>
+   ((pColumn 0 >> pRegExprDynamic "%2[\\s;]*$" >>= withAttribute KeywordTok) >>~ (popContext >> popContext))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","HereDocQ")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Tcsh","HereDocNQ") =
+  (((pRegExprDynamic "%1" >>= withAttribute KeywordTok) >>~ pushContext ("Tcsh","HereDocRemainder"))
+   <|>
+   ((pColumn 0 >> pRegExprDynamic "%2[\\s;]*$" >>= withAttribute KeywordTok) >>~ (popContext >> popContext))
+   <|>
+   ((parseRules ("Tcsh","FindSubstitutions")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","HereDocNQ")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Tcsh","HereDocIQ") =
+  (((pRegExprDynamic "%1" >>= withAttribute KeywordTok) >>~ pushContext ("Tcsh","HereDocRemainder"))
+   <|>
+   ((pColumn 0 >> pRegExprDynamic "\\s*%2[\\s;]*$" >>= withAttribute KeywordTok) >>~ (popContext >> popContext))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","HereDocIQ")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Tcsh","HereDocINQ") =
+  (((pRegExprDynamic "%1" >>= withAttribute KeywordTok) >>~ pushContext ("Tcsh","HereDocRemainder"))
+   <|>
+   ((pColumn 0 >> pRegExprDynamic "\\s*%2[\\s;]*$" >>= withAttribute KeywordTok) >>~ (popContext >> popContext))
+   <|>
+   ((parseRules ("Tcsh","FindSubstitutions")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Tcsh","HereDocINQ")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Alerts", _) = Text.Highlighting.Kate.Syntax.Alert.parseExpression Nothing
+
+parseRules x = parseRules ("Tcsh","Start") <|> fail ("Unknown context" ++ show x)
diff --git a/Text/Highlighting/Kate/Syntax/Vhdl.hs b/Text/Highlighting/Kate/Syntax/Vhdl.hs
--- a/Text/Highlighting/Kate/Syntax/Vhdl.hs
+++ b/Text/Highlighting/Kate/Syntax/Vhdl.hs
@@ -1,5 +1,5 @@
 {- This module was generated from data in the Kate syntax
-   highlighting file vhdl.xml, version 1.10, by Rocky Scaletta (rocky@purdue.edu), Stefan Endrullis (stefan@endrullis.de), Florent Ouchet (outchy@users.sourceforge.net), Chris Higgs (chiggs.99@gmail.com), Jan Michel (jan@mueschelsoft.de) -}
+   highlighting file vhdl.xml, version 1.11, by Rocky Scaletta (rocky@purdue.edu), Stefan Endrullis (stefan@endrullis.de), Florent Ouchet (outchy@users.sourceforge.net), Chris Higgs (chiggs.99@gmail.com), Jan Michel (jan@mueschelsoft.de) -}
 
 module Text.Highlighting.Kate.Syntax.Vhdl
           (highlight, parseExpression, syntaxName, syntaxExtensions)
@@ -47,8 +47,14 @@
     then case context of
       ("VHDL","start") -> return ()
       ("VHDL","package") -> return ()
+      ("VHDL","packagemain") -> return ()
+      ("VHDL","packagefunction") -> return ()
       ("VHDL","packagebody") -> return ()
+      ("VHDL","packagebodymain") -> return ()
+      ("VHDL","packagebodyfunc1") -> return ()
+      ("VHDL","packagebodyfunc2") -> return ()
       ("VHDL","architecture_main") -> return ()
+      ("VHDL","arch_start") -> return ()
       ("VHDL","arch_decl") -> return ()
       ("VHDL","detect_arch_parts") -> return ()
       ("VHDL","generate1") -> return ()
@@ -56,14 +62,22 @@
       ("VHDL","process1") -> return ()
       ("VHDL","proc_rules") -> return ()
       ("VHDL","instance") -> return ()
-      ("VHDL","forOrWhile") -> return ()
+      ("VHDL","instanceMap") -> return ()
+      ("VHDL","instanceInnerPar") -> return ()
+      ("VHDL","forwhile1") -> return ()
+      ("VHDL","forwhile2") -> return ()
       ("VHDL","if_start") -> return ()
       ("VHDL","if") -> return ()
       ("VHDL","case1") -> return ()
       ("VHDL","case2") -> return ()
       ("VHDL","caseWhen") -> return ()
+      ("VHDL","caseWhen2") -> return ()
       ("VHDL","entity") -> return ()
       ("VHDL","entity_main") -> return ()
+      ("VHDL","configuration") -> return ()
+      ("VHDL","conf_start") -> return ()
+      ("VHDL","conf_decl") -> return ()
+      ("VHDL","conf_for") -> return ()
       ("VHDL","preDetection") -> return ()
       ("VHDL","generalDetection") -> return ()
       ("VHDL","comment") -> (popContext) >> pEndLine
@@ -81,78 +95,149 @@
   return (attr, txt)
 
 list_keywordsToplevel = Set.fromList $ words $ "file library use"
-list_keywords = Set.fromList $ words $ "access after alias all array assert assume assume_guarantee attribute begin block body bus component constant context cover default disconnect downto end exit fairness file force function generate generic group guarded impure inertial is label linkage literal map new next null of on open others parameter port postponed procedure process property protected pure range record register reject release report return select sequence severity signal shared strong subtype to transport type unaffected units until variable vmode vprop vunit wait when with note warning error failure in inout out buffer and abs or xor xnor not mod nand nor rem rol ror sla sra sll srl"
+list_keywords = Set.fromList $ words $ "access after alias all array assert assume assume_guarantee attribute begin block body bus component constant context cover default disconnect downto end exit fairness falling_edge file force function generate generic group guarded impure inertial is label linkage literal map new next null of on open others parameter port postponed procedure process property protected pure range record register reject release report return rising_edge select sequence severity signal shared strong subtype to transport type unaffected units until variable vmode vprop vunit wait when with note warning error failure in inout out buffer and abs or xor xnor not mod nand nor rem rol ror sla sra sll srl"
 list_if = Set.fromList $ words $ "if else elsif then"
 list_forOrWhile = Set.fromList $ words $ "loop"
 list_directions = Set.fromList $ words $ "in inout out buffer linkage"
-list_signals = Set.fromList $ words $ "signal variable constant type"
+list_signals = Set.fromList $ words $ "signal variable constant type attribute"
 list_range = Set.fromList $ words $ "to downto others"
 list_case = Set.fromList $ words $ "case when"
+list_timeunits = Set.fromList $ words $ "fs ps ns us ms sec min hr"
 list_types = Set.fromList $ words $ "bit bit_vector character boolean boolean_vector integer integer_vector real real_vector time time_vector delay_length string severity_level positive natural file_open_kind file_open_status signed unsigned unresolved_unsigned unresolved_signed line text side width std_logic std_logic_vector std_ulogic std_ulogic_vector x01 x01z ux01 ux01z qsim_state qsim_state_vector qsim_12state qsim_12state_vector qsim_strength mux_bit mux_vector reg_bit reg_vector wor_bit wor_vector"
 
-regex_'28'5cb'29'28package'5cs'2b'28'5cb'28'3f'21'28'3f'3aprocess'7cconstant'7csignal'7cvariable'29'29'28'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'29'5cb'29'5cs'2bis'29'5cb = compileRegex True "(\\b)(package\\s+(\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)\\s+is)\\b"
-regex_'28'5cb'29'28package'5cs'2bbody'5cs'2b'28'5cb'28'3f'21'28'3f'3aprocess'7cconstant'7csignal'7cvariable'29'29'28'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'29'5cb'29'5cs'2bis'29'5cb = compileRegex True "(\\b)(package\\s+body\\s+(\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)\\s+is)\\b"
-regex_architecture'5cs'2b'28'5cb'28'3f'21'28'3f'3aprocess'7cconstant'7csignal'7cvariable'29'29'28'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'29'5cb'29'5cs'2bof'5cs'2b'28'5cb'28'3f'21'28'3f'3aprocess'7cconstant'7csignal'7cvariable'29'29'28'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'29'5cb'29'5cs'2bis = compileRegex True "architecture\\s+(\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)\\s+of\\s+(\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)\\s+is"
-regex_'28'5cb'29generate'5cb = compileRegex True "(\\b)generate\\b"
-regex_'28'5cb'29end'5cs'2bgenerate'28'5cs'2b'5cb'28'3f'21'28'3f'3aprocess'7cconstant'7csignal'7cvariable'29'29'28'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'29'5cb'29'3f'5cs'2a'3b = compileRegex True "(\\b)end\\s+generate(\\s+\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)?\\s*;"
+regex_'28'5cb'29package'5cb = compileRegex True "(\\b)package\\b"
+regex_'28'5cb'29is'5cb = compileRegex True "(\\b)is\\b"
+regex_'28'5cb'29end'5cb = compileRegex True "(\\b)end\\b"
+regex_'28'5cb'29function'5cb = compileRegex True "(\\b)function\\b"
+regex_'28'5cb'29'5cb'28'3f'21'28'3f'3aprocess'7cconstant'7csignal'7cvariable'29'29'28'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'29'5cb'5cb = compileRegex True "(\\b)\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b\\b"
+regex_'28'5cb'29end'5cs'2bpackage'5cb = compileRegex True "(\\b)end\\s+package\\b"
+regex_'28'5cb'29begin'5cb = compileRegex True "(\\b)begin\\b"
+regex_'28'5cb'29'28generate'7cloop'29'5cb = compileRegex True "(\\b)(generate|loop)\\b"
+regex_'28'5cb'29'28for'7cif'7cwhile'29'5cb = compileRegex True "(\\b)(for|if|while)\\b"
+regex_'28'5cb'29end'5cs'2b'28generate'7cloop'29'28'5cs'2b'5cb'28'3f'21'28'3f'3aprocess'7cconstant'7csignal'7cvariable'29'29'28'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'29'5cb'29'3f = compileRegex True "(\\b)end\\s+(generate|loop)(\\s+\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)?"
+regex_'28'5cb'29process'5cb = compileRegex True "(\\b)process\\b"
 regex_'28'5cb'29'5cb'28'3f'21'28'3f'3aprocess'7cconstant'7csignal'7cvariable'29'29'28'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'29'5cb'28'3f'3d'5cs'2a'3a'28'3f'21'3d'29'29 = compileRegex True "(\\b)\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b(?=\\s*:(?!=))"
-regex_'28'5cb'29'28if'29'5cb = compileRegex True "(\\b)(if)\\b"
-regex_'28'5cb'29'28'28'5cb'28'3f'21'28'3f'3aprocess'7cconstant'7csignal'7cvariable'29'29'28'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'29'5cb'29'5cs'2a'3a'5cs'2a'29'3f'28'28for'7cwhile'29'5cs'2b'2e'2b'5cs'2b'29'3floop'5cb = compileRegex True "(\\b)((\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)\\s*:\\s*)?((for|while)\\s+.+\\s+)?loop\\b"
-regex_'28'5cb'29end'5cs'2bloop'28'5cs'2b'5cb'28'3f'21'28'3f'3aprocess'7cconstant'7csignal'7cvariable'29'29'28'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'29'5cb'29'3f'5cs'2a'3b = compileRegex True "(\\b)end\\s+loop(\\s+\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)?\\s*;"
+regex_'28'5cb'29if'5cb = compileRegex True "(\\b)if\\b"
+regex_'28'5cb'29case'5cb = compileRegex True "(\\b)case\\b"
+regex_'28'5cb'29'28port'7cgeneric'29'5cs'2bmap'5cs'2a'5c'28 = compileRegex True "(\\b)(port|generic)\\s+map\\s*\\("
+regex_'28'5cb'29loop'5cb = compileRegex True "(\\b)loop\\b"
+regex_'28'5cb'29'28for'7cwhile'29'5cb = compileRegex True "(\\b)(for|while)\\b"
+regex_'28'5cb'29end'5cs'2bloop'28'5cs'2b'5cb'28'3f'21'28'3f'3aprocess'7cconstant'7csignal'7cvariable'29'29'28'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'29'5cb'29'3f = compileRegex True "(\\b)end\\s+loop(\\s+\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)?"
+regex_'28'5cb'29then'5cb = compileRegex True "(\\b)then\\b"
 regex_'28'5cb'29end'5cs'2bif'28'5cs'2b'5cb'28'3f'21'28'3f'3aprocess'7cconstant'7csignal'7cvariable'29'29'28'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'29'5cb'29'3f'5cs'2a'3b = compileRegex True "(\\b)end\\s+if(\\s+\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)?\\s*;"
-regex_'28'5cb'29end'5cs'2bcase'28'5cs'2b'5cb'28'3f'21'28'3f'3aprocess'7cconstant'7csignal'7cvariable'29'29'28'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'29'5cb'29'3f'5cs'2a'3b = compileRegex True "(\\b)end\\s+case(\\s+\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)?\\s*;"
+regex_'28'5cb'29end'5cs'2bcase'28'5cb'28'3f'21'28'3f'3aprocess'7cconstant'7csignal'7cvariable'29'29'28'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'29'5cb'29'3f'5cs'2a'3b = compileRegex True "(\\b)end\\s+case(\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)?\\s*;"
 regex_'28'5cb'29when'5cb = compileRegex True "(\\b)when\\b"
+regex_'5cs'2awhen'5cb = compileRegex True "\\s*when\\b"
+regex_'5cs'2aend'5cs'2bcase'5cb = compileRegex True "\\s*end\\s+case\\b"
 regex_'28'5cb'28'3f'21'28'3f'3aprocess'7cconstant'7csignal'7cvariable'29'29'28'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'29'5cb'29 = compileRegex True "(\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)"
 regex_generic = compileRegex True "generic"
 regex_port = compileRegex True "port"
+regex_end'28'5cs'2b'5cb'28'3f'21'28'3f'3aprocess'7cconstant'7csignal'7cvariable'29'29'28'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'29'5cb'29'3f = compileRegex True "end(\\s+\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)?"
 
 parseRules ("VHDL","start") =
   (((parseRules ("VHDL","preDetection")))
    <|>
-   ((lookAhead (pRegExprDynamic "architecture\\s+(\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)") >> pushContext ("VHDL","architecture_main") >> currentContext >>= parseRules))
+   ((lookAhead (pRegExprDynamic "(\\b)architecture\\s+(\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)\\b") >> pushContext ("VHDL","architecture_main") >> currentContext >>= parseRules))
    <|>
    ((pString False "entity" >>= withAttribute KeywordTok) >>~ pushContext ("VHDL","entity"))
    <|>
-   ((lookAhead (pRegExpr regex_'28'5cb'29'28package'5cs'2b'28'5cb'28'3f'21'28'3f'3aprocess'7cconstant'7csignal'7cvariable'29'29'28'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'29'5cb'29'5cs'2bis'29'5cb) >> pushContext ("VHDL","package") >> currentContext >>= parseRules))
+   ((lookAhead (pRegExprDynamic "(\\b)package\\s+(\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)\\s+is\\b") >> pushContext ("VHDL","package") >> currentContext >>= parseRules))
    <|>
-   ((lookAhead (pRegExpr regex_'28'5cb'29'28package'5cs'2bbody'5cs'2b'28'5cb'28'3f'21'28'3f'3aprocess'7cconstant'7csignal'7cvariable'29'29'28'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'29'5cb'29'5cs'2bis'29'5cb) >> pushContext ("VHDL","packagebody") >> currentContext >>= parseRules))
+   ((lookAhead (pRegExprDynamic "(\\b)package\\s+body\\s+(\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)\\s+is\\b") >> pushContext ("VHDL","packagebody") >> currentContext >>= parseRules))
    <|>
+   ((lookAhead (pRegExprDynamic "(\\b)configuration\\s+(\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)\\b") >> pushContext ("VHDL","configuration") >> currentContext >>= parseRules))
+   <|>
    ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_keywordsToplevel >>= withAttribute KeywordTok))
    <|>
    (currentContext >>= \x -> guard (x == ("VHDL","start")) >> pDefault >>= withAttribute NormalTok))
 
 parseRules ("VHDL","package") =
-  (((pString True "%2" >>= withAttribute KeywordTok))
+  (((parseRules ("VHDL","preDetection")))
    <|>
-   ((parseRules ("VHDL","preDetection")))
+   ((pRegExpr regex_'28'5cb'29package'5cb >>= withAttribute KeywordTok))
    <|>
-   ((pString False "begin" >>= withAttribute KeywordTok))
+   ((pRegExpr regex_'28'5cb'29is'5cb >>= withAttribute KeywordTok) >>~ pushContext ("VHDL","packagemain"))
    <|>
-   ((pRegExprDynamic "(\\b)end(\\s+package)?(\\s+%3)?\\s*;" >>= withAttribute KeywordTok) >>~ (popContext))
+   ((pRegExprDynamic "(\\b)%2\\b" >>= withAttribute KeywordTok))
    <|>
+   ((pRegExprDynamic "(\\b)end(\\s+package)?(\\s+%2)?\\s*;" >>= withAttribute KeywordTok) >>~ (popContext))
+   <|>
    ((parseRules ("VHDL","generalDetection")))
    <|>
    (currentContext >>= \x -> guard (x == ("VHDL","package")) >> pDefault >>= withAttribute NormalTok))
 
+parseRules ("VHDL","packagemain") =
+  (((parseRules ("VHDL","preDetection")))
+   <|>
+   ((lookAhead (pRegExpr regex_'28'5cb'29end'5cb) >> (popContext) >> currentContext >>= parseRules))
+   <|>
+   ((pRegExpr regex_'28'5cb'29function'5cb >>= withAttribute KeywordTok) >>~ pushContext ("VHDL","packagefunction"))
+   <|>
+   ((parseRules ("VHDL","generalDetection")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("VHDL","packagemain")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("VHDL","packagefunction") =
+  (((pRegExpr regex_'28'5cb'29'5cb'28'3f'21'28'3f'3aprocess'7cconstant'7csignal'7cvariable'29'29'28'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'29'5cb'5cb >>= withAttribute KeywordTok) >>~ (popContext))
+   <|>
+   (currentContext >>= \x -> guard (x == ("VHDL","packagefunction")) >> pDefault >>= withAttribute NormalTok))
+
 parseRules ("VHDL","packagebody") =
-  (((pString True "%2" >>= withAttribute KeywordTok))
+  (((parseRules ("VHDL","preDetection")))
    <|>
-   ((parseRules ("VHDL","preDetection")))
+   ((pRegExpr regex_'28'5cb'29package'5cb >>= withAttribute KeywordTok))
    <|>
-   ((pString False "begin" >>= withAttribute KeywordTok))
+   ((pRegExpr regex_'28'5cb'29is'5cb >>= withAttribute KeywordTok) >>~ pushContext ("VHDL","packagebodymain"))
    <|>
-   ((pRegExprDynamic "(\\b)end(\\s+package)?(\\s+%3)?\\s*;" >>= withAttribute KeywordTok) >>~ (popContext))
+   ((pRegExprDynamic "(\\b)%2\\b" >>= withAttribute KeywordTok))
    <|>
+   ((pRegExprDynamic "(\\b)end(\\s+package)?(\\s+%2)?\\s*;" >>= withAttribute KeywordTok) >>~ (popContext))
+   <|>
    ((parseRules ("VHDL","generalDetection")))
    <|>
    (currentContext >>= \x -> guard (x == ("VHDL","packagebody")) >> pDefault >>= withAttribute NormalTok))
 
+parseRules ("VHDL","packagebodymain") =
+  (((parseRules ("VHDL","preDetection")))
+   <|>
+   ((lookAhead (pRegExpr regex_'28'5cb'29end'5cs'2bpackage'5cb) >> (popContext) >> currentContext >>= parseRules))
+   <|>
+   ((lookAhead (pRegExprDynamic "(\\b)function\\s+(\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)\\b") >> pushContext ("VHDL","packagebodyfunc1") >> currentContext >>= parseRules))
+   <|>
+   ((parseRules ("VHDL","generalDetection")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("VHDL","packagebodymain")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("VHDL","packagebodyfunc1") =
+  (((parseRules ("VHDL","preDetection")))
+   <|>
+   ((pRegExpr regex_'28'5cb'29begin'5cb >>= withAttribute KeywordTok) >>~ pushContext ("VHDL","packagebodyfunc2"))
+   <|>
+   ((pRegExprDynamic "(\\b)end(\\s+function)?(\\s+%2)?\\b" >>= withAttribute KeywordTok) >>~ (popContext))
+   <|>
+   ((pRegExprDynamic "(\\b)%2\\b" >>= withAttribute KeywordTok))
+   <|>
+   ((parseRules ("VHDL","generalDetection")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("VHDL","packagebodyfunc1")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("VHDL","packagebodyfunc2") =
+  (((parseRules ("VHDL","preDetection")))
+   <|>
+   ((lookAhead (pRegExprDynamic "(\\b)end(\\s+function)?\\b") >> (popContext) >> currentContext >>= parseRules))
+   <|>
+   ((pRegExpr regex_'28'5cb'29begin'5cb >>= withAttribute KeywordTok))
+   <|>
+   ((parseRules ("VHDL","proc_rules")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("VHDL","packagebodyfunc2")) >> pDefault >>= withAttribute NormalTok))
+
 parseRules ("VHDL","architecture_main") =
   (((parseRules ("VHDL","preDetection")))
    <|>
-   ((pRegExpr regex_architecture'5cs'2b'28'5cb'28'3f'21'28'3f'3aprocess'7cconstant'7csignal'7cvariable'29'29'28'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'29'5cb'29'5cs'2bof'5cs'2b'28'5cb'28'3f'21'28'3f'3aprocess'7cconstant'7csignal'7cvariable'29'29'28'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'29'5cb'29'5cs'2bis >>= withAttribute KeywordTok) >>~ pushContext ("VHDL","arch_decl"))
+   ((lookAhead (pRegExprDynamic "(\\b)architecture\\s+(\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)\\s+of\\s+(\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)\\s+is") >> pushContext ("VHDL","arch_start") >> currentContext >>= parseRules))
    <|>
-   ((pRegExprDynamic "(\\b)end(\\s+architecture)?(\\s+%1)?\\s*;" >>= withAttribute KeywordTok) >>~ (popContext >> popContext))
+   ((pRegExprDynamic "(\\b)end(\\s+architecture)?(\\s+%2)?\\s*;" >>= withAttribute KeywordTok) >>~ (popContext >> popContext))
    <|>
    ((pRegExprDynamic "(\\b)end(\\s+architecture)?(\\s+\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)\\s*;" >>= withAttribute ErrorTok) >>~ (popContext >> popContext))
    <|>
@@ -160,6 +245,19 @@
    <|>
    (currentContext >>= \x -> guard (x == ("VHDL","architecture_main")) >> pDefault >>= withAttribute NormalTok))
 
+parseRules ("VHDL","arch_start") =
+  (((parseRules ("VHDL","preDetection")))
+   <|>
+   ((pRegExpr regex_'28'5cb'29is'5cb >>= withAttribute KeywordTok) >>~ pushContext ("VHDL","arch_decl"))
+   <|>
+   ((pRegExprDynamic "(\\b)%2\\b" >>= withAttribute KeywordTok))
+   <|>
+   ((pRegExprDynamic "(\\b)%4\\b" >>= withAttribute FunctionTok))
+   <|>
+   ((parseRules ("VHDL","generalDetection")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("VHDL","arch_start")) >> pDefault >>= withAttribute KeywordTok))
+
 parseRules ("VHDL","arch_decl") =
   (((parseRules ("VHDL","preDetection")))
    <|>
@@ -167,18 +265,18 @@
    <|>
    ((pString False "component" >>= withAttribute KeywordTok) >>~ pushContext ("VHDL","entity"))
    <|>
-   ((pString False "begin" >>= withAttribute KeywordTok) >>~ (popContext))
+   ((pString False "begin" >>= withAttribute KeywordTok) >>~ (popContext >> popContext))
    <|>
    ((parseRules ("VHDL","generalDetection")))
    <|>
    (currentContext >>= \x -> guard (x == ("VHDL","arch_decl")) >> pDefault >>= withAttribute NormalTok))
 
 parseRules ("VHDL","detect_arch_parts") =
-  (((lookAhead (pRegExprDynamic "(\\b)((\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)\\s*:\\s*)(if|for).*\\s+generate\\b") >> pushContext ("VHDL","generate1") >> currentContext >>= parseRules))
+  (((lookAhead (pRegExprDynamic "(\\b)(\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b\\s*:\\s*)(if|for).*\\s+generate\\b") >> pushContext ("VHDL","generate1") >> currentContext >>= parseRules))
    <|>
-   ((lookAhead (pRegExprDynamic "(\\b)((\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)\\s*:\\s*)?process\\b") >> pushContext ("VHDL","process1") >> currentContext >>= parseRules))
+   ((lookAhead (pRegExprDynamic "(\\b)(\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b\\s*:\\s*)?process\\b") >> pushContext ("VHDL","process1") >> currentContext >>= parseRules))
    <|>
-   ((lookAhead (pRegExprDynamic "\\b(\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)\\s*:\\s*(\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)") >> pushContext ("VHDL","instance") >> currentContext >>= parseRules))
+   ((lookAhead (pRegExprDynamic "(\\b)(\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)\\s*:\\s*((entity\\s+)?(\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)(\\.\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)?)") >> pushContext ("VHDL","instance") >> currentContext >>= parseRules))
    <|>
    ((parseRules ("VHDL","generalDetection")))
    <|>
@@ -187,13 +285,11 @@
 parseRules ("VHDL","generate1") =
   (((parseRules ("VHDL","preDetection")))
    <|>
-   ((pRegExpr regex_'28'5cb'29generate'5cb >>= withAttribute KeywordTok) >>~ pushContext ("VHDL","generate2"))
+   ((pRegExpr regex_'28'5cb'29'28generate'7cloop'29'5cb >>= withAttribute KeywordTok) >>~ pushContext ("VHDL","generate2"))
    <|>
    ((pRegExprDynamic "(\\b)%3\\b" >>= withAttribute KeywordTok))
    <|>
-   ((pString False "for" >>= withAttribute KeywordTok))
-   <|>
-   ((pString False "if" >>= withAttribute KeywordTok))
+   ((pRegExpr regex_'28'5cb'29'28for'7cif'7cwhile'29'5cb >>= withAttribute KeywordTok))
    <|>
    ((parseRules ("VHDL","generalDetection")))
    <|>
@@ -202,9 +298,9 @@
 parseRules ("VHDL","generate2") =
   (((parseRules ("VHDL","preDetection")))
    <|>
-   ((pString False "begin" >>= withAttribute KeywordTok))
+   ((pRegExpr regex_'28'5cb'29begin'5cb >>= withAttribute KeywordTok))
    <|>
-   ((pRegExpr regex_'28'5cb'29end'5cs'2bgenerate'28'5cs'2b'5cb'28'3f'21'28'3f'3aprocess'7cconstant'7csignal'7cvariable'29'29'28'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'29'5cb'29'3f'5cs'2a'3b >>= withAttribute KeywordTok) >>~ (popContext >> popContext))
+   ((pRegExpr regex_'28'5cb'29end'5cs'2b'28generate'7cloop'29'28'5cs'2b'5cb'28'3f'21'28'3f'3aprocess'7cconstant'7csignal'7cvariable'29'29'28'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'29'5cb'29'3f >>= withAttribute KeywordTok) >>~ (popContext >> popContext))
    <|>
    ((parseRules ("VHDL","detect_arch_parts")))
    <|>
@@ -213,13 +309,13 @@
 parseRules ("VHDL","process1") =
   (((parseRules ("VHDL","preDetection")))
    <|>
-   ((pRegExprDynamic "end\\s+process(\\s+%3)?\\s*;" >>= withAttribute KeywordTok) >>~ (popContext))
+   ((pRegExprDynamic "(\\b)end\\s+process(\\s+%3)?" >>= withAttribute KeywordTok) >>~ (popContext))
    <|>
-   ((pRegExprDynamic "end\\s+process(\\s+\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)?" >>= withAttribute ErrorTok) >>~ (popContext))
+   ((pRegExprDynamic "(\\b)end\\s+process(\\s+\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)?" >>= withAttribute ErrorTok) >>~ (popContext))
    <|>
-   ((pString False "process" >>= withAttribute KeywordTok))
+   ((pRegExpr regex_'28'5cb'29process'5cb >>= withAttribute KeywordTok))
    <|>
-   ((pString False "begin" >>= withAttribute KeywordTok))
+   ((pRegExpr regex_'28'5cb'29begin'5cb >>= withAttribute KeywordTok))
    <|>
    ((parseRules ("VHDL","proc_rules")))
    <|>
@@ -228,11 +324,11 @@
 parseRules ("VHDL","proc_rules") =
   (((pRegExpr regex_'28'5cb'29'5cb'28'3f'21'28'3f'3aprocess'7cconstant'7csignal'7cvariable'29'29'28'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'29'5cb'28'3f'3d'5cs'2a'3a'28'3f'21'3d'29'29 >>= withAttribute KeywordTok))
    <|>
-   ((pRegExpr regex_'28'5cb'29'28if'29'5cb >>= withAttribute KeywordTok) >>~ pushContext ("VHDL","if_start"))
+   ((pRegExpr regex_'28'5cb'29if'5cb >>= withAttribute KeywordTok) >>~ pushContext ("VHDL","if_start"))
    <|>
-   ((lookAhead (pRegExprDynamic "(\\b)(case)\\b") >> pushContext ("VHDL","case1") >> currentContext >>= parseRules))
+   ((lookAhead (pRegExpr regex_'28'5cb'29case'5cb) >> pushContext ("VHDL","case1") >> currentContext >>= parseRules))
    <|>
-   ((pRegExpr regex_'28'5cb'29'28'28'5cb'28'3f'21'28'3f'3aprocess'7cconstant'7csignal'7cvariable'29'29'28'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'29'5cb'29'5cs'2a'3a'5cs'2a'29'3f'28'28for'7cwhile'29'5cs'2b'2e'2b'5cs'2b'29'3floop'5cb >>= withAttribute KeywordTok) >>~ pushContext ("VHDL","forOrWhile"))
+   ((lookAhead (pRegExprDynamic "(\\b)((\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)\\s*:\\s*)?((for|while)\\s+.+\\s+)loop\\b") >> pushContext ("VHDL","forwhile1") >> currentContext >>= parseRules))
    <|>
    ((parseRules ("VHDL","generalDetection")))
    <|>
@@ -241,29 +337,74 @@
 parseRules ("VHDL","instance") =
   (((parseRules ("VHDL","preDetection")))
    <|>
-   ((pRegExprDynamic "\\b%1\\b" >>= withAttribute KeywordTok))
+   ((pRegExprDynamic "(\\b)%4\\b" >>= withAttribute FunctionTok))
    <|>
-   ((pRegExprDynamic "\\b%2\\b" >>= withAttribute KeywordTok))
+   ((pRegExprDynamic "(\\b)%3\\b" >>= withAttribute KeywordTok))
    <|>
-   ((pDetect2Chars False ')' ';' >>= withAttribute NormalTok) >>~ (popContext))
+   ((pRegExpr regex_'28'5cb'29'28port'7cgeneric'29'5cs'2bmap'5cs'2a'5c'28 >>= withAttribute KeywordTok) >>~ pushContext ("VHDL","instanceMap"))
    <|>
+   ((pDetectChar False ';' >>= withAttribute NormalTok) >>~ (popContext))
+   <|>
    ((parseRules ("VHDL","generalDetection")))
    <|>
-   (currentContext >>= \x -> guard (x == ("VHDL","instance")) >> pDefault >>= withAttribute NormalTok))
+   (currentContext >>= \x -> guard (x == ("VHDL","instance")) >> pDefault >>= withAttribute ErrorTok))
 
-parseRules ("VHDL","forOrWhile") =
-  (((pRegExpr regex_'28'5cb'29end'5cs'2bloop'28'5cs'2b'5cb'28'3f'21'28'3f'3aprocess'7cconstant'7csignal'7cvariable'29'29'28'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'29'5cb'29'3f'5cs'2a'3b >>= withAttribute KeywordTok) >>~ (popContext))
+parseRules ("VHDL","instanceMap") =
+  (((pAnyChar "<;:" >>= withAttribute ErrorTok))
    <|>
-   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_forOrWhile >>= withAttribute KeywordTok))
+   ((pDetectChar False ':' >>= withAttribute ErrorTok))
    <|>
+   ((parseRules ("VHDL","preDetection")))
+   <|>
+   ((pDetectChar False ')' >>= withAttribute NormalTok) >>~ (popContext))
+   <|>
+   ((pDetectChar False '(' >>= withAttribute NormalTok) >>~ pushContext ("VHDL","instanceInnerPar"))
+   <|>
+   ((parseRules ("VHDL","generalDetection")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("VHDL","instanceMap")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("VHDL","instanceInnerPar") =
+  (((parseRules ("VHDL","preDetection")))
+   <|>
+   ((pDetectChar False ')' >>= withAttribute NormalTok) >>~ (popContext))
+   <|>
+   ((pDetectChar False '(' >>= withAttribute NormalTok) >>~ pushContext ("VHDL","instanceInnerPar"))
+   <|>
+   ((pDetectChar False ';' >>= withAttribute ErrorTok))
+   <|>
+   ((parseRules ("VHDL","generalDetection")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("VHDL","instanceInnerPar")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("VHDL","forwhile1") =
+  (((parseRules ("VHDL","preDetection")))
+   <|>
+   ((pRegExpr regex_'28'5cb'29loop'5cb >>= withAttribute KeywordTok) >>~ pushContext ("VHDL","forwhile2"))
+   <|>
+   ((pRegExprDynamic "(\\b)%3\\b" >>= withAttribute KeywordTok))
+   <|>
+   ((pRegExpr regex_'28'5cb'29'28for'7cwhile'29'5cb >>= withAttribute KeywordTok))
+   <|>
+   ((parseRules ("VHDL","generalDetection")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("VHDL","forwhile1")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("VHDL","forwhile2") =
+  (((parseRules ("VHDL","preDetection")))
+   <|>
+   ((pRegExpr regex_'28'5cb'29begin'5cb >>= withAttribute KeywordTok))
+   <|>
+   ((pRegExpr regex_'28'5cb'29end'5cs'2bloop'28'5cs'2b'5cb'28'3f'21'28'3f'3aprocess'7cconstant'7csignal'7cvariable'29'29'28'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'29'5cb'29'3f >>= withAttribute KeywordTok) >>~ (popContext >> popContext))
+   <|>
    ((parseRules ("VHDL","proc_rules")))
    <|>
-   (currentContext >>= \x -> guard (x == ("VHDL","forOrWhile")) >> pDefault >>= withAttribute NormalTok))
+   (currentContext >>= \x -> guard (x == ("VHDL","forwhile2")) >> pDefault >>= withAttribute NormalTok))
 
 parseRules ("VHDL","if_start") =
   (((parseRules ("VHDL","preDetection")))
    <|>
-   ((pString False "then" >>= withAttribute KeywordTok) >>~ pushContext ("VHDL","if"))
+   ((pRegExpr regex_'28'5cb'29then'5cb >>= withAttribute KeywordTok) >>~ pushContext ("VHDL","if"))
    <|>
    ((parseRules ("VHDL","generalDetection")))
    <|>
@@ -283,34 +424,49 @@
 parseRules ("VHDL","case1") =
   (((parseRules ("VHDL","preDetection")))
    <|>
-   ((pString False "is" >>= withAttribute KeywordTok) >>~ pushContext ("VHDL","case2"))
+   ((pRegExpr regex_'28'5cb'29is'5cb >>= withAttribute KeywordTok) >>~ pushContext ("VHDL","case2"))
    <|>
    ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_case >>= withAttribute KeywordTok))
    <|>
+   ((parseRules ("VHDL","generalDetection")))
+   <|>
    (currentContext >>= \x -> guard (x == ("VHDL","case1")) >> pDefault >>= withAttribute NormalTok))
 
 parseRules ("VHDL","case2") =
   (((parseRules ("VHDL","preDetection")))
    <|>
-   ((pRegExpr regex_'28'5cb'29end'5cs'2bcase'28'5cs'2b'5cb'28'3f'21'28'3f'3aprocess'7cconstant'7csignal'7cvariable'29'29'28'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'29'5cb'29'3f'5cs'2a'3b >>= withAttribute KeywordTok) >>~ (popContext >> popContext))
+   ((pRegExpr regex_'28'5cb'29end'5cs'2bcase'28'5cb'28'3f'21'28'3f'3aprocess'7cconstant'7csignal'7cvariable'29'29'28'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'29'5cb'29'3f'5cs'2a'3b >>= withAttribute KeywordTok) >>~ (popContext >> popContext))
    <|>
-   ((pString False "when" >>= withAttribute KeywordTok) >>~ pushContext ("VHDL","caseWhen"))
+   ((lookAhead (pRegExprDynamic "(\\b)when(\\s+\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)?\\b") >> pushContext ("VHDL","caseWhen") >> currentContext >>= parseRules))
    <|>
    ((parseRules ("VHDL","proc_rules")))
    <|>
    (currentContext >>= \x -> guard (x == ("VHDL","case2")) >> pDefault >>= withAttribute NormalTok))
 
 parseRules ("VHDL","caseWhen") =
-  (((parseRules ("VHDL","preDetection")))
+  (((pDetect2Chars False '=' '>' >>= withAttribute OtherTok) >>~ pushContext ("VHDL","caseWhen2"))
    <|>
-   ((lookAhead (pRegExpr regex_'28'5cb'29when'5cb) >> (popContext) >> currentContext >>= parseRules))
+   ((parseRules ("VHDL","preDetection")))
    <|>
-   ((lookAhead (pRegExpr regex_'28'5cb'29end'5cs'2bcase'28'5cs'2b'5cb'28'3f'21'28'3f'3aprocess'7cconstant'7csignal'7cvariable'29'29'28'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'29'5cb'29'3f'5cs'2a'3b) >> (popContext) >> currentContext >>= parseRules))
+   ((pRegExpr regex_'28'5cb'29when'5cb >>= withAttribute KeywordTok))
    <|>
+   ((pRegExprDynamic "(\\b)%2\\b" >>= withAttribute KeywordTok))
+   <|>
    ((parseRules ("VHDL","proc_rules")))
    <|>
    (currentContext >>= \x -> guard (x == ("VHDL","caseWhen")) >> pDefault >>= withAttribute NormalTok))
 
+parseRules ("VHDL","caseWhen2") =
+  (((parseRules ("VHDL","preDetection")))
+   <|>
+   ((pColumn 0 >> lookAhead (pRegExpr regex_'5cs'2awhen'5cb) >> (popContext >> popContext) >> currentContext >>= parseRules))
+   <|>
+   ((pColumn 0 >> lookAhead (pRegExpr regex_'5cs'2aend'5cs'2bcase'5cb) >> (popContext >> popContext) >> currentContext >>= parseRules))
+   <|>
+   ((parseRules ("VHDL","proc_rules")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("VHDL","caseWhen2")) >> pDefault >>= withAttribute NormalTok))
+
 parseRules ("VHDL","entity") =
   (((parseRules ("VHDL","preDetection")))
    <|>
@@ -335,6 +491,52 @@
    <|>
    (currentContext >>= \x -> guard (x == ("VHDL","entity_main")) >> pDefault >>= withAttribute NormalTok))
 
+parseRules ("VHDL","configuration") =
+  (((parseRules ("VHDL","preDetection")))
+   <|>
+   ((lookAhead (pRegExprDynamic "(\\b)configuration\\s+(\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)\\s+of\\s+(\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)\\s+is") >> pushContext ("VHDL","conf_start") >> currentContext >>= parseRules))
+   <|>
+   ((pRegExprDynamic "(\\b)end(\\s+configuration)?(\\s+%2)?\\s*;" >>= withAttribute KeywordTok) >>~ (popContext >> popContext))
+   <|>
+   ((pRegExprDynamic "(\\b)end(\\s+configuration)?(\\s+\\b(?!(?:process|constant|signal|variable))([A-Za-z_][A-Za-z0-9_]*)\\b)\\s*;" >>= withAttribute ErrorTok) >>~ (popContext >> popContext))
+   <|>
+   (currentContext >>= \x -> guard (x == ("VHDL","configuration")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("VHDL","conf_start") =
+  (((parseRules ("VHDL","preDetection")))
+   <|>
+   ((pRegExpr regex_'28'5cb'29is'5cb >>= withAttribute KeywordTok) >>~ pushContext ("VHDL","conf_decl"))
+   <|>
+   ((pRegExprDynamic "(\\b)%2\\b" >>= withAttribute KeywordTok))
+   <|>
+   ((pRegExprDynamic "(\\b)%4\\b" >>= withAttribute FunctionTok))
+   <|>
+   ((parseRules ("VHDL","generalDetection")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("VHDL","conf_start")) >> pDefault >>= withAttribute KeywordTok))
+
+parseRules ("VHDL","conf_decl") =
+  (((parseRules ("VHDL","preDetection")))
+   <|>
+   ((pString False "for" >>= withAttribute KeywordTok) >>~ pushContext ("VHDL","conf_for"))
+   <|>
+   ((lookAhead (pString False "end") >> (popContext >> popContext) >> currentContext >>= parseRules))
+   <|>
+   ((parseRules ("VHDL","generalDetection")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("VHDL","conf_decl")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("VHDL","conf_for") =
+  (((parseRules ("VHDL","preDetection")))
+   <|>
+   ((pString False "for" >>= withAttribute KeywordTok) >>~ pushContext ("VHDL","conf_for"))
+   <|>
+   ((pRegExpr regex_end'28'5cs'2b'5cb'28'3f'21'28'3f'3aprocess'7cconstant'7csignal'7cvariable'29'29'28'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'29'5cb'29'3f >>= withAttribute KeywordTok) >>~ (popContext))
+   <|>
+   ((parseRules ("VHDL","generalDetection")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("VHDL","conf_for")) >> pDefault >>= withAttribute NormalTok))
+
 parseRules ("VHDL","preDetection") =
   (((pDetect2Chars False '-' '-' >>= withAttribute CommentTok) >>~ pushContext ("VHDL","comment"))
    <|>
@@ -349,6 +551,8 @@
 parseRules ("VHDL","generalDetection") =
   (((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_types >>= withAttribute DataTypeTok))
    <|>
+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_timeunits >>= withAttribute DataTypeTok))
+   <|>
    ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_signals >>= withAttribute OtherTok) >>~ pushContext ("VHDL","signal"))
    <|>
    ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_range >>= withAttribute OtherTok))
@@ -374,11 +578,13 @@
 parseRules ("VHDL","attribute") =
   (((pDetectChar False '"' >>= withAttribute BaseNTok) >>~ pushContext ("VHDL","quot in att"))
    <|>
+   ((pDetectChar False '"' >>= withAttribute BaseNTok) >>~ pushContext ("VHDL","quot in att"))
+   <|>
    ((pDetectChar False ' ' >>= withAttribute NormalTok) >>~ (popContext))
    <|>
    ((pDetectChar False '\'' >>= withAttribute BaseNTok) >>~ (popContext))
    <|>
-   ((pAnyChar "()=<>" >>= withAttribute BaseNTok) >>~ (popContext))
+   ((pAnyChar ")=<>" >>= withAttribute BaseNTok) >>~ (popContext))
    <|>
    (currentContext >>= \x -> guard (x == ("VHDL","attribute")) >> pDefault >>= withAttribute BaseNTok))
 
@@ -390,7 +596,7 @@
 parseRules ("VHDL","signal") =
   (((parseRules ("VHDL","preDetection")))
    <|>
-   ((pDetectChar False ';' >>= withAttribute NormalTok) >>~ (popContext))
+   ((lookAhead (pDetectChar False ';') >> (popContext) >> currentContext >>= parseRules))
    <|>
    ((parseRules ("VHDL","generalDetection")))
    <|>
diff --git a/Text/Highlighting/Kate/Syntax/Yacc.hs b/Text/Highlighting/Kate/Syntax/Yacc.hs
--- a/Text/Highlighting/Kate/Syntax/Yacc.hs
+++ b/Text/Highlighting/Kate/Syntax/Yacc.hs
@@ -1,5 +1,5 @@
 {- This module was generated from data in the Kate syntax
-   highlighting file yacc.xml, version 1.03, by Jan Villat (jan.villat@net2000.ch) -}
+   highlighting file yacc.xml, version 1.04, by Jan Villat (jan.villat@net2000.ch) -}
 
 module Text.Highlighting.Kate.Syntax.Yacc
           (highlight, parseExpression, syntaxName, syntaxExtensions)
diff --git a/Text/Highlighting/Kate/Syntax/Zsh.hs b/Text/Highlighting/Kate/Syntax/Zsh.hs
new file mode 100644
--- /dev/null
+++ b/Text/Highlighting/Kate/Syntax/Zsh.hs
@@ -0,0 +1,757 @@
+{- This module was generated from data in the Kate syntax
+   highlighting file zsh.xml, version 0.1, by Jonathan Kolberg (bulldog98@kubuntu-de.org) -}
+
+module Text.Highlighting.Kate.Syntax.Zsh
+          (highlight, parseExpression, syntaxName, syntaxExtensions)
+where
+import Text.Highlighting.Kate.Types
+import Text.Highlighting.Kate.Common
+import qualified Text.Highlighting.Kate.Syntax.Alert
+import Text.ParserCombinators.Parsec hiding (State)
+import Control.Monad.State
+import Data.Char (isSpace)
+import qualified Data.Set as Set
+
+-- | Full name of language.
+syntaxName :: String
+syntaxName = "Zsh"
+
+-- | Filename extensions for this language.
+syntaxExtensions :: String
+syntaxExtensions = "*.sh;*.zsh;.zshrc;.zprofile;.zlogin;.zlogout;.profile"
+
+-- | Highlight source code using this syntax definition.
+highlight :: String -> [SourceLine]
+highlight input = evalState (mapM parseSourceLine $ lines input) startingState
+
+parseSourceLine :: String -> State SyntaxState SourceLine
+parseSourceLine = mkParseSourceLine (parseExpression Nothing)
+
+-- | Parse an expression using appropriate local context.
+parseExpression :: Maybe (String,String)
+                -> KateParser Token
+parseExpression mbcontext = do
+  (lang,cont) <- maybe currentContext return mbcontext
+  result <- parseRules (lang,cont)
+  optional $ do eof
+                updateState $ \st -> st{ synStPrevChar = '\n' }
+                pEndLine
+  return result
+
+startingState = SyntaxState {synStContexts = [("Zsh","Start")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}
+
+pEndLine = do
+  updateState $ \st -> st{ synStPrevNonspace = False }
+  context <- currentContext
+  contexts <- synStContexts `fmap` getState
+  if length contexts >= 2
+    then case context of
+      ("Zsh","Start") -> return ()
+      ("Zsh","FindAll") -> return ()
+      ("Zsh","FindMost") -> return ()
+      ("Zsh","FindComments") -> (popContext) >> pEndLine
+      ("Zsh","Comment") -> (popContext) >> pEndLine
+      ("Zsh","FindCommentsParen") -> (popContext) >> pEndLine
+      ("Zsh","CommentParen") -> (popContext) >> pEndLine
+      ("Zsh","FindCommentsBackq") -> (popContext) >> pEndLine
+      ("Zsh","CommentBackq") -> (popContext) >> pEndLine
+      ("Zsh","FindCommands") -> return ()
+      ("Zsh","FindOthers") -> return ()
+      ("Zsh","FindStrings") -> return ()
+      ("Zsh","FindSubstitutions") -> return ()
+      ("Zsh","FindTests") -> return ()
+      ("Zsh","ExprDblParen") -> return ()
+      ("Zsh","ExprDblParenSubst") -> return ()
+      ("Zsh","ExprSubParen") -> return ()
+      ("Zsh","ExprBracket") -> return ()
+      ("Zsh","ExprDblBracket") -> return ()
+      ("Zsh","Group") -> return ()
+      ("Zsh","SubShell") -> return ()
+      ("Zsh","Assign") -> (popContext) >> pEndLine
+      ("Zsh","AssignArray") -> (popContext) >> pEndLine
+      ("Zsh","AssignSubscr") -> (popContext) >> pEndLine
+      ("Zsh","Subscript") -> return ()
+      ("Zsh","FunctionDef") -> (popContext) >> pEndLine
+      ("Zsh","VarName") -> (popContext) >> pEndLine
+      ("Zsh","ProcessSubst") -> return ()
+      ("Zsh","StringSQ") -> return ()
+      ("Zsh","StringDQ") -> return ()
+      ("Zsh","StringEsc") -> return ()
+      ("Zsh","VarBrace") -> return ()
+      ("Zsh","VarAlt") -> return ()
+      ("Zsh","VarSubst") -> return ()
+      ("Zsh","VarSubst2") -> return ()
+      ("Zsh","VarSub") -> return ()
+      ("Zsh","VarSub2") -> return ()
+      ("Zsh","SubstFile") -> return ()
+      ("Zsh","SubstCommand") -> return ()
+      ("Zsh","SubstBackq") -> return ()
+      ("Zsh","Case") -> return ()
+      ("Zsh","CaseIn") -> return ()
+      ("Zsh","CaseExpr") -> return ()
+      ("Zsh","HereDoc") -> return ()
+      ("Zsh","HereDocRemainder") -> (popContext) >> pEndLine
+      ("Zsh","HereDocQ") -> return ()
+      ("Zsh","HereDocNQ") -> return ()
+      ("Zsh","HereDocIQ") -> return ()
+      ("Zsh","HereDocINQ") -> return ()
+      _ -> return ()
+    else return ()
+
+withAttribute attr txt = do
+  when (null txt) $ fail "Parser matched no text"
+  updateState $ \st -> st { synStPrevChar = last txt
+                          , synStPrevNonspace = synStPrevNonspace st || not (all isSpace txt) }
+  return (attr, txt)
+
+list_keywords = Set.fromList $ words $ "else for function in select until while elif then set"
+list_builtins = Set.fromList $ words $ "- . : alias autoload bg bindkey break builtin bye cap cd chdir clone command comparguments compcall compctl compdescribe compfiles compgroups compquote comptags comptry compvalues continue dirs disable disown echo echotc echoti emulate enable eval exec exit false fc fg functions getcap getopts hash history jobs kill let limit log logout noglob popd print printf pushd pushln pwd r rehash return sched set setcap setopt shift source stat suspend test times trap true ttyctl type ulimit umask unalias unfunction unhash unlimit unset unsetopt vared wait whence where which zcompile zformat zftp zle zmodload zparseopts zprof zpty zregexparse zsocket zstyle ztcp"
+list_builtins'5fvar = Set.fromList $ words $ "declare export float getln integer unset declare typeset local read readonly"
+list_unixcommands = Set.fromList $ words $ "arch awk bash bunzip2 bzcat bzcmp bzdiff bzegrep bzfgrep bzgrep bzip2 bzip2recover bzless bzmore cat chattr chgrp chmod chown chvt cp date dd deallocvt df dir dircolors dmesg dnsdomainname domainname du dumpkeys echo ed egrep false fgconsole fgrep fuser gawk getkeycodes gocr grep groff groups gunzip gzexe gzip hostname igawk install kbd_mode kbdrate killall last lastb link ln loadkeys loadunimap login ls lsattr lsmod lsmod.old lzcat lzcmp lzdiff lzegrep lzfgrep lzgrep lzless lzcat lzma lzmainfo lzmore mapscrn mesg mkdir mkfifo mknod mktemp more mount mv nano netstat nisdomainname nroff openvt pgawk pidof ping ps pstree pwd rbash readlink red resizecons rm rmdir run-parts sash sed setfont setkeycodes setleds setmetamode setserial sh showkey shred sleep ssed stat stty su sync tar tempfile touch troff true umount uname unicode_start unicode_stop unlink unlzma unxz utmpdump uuidgen vdir wall wc xz xzcat ypdomainname zcat zcmp zdiff zegrep zfgrep zforce zgrep zless zmore znew zsh aclocal aconnect aplay apm apmsleep apropos ar arecord as as86 autoconf autoheader automake awk basename bc bison c++ cal cat cc cdda2wav cdparanoia cdrdao cd-read cdrecord chfn chgrp chmod chown chroot chsh clear cmp co col comm cp cpio cpp cut dc dd df diff diff3 dir dircolors directomatic dirname du env expr fbset file find flex flex++ fmt free ftp funzip fuser g++ gawk gc gcc gdb getent getopt gettext gettextize gimp gimp-remote gimptool gmake gs head hexdump id install join kill killall ld ld86 ldd less lex ln locate lockfile logname lp lpr ls lynx m4 make man mkdir mknod msgfmt mv namei nasm nawk nice nl nm nm86 nmap nohup nop od passwd patch pcregrep pcretest perl perror pidof pr printf procmail prune ps2ascii ps2epsi ps2frag ps2pdf ps2ps psbook psmerge psnup psresize psselect pstops rcs rev rm scp sed seq setterm shred size size86 skill slogin snice sort sox split ssh ssh-add ssh-agent ssh-keygen ssh-keyscan stat strings strip sudo suidperl sum tac tail tee test tr uniq unlink unzip updatedb updmap uptime users vmstat w wc wget whatis whereis which who whoami write xargs yacc yes zip zsoelim dcop kdialog kfile xhost xmodmap xset"
+
+regex_'5b'5cs'3b'5d'28'3f'3d'23'29 = compileRegex True "[\\s;](?=#)"
+regex_'5b'5e'29'5d'28'3f'3d'5c'29'29 = compileRegex True "[^)](?=\\))"
+regex_'5b'5e'60'5d'28'3f'3d'60'29 = compileRegex True "[^`](?=`)"
+regex_'5c'5b'5c'5b'28'3f'3d'28'24'7c'5cs'29'29 = compileRegex True "\\[\\[(?=($|\\s))"
+regex_'5cs'5c'5b'5c'5b'28'3f'3d'28'24'7c'5cs'29'29 = compileRegex True "\\s\\[\\[(?=($|\\s))"
+regex_'5c'5b'28'3f'3d'28'24'7c'5cs'29'29 = compileRegex True "\\[(?=($|\\s))"
+regex_'5cs'5c'5b'28'3f'3d'28'24'7c'5cs'29'29 = compileRegex True "\\s\\[(?=($|\\s))"
+regex_'5c'7b'28'3f'3d'28'24'7c'5cs'29'29 = compileRegex True "\\{(?=($|\\s))"
+regex_'5cbdo'28'3f'21'5b'5cw'24'2b'2d'5d'29 = compileRegex True "\\bdo(?![\\w$+-])"
+regex_'5cbdone'28'3f'21'5b'5cw'24'2b'2d'5d'29 = compileRegex True "\\bdone(?![\\w$+-])"
+regex_'5cbif'28'3f'3d'28'24'7c'5cs'29'29 = compileRegex True "\\bif(?=($|\\s))"
+regex_'5cbfi'28'3f'21'5b'5cw'24'2b'2d'5d'29 = compileRegex True "\\bfi(?![\\w$+-])"
+regex_'5cbcase'28'3f'21'5b'5cw'24'2b'2d'5d'29 = compileRegex True "\\bcase(?![\\w$+-])"
+regex_'2d'5bA'2dZa'2dz0'2d9'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a = compileRegex True "-[A-Za-z0-9][A-Za-z0-9_]*"
+regex_'2d'2d'5ba'2dz'5d'5bA'2dZa'2dz0'2d9'5f'2d'5d'2a = compileRegex True "--[a-z][A-Za-z0-9_-]*"
+regex_'5cb'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'5c'2b'3f'3d = compileRegex True "\\b[A-Za-z_][A-Za-z0-9_]*\\+?="
+regex_'5cb'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'28'3f'3d'5c'5b'2e'2b'5c'5d'5c'2b'3f'3d'29 = compileRegex True "\\b[A-Za-z_][A-Za-z0-9_]*(?=\\[.+\\]\\+?=)"
+regex_'5cbfunction'5cb = compileRegex True "\\bfunction\\b"
+regex_'5c'2e'28'3f'3d'5cs'29 = compileRegex True "\\.(?=\\s)"
+regex_'5cd'2a'3c'3c'3c = compileRegex True "\\d*<<<"
+regex_'5b'3c'3e'5d'5c'28 = compileRegex True "[<>]\\("
+regex_'28'5b0'2d9'5d'2a'28'3e'7b1'2c2'7d'7c'3c'29'28'26'5b0'2d9'5d'2b'2d'3f'29'3f'7c'26'3e'7c'3e'26'7c'5b0'2d9'5d'2a'3c'3e'29 = compileRegex True "([0-9]*(>{1,2}|<)(&[0-9]+-?)?|&>|>&|[0-9]*<>)"
+regex_'28'5b'7c'26'5d'29'5c1'3f = compileRegex True "([|&])\\1?"
+regex_'5bA'2dZa'2dz'5f'3a'5d'5bA'2dZa'2dz0'2d9'5f'3a'23'25'40'2d'5d'2a'5cs'2a'5c'28'5c'29 = compileRegex True "[A-Za-z_:][A-Za-z0-9_:#%@-]*\\s*\\(\\)"
+regex_'5c'5c'5b'5d'5b'3b'5c'5c'24'60'7b'7d'28'29'7c'26'3c'3e'2a_'5d = compileRegex True "\\\\[][;\\\\$`{}()|&<>* ]"
+regex_'5c'5c'24 = compileRegex True "\\\\$"
+regex_'5c'7b'28'3f'21'28'5cs'7c'24'29'29'5cS'2a'5c'7d = compileRegex True "\\{(?!(\\s|$))\\S*\\}"
+regex_'28'5b'5cw'5f'40'2e'25'2a'3f'2b'2d'5d'7c'5c'5c_'29'2a'28'3f'3d'2f'29 = compileRegex True "([\\w_@.%*?+-]|\\\\ )*(?=/)"
+regex_'7e'5cw'2a = compileRegex True "~\\w*"
+regex_'2f'28'5b'5cw'5f'40'2e'25'2a'3f'2b'2d'5d'7c'5c'5c_'29'2a'28'3f'3d'28'5b'5cs'2f'29'3a'3b'24'60'27'22'5d'7c'24'29'29 = compileRegex True "/([\\w_@.%*?+-]|\\\\ )*(?=([\\s/):;$`'\"]|$))"
+regex_'5c'24'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'5c'5b = compileRegex True "\\$[A-Za-z_][A-Za-z0-9_]*\\["
+regex_'5c'24'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a = compileRegex True "\\$[A-Za-z_][A-Za-z0-9_]*"
+regex_'5c'24'5b'2a'40'23'3f'24'21'5f0'2d9'2d'5d = compileRegex True "\\$[*@#?$!_0-9-]"
+regex_'5c'24'5c'7b'5b'2a'40'23'3f'24'21'5f0'2d9'2d'5d'5c'7d = compileRegex True "\\$\\{[*@#?$!_0-9-]\\}"
+regex_'5c'24'5c'7b'23'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'28'5c'5b'5b'2a'40'5d'5c'5d'29'3f'5c'7d = compileRegex True "\\$\\{#[A-Za-z_][A-Za-z0-9_]*(\\[[*@]\\])?\\}"
+regex_'5c'24'5c'7b'21'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'28'5c'5b'5b'2a'40'5d'5c'5d'7c'5b'2a'40'5d'29'3f'5c'7d = compileRegex True "\\$\\{![A-Za-z_][A-Za-z0-9_]*(\\[[*@]\\]|[*@])?\\}"
+regex_'5c'24'5c'7b'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a = compileRegex True "\\$\\{[A-Za-z_][A-Za-z0-9_]*"
+regex_'5c'24'5c'7b'5b'2a'40'23'3f'24'21'5f0'2d9'2d'5d'28'3f'3d'5b'3a'23'25'2f'3d'3f'2b'2d'5d'29 = compileRegex True "\\$\\{[*@#?$!_0-9-](?=[:#%/=?+-])"
+regex_'5c'5c'5b'60'24'5c'5c'5d = compileRegex True "\\\\[`$\\\\]"
+regex_'2d'5babcdefghkprstuwxOGLSNozn'5d'28'3f'3d'5cs'29 = compileRegex True "-[abcdefghkprstuwxOGLSNozn](?=\\s)"
+regex_'2d'28'5bno'5dt'7cef'29'28'3f'3d'5cs'29 = compileRegex True "-([no]t|ef)(?=\\s)"
+regex_'28'5b'21'3d'5d'3d'3f'7c'5b'3e'3c'5d'29'28'3f'3d'5cs'29 = compileRegex True "([!=]=?|[><])(?=\\s)"
+regex_'2d'28eq'7cne'7c'5bgl'5d'5bte'5d'29'28'3f'3d'5cs'29 = compileRegex True "-(eq|ne|[gl][te])(?=\\s)"
+regex_'5cs'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 = compileRegex True "\\s\\](?=($|[\\s;|&]))"
+regex_'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 = compileRegex True "\\](?=($|[\\s;|&]))"
+regex_'5cs'5c'5d'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 = compileRegex True "\\s\\]\\](?=($|[\\s;|&]))"
+regex_'5c'5d'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 = compileRegex True "\\]\\](?=($|[\\s;|&]))"
+regex_'5b'5cw'3a'2c'2b'5f'2e'2f'2d'5d = compileRegex True "[\\w:,+_./-]"
+regex_'5cs'2b'5bA'2dZa'2dz'5f'3a'5d'5bA'2dZa'2dz0'2d9'5f'3a'23'25'40'2d'5d'2a'28'5cs'2a'5c'28'5c'29'29'3f = compileRegex True "\\s+[A-Za-z_:][A-Za-z0-9_:#%@-]*(\\s*\\(\\))?"
+regex_'2d'5bA'2dZa'2dz0'2d9'5d'2b = compileRegex True "-[A-Za-z0-9]+"
+regex_'5cb'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a = compileRegex True "\\b[A-Za-z_][A-Za-z0-9_]*"
+regex_'5b'5e'5d'7d'29'7c'3b'60'26'3e'3c'5d = compileRegex True "[^]})|;`&><]"
+regex_'5c'5c'5b'60'22'5c'5c'24'5cn'5d = compileRegex True "\\\\[`\"\\\\$\\n]"
+regex_'5c'5c'5babefnrtv'5c'5c'27'5d = compileRegex True "\\\\[abefnrtv\\\\']"
+regex_'5c'5c'28'5b0'2d7'5d'7b1'2c3'7d'7cx'5bA'2dFa'2df0'2d9'5d'7b1'2c2'7d'7cc'2e'29 = compileRegex True "\\\\([0-7]{1,3}|x[A-Fa-f0-9]{1,2}|c.)"
+regex_'28'3a'3f'5b'2d'3d'3f'2b'5d'7c'23'23'3f'7c'25'25'3f'29 = compileRegex True "(:?[-=?+]|##?|%%?)"
+regex_'2f'2f'3f = compileRegex True "//?"
+regex_'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a = compileRegex True "[A-Za-z_][A-Za-z0-9_]*"
+regex_'5b0'2d9'5d'2b'28'3f'3d'5b'3a'7d'5d'29 = compileRegex True "[0-9]+(?=[:}])"
+regex_'5b0'2d9'5d'28'3f'3d'5b'3a'7d'5d'29 = compileRegex True "[0-9](?=[:}])"
+regex_'5csin'5cb = compileRegex True "\\sin\\b"
+regex_'5cbesac'28'3f'3d'24'7c'5b'5cs'3b'29'5d'29 = compileRegex True "\\besac(?=$|[\\s;)])"
+regex_esac'28'3f'3d'24'7c'5b'5cs'3b'29'5d'29 = compileRegex True "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 True "(<<-\\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 True "(<<-\\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 True "(<<-\\s*\\\\([^|&;()<>\\s]+))"
+regex_'28'3c'3c'2d'5cs'2a'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'29 = compileRegex True "(<<-\\s*([^|&;()<>\\s]+))"
+regex_'28'3c'3c'5cs'2a'22'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'22'29 = compileRegex True "(<<\\s*\"([^|&;()<>\\s]+)\")"
+regex_'28'3c'3c'5cs'2a'27'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'27'29 = compileRegex True "(<<\\s*'([^|&;()<>\\s]+)')"
+regex_'28'3c'3c'5cs'2a'5c'5c'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'29 = compileRegex True "(<<\\s*\\\\([^|&;()<>\\s]+))"
+regex_'28'3c'3c'5cs'2a'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'29 = compileRegex True "(<<\\s*([^|&;()<>\\s]+))"
+
+parseRules ("Zsh","Start") =
+  (((parseRules ("Zsh","FindAll")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","Start")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Zsh","FindAll") =
+  (((parseRules ("Zsh","FindComments")))
+   <|>
+   ((parseRules ("Zsh","FindCommands")))
+   <|>
+   ((parseRules ("Zsh","FindStrings")))
+   <|>
+   ((parseRules ("Zsh","FindSubstitutions")))
+   <|>
+   ((parseRules ("Zsh","FindOthers")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","FindAll")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Zsh","FindMost") =
+  (((parseRules ("Zsh","FindComments")))
+   <|>
+   ((parseRules ("Zsh","FindStrings")))
+   <|>
+   ((parseRules ("Zsh","FindSubstitutions")))
+   <|>
+   ((parseRules ("Zsh","FindOthers")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","FindMost")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Zsh","FindComments") =
+  (((pFirstNonSpace >> pDetectChar False '#' >>= withAttribute CommentTok) >>~ pushContext ("Zsh","Comment"))
+   <|>
+   ((pRegExpr regex_'5b'5cs'3b'5d'28'3f'3d'23'29 >>= withAttribute NormalTok) >>~ pushContext ("Zsh","Comment"))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","FindComments")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Zsh","Comment") =
+  (((Text.Highlighting.Kate.Syntax.Alert.parseExpression (Just ("Alerts","")) >>= ((withAttribute CommentTok) . snd)))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","Comment")) >> pDefault >>= withAttribute CommentTok))
+
+parseRules ("Zsh","FindCommentsParen") =
+  (((pFirstNonSpace >> pDetectChar False '#' >>= withAttribute CommentTok) >>~ pushContext ("Zsh","CommentParen"))
+   <|>
+   ((pRegExpr regex_'5b'5cs'3b'5d'28'3f'3d'23'29 >>= withAttribute NormalTok) >>~ pushContext ("Zsh","CommentParen"))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","FindCommentsParen")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Zsh","CommentParen") =
+  (((pRegExpr regex_'5b'5e'29'5d'28'3f'3d'5c'29'29 >>= withAttribute CommentTok) >>~ (popContext))
+   <|>
+   ((Text.Highlighting.Kate.Syntax.Alert.parseExpression (Just ("Alerts","")) >>= ((withAttribute CommentTok) . snd)))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","CommentParen")) >> pDefault >>= withAttribute CommentTok))
+
+parseRules ("Zsh","FindCommentsBackq") =
+  (((pFirstNonSpace >> pDetectChar False '#' >>= withAttribute CommentTok) >>~ pushContext ("Zsh","CommentBackq"))
+   <|>
+   ((pRegExpr regex_'5b'5cs'3b'5d'28'3f'3d'23'29 >>= withAttribute NormalTok) >>~ pushContext ("Zsh","CommentBackq"))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","FindCommentsBackq")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Zsh","CommentBackq") =
+  (((pRegExpr regex_'5b'5e'60'5d'28'3f'3d'60'29 >>= withAttribute CommentTok) >>~ (popContext))
+   <|>
+   ((Text.Highlighting.Kate.Syntax.Alert.parseExpression (Just ("Alerts","")) >>= ((withAttribute CommentTok) . snd)))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","CommentBackq")) >> pDefault >>= withAttribute CommentTok))
+
+parseRules ("Zsh","FindCommands") =
+  (((pDetect2Chars False '(' '(' >>= withAttribute KeywordTok) >>~ pushContext ("Zsh","ExprDblParen"))
+   <|>
+   ((pColumn 0 >> pRegExpr regex_'5c'5b'5c'5b'28'3f'3d'28'24'7c'5cs'29'29 >>= withAttribute KeywordTok) >>~ pushContext ("Zsh","ExprDblBracket"))
+   <|>
+   ((pRegExpr regex_'5cs'5c'5b'5c'5b'28'3f'3d'28'24'7c'5cs'29'29 >>= withAttribute KeywordTok) >>~ pushContext ("Zsh","ExprDblBracket"))
+   <|>
+   ((pColumn 0 >> pRegExpr regex_'5c'5b'28'3f'3d'28'24'7c'5cs'29'29 >>= withAttribute KeywordTok) >>~ pushContext ("Zsh","ExprBracket"))
+   <|>
+   ((pRegExpr regex_'5cs'5c'5b'28'3f'3d'28'24'7c'5cs'29'29 >>= withAttribute KeywordTok) >>~ pushContext ("Zsh","ExprBracket"))
+   <|>
+   ((pRegExpr regex_'5c'7b'28'3f'3d'28'24'7c'5cs'29'29 >>= withAttribute KeywordTok) >>~ pushContext ("Zsh","Group"))
+   <|>
+   ((pDetectChar False '(' >>= withAttribute KeywordTok) >>~ pushContext ("Zsh","SubShell"))
+   <|>
+   ((pRegExpr regex_'5cbdo'28'3f'21'5b'5cw'24'2b'2d'5d'29 >>= withAttribute KeywordTok))
+   <|>
+   ((pRegExpr regex_'5cbdone'28'3f'21'5b'5cw'24'2b'2d'5d'29 >>= withAttribute KeywordTok))
+   <|>
+   ((pRegExpr regex_'5cbif'28'3f'3d'28'24'7c'5cs'29'29 >>= withAttribute KeywordTok))
+   <|>
+   ((pRegExpr regex_'5cbfi'28'3f'21'5b'5cw'24'2b'2d'5d'29 >>= withAttribute KeywordTok))
+   <|>
+   ((pRegExpr regex_'5cbcase'28'3f'21'5b'5cw'24'2b'2d'5d'29 >>= withAttribute KeywordTok) >>~ pushContext ("Zsh","Case"))
+   <|>
+   ((pRegExpr regex_'2d'5bA'2dZa'2dz0'2d9'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a >>= withAttribute NormalTok))
+   <|>
+   ((pRegExpr regex_'2d'2d'5ba'2dz'5d'5bA'2dZa'2dz0'2d9'5f'2d'5d'2a >>= withAttribute NormalTok))
+   <|>
+   ((pRegExpr regex_'5cb'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'5c'2b'3f'3d >>= withAttribute OtherTok) >>~ pushContext ("Zsh","Assign"))
+   <|>
+   ((pRegExpr regex_'5cb'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'28'3f'3d'5c'5b'2e'2b'5c'5d'5c'2b'3f'3d'29 >>= withAttribute OtherTok) >>~ pushContext ("Zsh","AssignSubscr"))
+   <|>
+   ((pString False ":()" >>= withAttribute FunctionTok))
+   <|>
+   ((pRegExpr regex_'5cbfunction'5cb >>= withAttribute KeywordTok) >>~ pushContext ("Zsh","FunctionDef"))
+   <|>
+   ((pKeyword " \n\t()!+,<=>&*;?|~\\`" list_keywords >>= withAttribute KeywordTok))
+   <|>
+   ((pRegExpr regex_'5c'2e'28'3f'3d'5cs'29 >>= withAttribute KeywordTok))
+   <|>
+   ((pKeyword " \n\t()!+,<=>&*;?|~\\`" list_builtins >>= withAttribute KeywordTok))
+   <|>
+   ((pKeyword " \n\t()!+,<=>&*;?|~\\`" list_unixcommands >>= withAttribute KeywordTok))
+   <|>
+   ((pKeyword " \n\t()!+,<=>&*;?|~\\`" list_builtins'5fvar >>= withAttribute KeywordTok) >>~ pushContext ("Zsh","VarName"))
+   <|>
+   ((pRegExpr regex_'5cd'2a'3c'3c'3c >>= withAttribute KeywordTok))
+   <|>
+   ((lookAhead (pString False "<<") >> pushContext ("Zsh","HereDoc") >> currentContext >>= parseRules))
+   <|>
+   ((pRegExpr regex_'5b'3c'3e'5d'5c'28 >>= withAttribute KeywordTok) >>~ pushContext ("Zsh","ProcessSubst"))
+   <|>
+   ((pRegExpr regex_'28'5b0'2d9'5d'2a'28'3e'7b1'2c2'7d'7c'3c'29'28'26'5b0'2d9'5d'2b'2d'3f'29'3f'7c'26'3e'7c'3e'26'7c'5b0'2d9'5d'2a'3c'3e'29 >>= withAttribute KeywordTok))
+   <|>
+   ((pRegExpr regex_'28'5b'7c'26'5d'29'5c1'3f >>= withAttribute KeywordTok))
+   <|>
+   ((pRegExpr regex_'5bA'2dZa'2dz'5f'3a'5d'5bA'2dZa'2dz0'2d9'5f'3a'23'25'40'2d'5d'2a'5cs'2a'5c'28'5c'29 >>= withAttribute FunctionTok))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","FindCommands")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Zsh","FindOthers") =
+  (((pRegExpr regex_'5c'5c'5b'5d'5b'3b'5c'5c'24'60'7b'7d'28'29'7c'26'3c'3e'2a_'5d >>= withAttribute DataTypeTok))
+   <|>
+   ((pRegExpr regex_'5c'5c'24 >>= withAttribute KeywordTok))
+   <|>
+   ((pRegExpr regex_'5c'7b'28'3f'21'28'5cs'7c'24'29'29'5cS'2a'5c'7d >>= withAttribute DataTypeTok))
+   <|>
+   ((pRegExpr regex_'28'5b'5cw'5f'40'2e'25'2a'3f'2b'2d'5d'7c'5c'5c_'29'2a'28'3f'3d'2f'29 >>= withAttribute NormalTok))
+   <|>
+   ((pRegExpr regex_'7e'5cw'2a >>= withAttribute NormalTok))
+   <|>
+   ((pRegExpr regex_'2f'28'5b'5cw'5f'40'2e'25'2a'3f'2b'2d'5d'7c'5c'5c_'29'2a'28'3f'3d'28'5b'5cs'2f'29'3a'3b'24'60'27'22'5d'7c'24'29'29 >>= withAttribute NormalTok))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","FindOthers")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Zsh","FindStrings") =
+  (((pDetect2Chars False '\\' '\'' >>= withAttribute DataTypeTok))
+   <|>
+   ((pDetect2Chars False '\\' '"' >>= withAttribute DataTypeTok))
+   <|>
+   ((pDetectChar False '\'' >>= withAttribute StringTok) >>~ pushContext ("Zsh","StringSQ"))
+   <|>
+   ((pDetectChar False '"' >>= withAttribute StringTok) >>~ pushContext ("Zsh","StringDQ"))
+   <|>
+   ((pDetect2Chars False '$' '\'' >>= withAttribute StringTok) >>~ pushContext ("Zsh","StringEsc"))
+   <|>
+   ((pDetect2Chars False '$' '"' >>= withAttribute StringTok) >>~ pushContext ("Zsh","StringDQ"))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","FindStrings")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Zsh","FindSubstitutions") =
+  (((pRegExpr regex_'5c'24'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'5c'5b >>= withAttribute OtherTok) >>~ pushContext ("Zsh","Subscript"))
+   <|>
+   ((pRegExpr regex_'5c'24'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a >>= withAttribute OtherTok))
+   <|>
+   ((pRegExpr regex_'5c'24'5b'2a'40'23'3f'24'21'5f0'2d9'2d'5d >>= withAttribute OtherTok))
+   <|>
+   ((pRegExpr regex_'5c'24'5c'7b'5b'2a'40'23'3f'24'21'5f0'2d9'2d'5d'5c'7d >>= withAttribute OtherTok))
+   <|>
+   ((pRegExpr regex_'5c'24'5c'7b'23'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'28'5c'5b'5b'2a'40'5d'5c'5d'29'3f'5c'7d >>= withAttribute OtherTok))
+   <|>
+   ((pRegExpr regex_'5c'24'5c'7b'21'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a'28'5c'5b'5b'2a'40'5d'5c'5d'7c'5b'2a'40'5d'29'3f'5c'7d >>= withAttribute OtherTok))
+   <|>
+   ((pRegExpr regex_'5c'24'5c'7b'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a >>= withAttribute OtherTok) >>~ pushContext ("Zsh","VarBrace"))
+   <|>
+   ((pRegExpr regex_'5c'24'5c'7b'5b'2a'40'23'3f'24'21'5f0'2d9'2d'5d'28'3f'3d'5b'3a'23'25'2f'3d'3f'2b'2d'5d'29 >>= withAttribute OtherTok) >>~ pushContext ("Zsh","VarBrace"))
+   <|>
+   ((pString False "$((" >>= withAttribute OtherTok) >>~ pushContext ("Zsh","ExprDblParenSubst"))
+   <|>
+   ((pString False "$(<" >>= withAttribute KeywordTok) >>~ pushContext ("Zsh","SubstFile"))
+   <|>
+   ((pString False "$(" >>= withAttribute OtherTok) >>~ pushContext ("Zsh","SubstCommand"))
+   <|>
+   ((pDetectChar False '`' >>= withAttribute KeywordTok) >>~ pushContext ("Zsh","SubstBackq"))
+   <|>
+   ((pRegExpr regex_'5c'5c'5b'60'24'5c'5c'5d >>= withAttribute DataTypeTok))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","FindSubstitutions")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Zsh","FindTests") =
+  (((pRegExpr regex_'2d'5babcdefghkprstuwxOGLSNozn'5d'28'3f'3d'5cs'29 >>= withAttribute OtherTok))
+   <|>
+   ((pRegExpr regex_'2d'28'5bno'5dt'7cef'29'28'3f'3d'5cs'29 >>= withAttribute OtherTok))
+   <|>
+   ((pRegExpr regex_'28'5b'21'3d'5d'3d'3f'7c'5b'3e'3c'5d'29'28'3f'3d'5cs'29 >>= withAttribute OtherTok))
+   <|>
+   ((pRegExpr regex_'2d'28eq'7cne'7c'5bgl'5d'5bte'5d'29'28'3f'3d'5cs'29 >>= withAttribute OtherTok))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","FindTests")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Zsh","ExprDblParen") =
+  (((pDetect2Chars False ')' ')' >>= withAttribute KeywordTok) >>~ (popContext))
+   <|>
+   ((pDetectChar False '(' >>= withAttribute NormalTok) >>~ pushContext ("Zsh","ExprSubParen"))
+   <|>
+   ((parseRules ("Zsh","FindMost")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","ExprDblParen")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Zsh","ExprDblParenSubst") =
+  (((pDetect2Chars False ')' ')' >>= withAttribute OtherTok) >>~ (popContext))
+   <|>
+   ((pDetectChar False '(' >>= withAttribute NormalTok) >>~ pushContext ("Zsh","ExprSubParen"))
+   <|>
+   ((parseRules ("Zsh","FindMost")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","ExprDblParenSubst")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Zsh","ExprSubParen") =
+  (((pDetectChar False ')' >>= withAttribute NormalTok) >>~ (popContext))
+   <|>
+   ((pDetectChar False '(' >>= withAttribute NormalTok) >>~ pushContext ("Zsh","ExprSubParen"))
+   <|>
+   ((parseRules ("Zsh","FindMost")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","ExprSubParen")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Zsh","ExprBracket") =
+  (((pRegExpr regex_'5cs'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 >>= withAttribute KeywordTok) >>~ (popContext))
+   <|>
+   ((pColumn 0 >> pRegExpr regex_'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 >>= withAttribute KeywordTok) >>~ (popContext))
+   <|>
+   ((pDetectChar False '(' >>= withAttribute NormalTok) >>~ pushContext ("Zsh","ExprSubParen"))
+   <|>
+   ((parseRules ("Zsh","FindTests")))
+   <|>
+   ((parseRules ("Zsh","FindMost")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","ExprBracket")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Zsh","ExprDblBracket") =
+  (((pRegExpr regex_'5cs'5c'5d'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 >>= withAttribute KeywordTok) >>~ (popContext))
+   <|>
+   ((pColumn 0 >> pRegExpr regex_'5c'5d'5c'5d'28'3f'3d'28'24'7c'5b'5cs'3b'7c'26'5d'29'29 >>= withAttribute KeywordTok) >>~ (popContext))
+   <|>
+   ((pDetectChar False '(' >>= withAttribute NormalTok) >>~ pushContext ("Zsh","ExprSubParen"))
+   <|>
+   ((parseRules ("Zsh","FindTests")))
+   <|>
+   ((parseRules ("Zsh","FindMost")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","ExprDblBracket")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Zsh","Group") =
+  (((pDetectChar False '}' >>= withAttribute KeywordTok) >>~ (popContext))
+   <|>
+   ((parseRules ("Zsh","FindAll")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","Group")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Zsh","SubShell") =
+  (((pDetectChar False ')' >>= withAttribute KeywordTok) >>~ (popContext))
+   <|>
+   ((parseRules ("Zsh","FindAll")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","SubShell")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Zsh","Assign") =
+  (((pDetectChar False '(' >>= withAttribute OtherTok) >>~ pushContext ("Zsh","AssignArray"))
+   <|>
+   ((parseRules ("Zsh","FindStrings")))
+   <|>
+   ((parseRules ("Zsh","FindSubstitutions")))
+   <|>
+   ((parseRules ("Zsh","FindOthers")))
+   <|>
+   ((pRegExpr regex_'5b'5cw'3a'2c'2b'5f'2e'2f'2d'5d >>= withAttribute NormalTok))
+   <|>
+   ((popContext) >> currentContext >>= parseRules))
+
+parseRules ("Zsh","AssignArray") =
+  (((pDetectChar False ')' >>= withAttribute OtherTok) >>~ (popContext))
+   <|>
+   ((pDetectChar False '[' >>= withAttribute OtherTok) >>~ pushContext ("Zsh","Subscript"))
+   <|>
+   ((pDetectChar False '=' >>= withAttribute OtherTok) >>~ pushContext ("Zsh","Assign"))
+   <|>
+   ((parseRules ("Zsh","FindMost")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","AssignArray")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Zsh","AssignSubscr") =
+  (((pDetectChar False '[' >>= withAttribute OtherTok) >>~ pushContext ("Zsh","Subscript"))
+   <|>
+   ((pDetect2Chars False '+' '=' >>= withAttribute OtherTok) >>~ pushContext ("Zsh","Assign"))
+   <|>
+   ((pDetectChar False '=' >>= withAttribute OtherTok) >>~ pushContext ("Zsh","Assign"))
+   <|>
+   ((parseRules ("Zsh","FindStrings")))
+   <|>
+   ((parseRules ("Zsh","FindSubstitutions")))
+   <|>
+   ((parseRules ("Zsh","FindOthers")))
+   <|>
+   ((popContext) >> currentContext >>= parseRules))
+
+parseRules ("Zsh","Subscript") =
+  (((pDetectChar False ']' >>= withAttribute OtherTok) >>~ (popContext))
+   <|>
+   ((parseRules ("Zsh","FindStrings")))
+   <|>
+   ((parseRules ("Zsh","FindSubstitutions")))
+   <|>
+   ((parseRules ("Zsh","FindOthers")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","Subscript")) >> pDefault >>= withAttribute OtherTok))
+
+parseRules ("Zsh","FunctionDef") =
+  (((pRegExpr regex_'5cs'2b'5bA'2dZa'2dz'5f'3a'5d'5bA'2dZa'2dz0'2d9'5f'3a'23'25'40'2d'5d'2a'28'5cs'2a'5c'28'5c'29'29'3f >>= withAttribute FunctionTok) >>~ (popContext))
+   <|>
+   ((popContext) >> currentContext >>= parseRules))
+
+parseRules ("Zsh","VarName") =
+  (((pRegExpr regex_'2d'5bA'2dZa'2dz0'2d9'5d'2b >>= withAttribute NormalTok))
+   <|>
+   ((pRegExpr regex_'2d'2d'5ba'2dz'5d'5bA'2dZa'2dz0'2d9'5f'2d'5d'2a >>= withAttribute NormalTok))
+   <|>
+   ((pRegExpr regex_'5cb'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a >>= withAttribute OtherTok))
+   <|>
+   ((pDetectChar False '[' >>= withAttribute OtherTok) >>~ pushContext ("Zsh","Subscript"))
+   <|>
+   ((pDetectChar False '=' >>= withAttribute OtherTok) >>~ pushContext ("Zsh","Assign"))
+   <|>
+   ((parseRules ("Zsh","FindMost")))
+   <|>
+   ((pRegExpr regex_'5b'5e'5d'7d'29'7c'3b'60'26'3e'3c'5d >>= withAttribute NormalTok))
+   <|>
+   ((popContext) >> currentContext >>= parseRules))
+
+parseRules ("Zsh","ProcessSubst") =
+  (((pDetectChar False ')' >>= withAttribute KeywordTok) >>~ (popContext))
+   <|>
+   ((parseRules ("Zsh","FindCommentsParen")))
+   <|>
+   ((parseRules ("Zsh","FindCommands")))
+   <|>
+   ((parseRules ("Zsh","FindStrings")))
+   <|>
+   ((parseRules ("Zsh","FindSubstitutions")))
+   <|>
+   ((parseRules ("Zsh","FindOthers")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","ProcessSubst")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Zsh","StringSQ") =
+  (((pDetectChar False '\'' >>= withAttribute StringTok) >>~ (popContext))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","StringSQ")) >> pDefault >>= withAttribute StringTok))
+
+parseRules ("Zsh","StringDQ") =
+  (((pDetectChar False '"' >>= withAttribute StringTok) >>~ (popContext))
+   <|>
+   ((pRegExpr regex_'5c'5c'5b'60'22'5c'5c'24'5cn'5d >>= withAttribute DataTypeTok))
+   <|>
+   ((parseRules ("Zsh","FindSubstitutions")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","StringDQ")) >> pDefault >>= withAttribute StringTok))
+
+parseRules ("Zsh","StringEsc") =
+  (((pDetectChar False '\'' >>= withAttribute StringTok) >>~ (popContext))
+   <|>
+   ((pRegExpr regex_'5c'5c'5babefnrtv'5c'5c'27'5d >>= withAttribute DataTypeTok))
+   <|>
+   ((pRegExpr regex_'5c'5c'28'5b0'2d7'5d'7b1'2c3'7d'7cx'5bA'2dFa'2df0'2d9'5d'7b1'2c2'7d'7cc'2e'29 >>= withAttribute DataTypeTok))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","StringEsc")) >> pDefault >>= withAttribute StringTok))
+
+parseRules ("Zsh","VarBrace") =
+  (((pDetectChar False '}' >>= withAttribute OtherTok) >>~ (popContext))
+   <|>
+   ((pDetectChar False '[' >>= withAttribute OtherTok) >>~ pushContext ("Zsh","Subscript"))
+   <|>
+   ((pRegExpr regex_'28'3a'3f'5b'2d'3d'3f'2b'5d'7c'23'23'3f'7c'25'25'3f'29 >>= withAttribute OtherTok) >>~ pushContext ("Zsh","VarAlt"))
+   <|>
+   ((pRegExpr regex_'2f'2f'3f >>= withAttribute OtherTok) >>~ pushContext ("Zsh","VarSubst"))
+   <|>
+   ((pDetectChar False ':' >>= withAttribute OtherTok) >>~ pushContext ("Zsh","VarSub"))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","VarBrace")) >> pDefault >>= withAttribute ErrorTok))
+
+parseRules ("Zsh","VarAlt") =
+  (((pDetectChar False '}' >>= withAttribute OtherTok) >>~ (popContext >> popContext))
+   <|>
+   ((parseRules ("Zsh","FindStrings")))
+   <|>
+   ((parseRules ("Zsh","FindSubstitutions")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","VarAlt")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Zsh","VarSubst") =
+  (((pDetectChar False '}' >>= withAttribute OtherTok) >>~ (popContext >> popContext))
+   <|>
+   ((pDetectChar False '/' >>= withAttribute OtherTok) >>~ pushContext ("Zsh","VarSubst2"))
+   <|>
+   ((parseRules ("Zsh","FindStrings")))
+   <|>
+   ((parseRules ("Zsh","FindSubstitutions")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","VarSubst")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Zsh","VarSubst2") =
+  (((pDetectChar False '}' >>= withAttribute OtherTok) >>~ (popContext >> popContext >> popContext))
+   <|>
+   ((parseRules ("Zsh","FindStrings")))
+   <|>
+   ((parseRules ("Zsh","FindSubstitutions")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","VarSubst2")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Zsh","VarSub") =
+  (((pDetectChar False ':' >>= withAttribute OtherTok) >>~ pushContext ("Zsh","VarSub2"))
+   <|>
+   ((pDetectChar False '}' >>= withAttribute OtherTok) >>~ (popContext >> popContext))
+   <|>
+   ((pRegExpr regex_'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a >>= withAttribute OtherTok))
+   <|>
+   ((pRegExpr regex_'5b0'2d9'5d'2b'28'3f'3d'5b'3a'7d'5d'29 >>= withAttribute OtherTok))
+   <|>
+   ((parseRules ("Zsh","FindSubstitutions")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","VarSub")) >> pDefault >>= withAttribute ErrorTok))
+
+parseRules ("Zsh","VarSub2") =
+  (((pDetectChar False '}' >>= withAttribute OtherTok) >>~ (popContext >> popContext >> popContext))
+   <|>
+   ((pRegExpr regex_'5bA'2dZa'2dz'5f'5d'5bA'2dZa'2dz0'2d9'5f'5d'2a >>= withAttribute OtherTok))
+   <|>
+   ((pRegExpr regex_'5b0'2d9'5d'28'3f'3d'5b'3a'7d'5d'29 >>= withAttribute OtherTok))
+   <|>
+   ((parseRules ("Zsh","FindSubstitutions")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","VarSub2")) >> pDefault >>= withAttribute ErrorTok))
+
+parseRules ("Zsh","SubstFile") =
+  (((pDetectChar False ')' >>= withAttribute KeywordTok) >>~ (popContext))
+   <|>
+   ((parseRules ("Zsh","FindCommentsParen")))
+   <|>
+   ((parseRules ("Zsh","FindStrings")))
+   <|>
+   ((parseRules ("Zsh","FindSubstitutions")))
+   <|>
+   ((parseRules ("Zsh","FindOthers")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","SubstFile")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Zsh","SubstCommand") =
+  (((pDetectChar False ')' >>= withAttribute OtherTok) >>~ (popContext))
+   <|>
+   ((parseRules ("Zsh","FindCommentsParen")))
+   <|>
+   ((parseRules ("Zsh","FindCommands")))
+   <|>
+   ((parseRules ("Zsh","FindStrings")))
+   <|>
+   ((parseRules ("Zsh","FindSubstitutions")))
+   <|>
+   ((parseRules ("Zsh","FindOthers")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","SubstCommand")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Zsh","SubstBackq") =
+  (((pDetectChar False '`' >>= withAttribute KeywordTok) >>~ (popContext))
+   <|>
+   ((parseRules ("Zsh","FindCommentsBackq")))
+   <|>
+   ((parseRules ("Zsh","FindCommands")))
+   <|>
+   ((parseRules ("Zsh","FindStrings")))
+   <|>
+   ((parseRules ("Zsh","FindSubstitutions")))
+   <|>
+   ((parseRules ("Zsh","FindOthers")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","SubstBackq")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Zsh","Case") =
+  (((pRegExpr regex_'5csin'5cb >>= withAttribute KeywordTok) >>~ pushContext ("Zsh","CaseIn"))
+   <|>
+   ((parseRules ("Zsh","FindMost")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","Case")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Zsh","CaseIn") =
+  (((pRegExpr regex_'5cbesac'28'3f'3d'24'7c'5b'5cs'3b'29'5d'29 >>= withAttribute KeywordTok) >>~ (popContext >> popContext))
+   <|>
+   ((pDetectChar False ')' >>= withAttribute KeywordTok) >>~ pushContext ("Zsh","CaseExpr"))
+   <|>
+   ((pAnyChar "(|" >>= withAttribute KeywordTok))
+   <|>
+   ((parseRules ("Zsh","FindMost")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","CaseIn")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Zsh","CaseExpr") =
+  (((pDetect2Chars False ';' ';' >>= withAttribute KeywordTok) >>~ (popContext))
+   <|>
+   ((pFirstNonSpace >> lookAhead (pRegExpr regex_esac'28'3f'3d'24'7c'5b'5cs'3b'29'5d'29) >> (popContext) >> currentContext >>= parseRules))
+   <|>
+   ((parseRules ("Zsh","FindAll")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","CaseExpr")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Zsh","HereDoc") =
+  (((lookAhead (pRegExpr regex_'28'3c'3c'2d'5cs'2a'22'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'22'29) >> pushContext ("Zsh","HereDocIQ") >> currentContext >>= parseRules))
+   <|>
+   ((lookAhead (pRegExpr regex_'28'3c'3c'2d'5cs'2a'27'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'27'29) >> pushContext ("Zsh","HereDocIQ") >> currentContext >>= parseRules))
+   <|>
+   ((lookAhead (pRegExpr regex_'28'3c'3c'2d'5cs'2a'5c'5c'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'29) >> pushContext ("Zsh","HereDocIQ") >> currentContext >>= parseRules))
+   <|>
+   ((lookAhead (pRegExpr regex_'28'3c'3c'2d'5cs'2a'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'29) >> pushContext ("Zsh","HereDocINQ") >> currentContext >>= parseRules))
+   <|>
+   ((lookAhead (pRegExpr regex_'28'3c'3c'5cs'2a'22'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'22'29) >> pushContext ("Zsh","HereDocQ") >> currentContext >>= parseRules))
+   <|>
+   ((lookAhead (pRegExpr regex_'28'3c'3c'5cs'2a'27'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'27'29) >> pushContext ("Zsh","HereDocQ") >> currentContext >>= parseRules))
+   <|>
+   ((lookAhead (pRegExpr regex_'28'3c'3c'5cs'2a'5c'5c'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'29) >> pushContext ("Zsh","HereDocQ") >> currentContext >>= parseRules))
+   <|>
+   ((lookAhead (pRegExpr regex_'28'3c'3c'5cs'2a'28'5b'5e'7c'26'3b'28'29'3c'3e'5cs'5d'2b'29'29) >> pushContext ("Zsh","HereDocNQ") >> currentContext >>= parseRules))
+   <|>
+   ((pString False "<<" >>= withAttribute KeywordTok) >>~ (popContext))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","HereDoc")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Zsh","HereDocRemainder") =
+  (((parseRules ("Zsh","FindAll")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","HereDocRemainder")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Zsh","HereDocQ") =
+  (((pRegExprDynamic "%1" >>= withAttribute KeywordTok) >>~ pushContext ("Zsh","HereDocRemainder"))
+   <|>
+   ((pColumn 0 >> pRegExprDynamic "%2\\b" >>= withAttribute KeywordTok) >>~ (popContext >> popContext))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","HereDocQ")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Zsh","HereDocNQ") =
+  (((pRegExprDynamic "%1" >>= withAttribute KeywordTok) >>~ pushContext ("Zsh","HereDocRemainder"))
+   <|>
+   ((pColumn 0 >> pRegExprDynamic "%2\\b" >>= withAttribute KeywordTok) >>~ (popContext >> popContext))
+   <|>
+   ((parseRules ("Zsh","FindSubstitutions")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","HereDocNQ")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Zsh","HereDocIQ") =
+  (((pRegExprDynamic "%1" >>= withAttribute KeywordTok) >>~ pushContext ("Zsh","HereDocRemainder"))
+   <|>
+   ((pColumn 0 >> pRegExprDynamic "\\t*%2\\b" >>= withAttribute KeywordTok) >>~ (popContext >> popContext))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","HereDocIQ")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Zsh","HereDocINQ") =
+  (((pRegExprDynamic "%1" >>= withAttribute KeywordTok) >>~ pushContext ("Zsh","HereDocRemainder"))
+   <|>
+   ((pColumn 0 >> pRegExprDynamic "\\t*%2\\b" >>= withAttribute KeywordTok) >>~ (popContext >> popContext))
+   <|>
+   ((parseRules ("Zsh","FindSubstitutions")))
+   <|>
+   (currentContext >>= \x -> guard (x == ("Zsh","HereDocINQ")) >> pDefault >>= withAttribute NormalTok))
+
+parseRules ("Alerts", _) = Text.Highlighting.Kate.Syntax.Alert.parseExpression Nothing
+
+parseRules x = parseRules ("Zsh","Start") <|> fail ("Unknown context" ++ show x)
diff --git a/changelog b/changelog
--- a/changelog
+++ b/changelog
@@ -1,3 +1,27 @@
+highlighting-kate 0.5.9 (24 Aug 2014)
+
+  * Added cabal test suite.
+  * Update .cabal file and README.md to reflect new upstream repo
+    (Geoff Nixon).
+  * Added new syntaxes: ABC, Lilypond (musical typesetting),
+    FASM/[NASM/MASM/YASM] (Intel Style Assembly Language), GraphViz Dot (graph
+    notation), GLSL (graphics language), M4 (macro language, used by GNU
+    autotools), Mathematica, MediaWiki (wiki markup), OpenCL (GPGPU language),
+    RELAX NG (XML schema) [as the alternate RELAX NG compact syntax is already
+    included], tcsh [C shell] (scripting/shell language [with small patch for
+    parsing error]).  (Geoff Nixon)
+  * Add language.xsd and validatehl.sh script from upstream: useful (Geoff
+    Nixon).
+  * Replace restructuredtext.xml with updated (renamed) rest.xml (Geoff
+    Nixon).
+  * Update from upstream: alert_indent, awk, css, diff, doxygen, email,
+    fsharp, haskell, javadoc, literate-haskell, markdown, maxima, perl,
+    prolog, python, vhdl, yacc. (Geoff Nixon)
+  * Added .patch files in xml directory where local changes have been
+    made (Geoff Nixon).
+  * Common:  Convert `\o{...}` to `\x{..}` in regexes.
+    `\x{..}` has been supported for a long time in pcre.
+
 highlighting-kate 0.5.8.5 (15 Jul 2014)
 
   * Use utf8 option with pcre-light.
diff --git a/css/hk-tango.css b/css/hk-tango.css
new file mode 100644
--- /dev/null
+++ b/css/hk-tango.css
@@ -0,0 +1,21 @@
+/* Loosely based on pygment's tango colors */
+table.sourceCode, tr.sourceCode, td.sourceCode, table.sourceCode pre
+   { margin: 0; padding: 0; border: 0; vertical-align: baseline; border: none; background-color: #f8f8f8 }
+td.nums { text-align: right; padding-right: 5px; padding-left: 5px; background-color: #f0f0f0; }
+td.sourceCode { padding-left: 5px; }
+code.sourceCode { background-color: #f8f8f8; }
+pre.sourceCode { background-color: #f8f8f8; line-height: 125% }
+td.nums pre { background-color: #f0f0f0; line-height: 125% }
+code.sourceCode span.kw { color: #204a87; font-weight: bold } /* Keyword */
+code.sourceCode span.dt { color: #204a87 } /* Keyword.Type */
+code.sourceCode span.dv { color: #0000cf } /* Literal.Number.Integer */
+code.sourceCode span.bn { color: #0000cf } /* Literal.Number.Hex */
+code.sourceCode span.fl { color: #0000cf } /* Literal.Number.Float */
+code.sourceCode span.ch { color: #4e9a06 } /* Literal.String.Char */
+code.sourceCode span.st { color: #4e9a06 } /* Literal.String */
+code.sourceCode span.co { color: #8f5902; font-style: italic } /* Comment */
+code.sourceCode span.ot { color: #8f5902 } /* Comment.Preproc */
+code.sourceCode span.al { color: #ef2929 } /* Generic.Error */
+code.sourceCode span.fu { color: #000000 } /* Name.Function */
+code.sourceCode span.re { }
+code.sourceCode span.er { color: #a40000; border: 1px solid #ef2929 } /* Error */
diff --git a/highlighting-kate.cabal b/highlighting-kate.cabal
--- a/highlighting-kate.cabal
+++ b/highlighting-kate.cabal
@@ -1,5 +1,5 @@
 Name:                highlighting-kate
-Version:             0.5.8.5
+Version:             0.5.9
 Cabal-Version:       >= 1.10
 Build-Type:          Simple
 Category:            Text
@@ -20,116 +20,67 @@
 Homepage:            http://github.com/jgm/highlighting-kate
 Extra-Source-Files:  README.md
                      changelog
+                     Makefile
                      ParseSyntaxFiles.hs
                      Text/Highlighting/Kate/Syntax.hs.in
                      css/hk-espresso.css
                      css/hk-kate.css
                      css/hk-pyg.css
-                     xml/actionscript.xml
-                     xml/ada.xml
-                     xml/alert.xml
-                     xml/alert_indent.xml
-                     xml/apache.xml
-                     xml/asn1.xml
-                     xml/asp.xml
-                     xml/awk.xml
-                     xml/bash.xml
-                     xml/bash.xml.bkp
-                     xml/bibtex.xml
-                     xml/boo.xml
-                     xml/c.xml
-                     xml/changelog.xml
-                     xml/clojure.xml
-                     xml/cmake.xml
-                     xml/coffee.xml
-                     xml/coldfusion.xml
-                     xml/commonlisp.xml
-                     xml/cpp.xml
-                     xml/cs.xml
-                     xml/css.xml
-                     xml/curry.xml
-                     xml/d.xml
-                     xml/diff.xml
-                     xml/djangotemplate.xml
-                     xml/doxygen.xml
-                     xml/doxygenlua.xml
-                     xml/dtd.xml
-                     xml/eiffel.xml
-                     xml/email.xml
-                     xml/erlang.xml
-                     xml/fortran.xml
-                     xml/fsharp.xml
-                     xml/gcc.xml
-                     xml/gnuassembler.xml
-                     xml/go.xml
-                     xml/haskell.xml
-                     xml/haxe.xml
-                     xml/html.xml
-                     xml/ini.xml
-                     xml/isocpp.xml
-                     xml/java.xml
-                     xml/javadoc.xml
-                     xml/javascript.xml
-                     xml/javascript.xml.bkp
-                     xml/json.xml
-                     xml/jsp.xml
-                     xml/julia.xml
-                     xml/language.dtd
-                     xml/latex.xml
-                     xml/lex.xml
-                     xml/literate-curry.xml
-                     xml/literate-haskell.xml
-                     xml/lua.xml
-                     xml/makefile.xml
-                     xml/mandoc.xml
-                     xml/markdown.xml
-                     xml/matlab.xml
-                     xml/maxima.xml
-                     xml/metafont.xml
-                     xml/mips.xml
-                     xml/modelines.xml
-                     xml/modula-2.xml
-                     xml/modula-3.xml
-                     xml/monobasic.xml
-                     xml/nasm.xml
-                     xml/noweb.xml
-                     xml/objectivec.xml
-                     xml/objectivecpp.xml
-                     xml/ocaml.xml
-                     xml/octave.xml
-                     xml/pascal.xml
-                     xml/perl.xml
-                     xml/perl.xml.bkp
-                     xml/php.xml
-                     xml/pike.xml
-                     xml/postscript.xml
-                     xml/prolog.xml
-                     xml/python.xml
-                     xml/r.xml
-                     xml/relaxngcompact.xml
-                     xml/restructuredtext.xml
-                     xml/rhtml.xml
-                     xml/roff.xml
-                     xml/ruby.xml
-                     xml/rust.xml
-                     xml/scala.xml
-                     xml/scheme.xml
-                     xml/sci.xml
-                     xml/sed.xml
-                     xml/sgml.xml
-                     xml/sql-mysql.xml
-                     xml/sql-postgresql.xml
-                     xml/sql.xml
-                     xml/tcl.xml
-                     xml/texinfo.xml
-                     xml/verilog.xml
-                     xml/vhdl.xml
-                     xml/xml.xml
-                     xml/xorg.xml
-                     xml/xslt.xml
-                     xml/xul.xml
-                     xml/yacc.xml
-                     xml/yaml.xml
+                     css/hk-tango.css
+                     xml/*.xml
+                     xml/*.xml.patch
+                     tests/abc.ada
+                     tests/abc.ada.html
+                     tests/abc.c
+                     tests/abc.c.html
+                     tests/abc.clojure
+                     tests/abc.clojure.html
+                     tests/abc.cpp
+                     tests/abc.cpp.html
+                     tests/abc.cs
+                     tests/abc.cs.html
+                     tests/abc.d
+                     tests/abc.d.html
+                     tests/abc.fortran
+                     tests/abc.fortran.html
+                     tests/abc.go
+                     tests/abc.go.html
+                     tests/abc.haskell
+                     tests/abc.haskell.html
+                     tests/abc.java
+                     tests/abc.java.html
+                     tests/abc.javascript
+                     tests/abc.javascript.html
+                     tests/abc.julia
+                     tests/abc.julia.html
+                     tests/abc.lisp
+                     tests/abc.lisp.html
+                     tests/abc.matlab
+                     tests/abc.matlab.html
+                     tests/abc.ocaml
+                     tests/abc.ocaml.html
+                     tests/abc.perl
+                     tests/abc.perl.html
+                     tests/abc.php
+                     tests/abc.php.html
+                     tests/abc.prolog
+                     tests/abc.prolog.html
+                     tests/abc.python
+                     tests/abc.python.html
+                     tests/abc.r
+                     tests/abc.r.html
+                     tests/abc.ruby
+                     tests/abc.ruby.html
+                     tests/abc.scala
+                     tests/abc.scala.html
+                     tests/abc.scheme
+                     tests/abc.scheme.html
+                     tests/abc.tcl
+                     tests/abc.tcl.html
+                     tests/archive.rhtml
+                     tests/archive.rhtml.html
+                     tests/life.lua
+                     tests/life.lua.html
 Flag splitBase
   Description:       Choose the new, smaller, split-up base package.
   Default:           True
@@ -163,6 +114,7 @@
                      Text.Highlighting.Kate.Format.LaTeX
   Other-Modules:     Text.Highlighting.Kate.Common
                      Paths_highlighting_kate
+                     Text.Highlighting.Kate.Syntax.Abc
                      Text.Highlighting.Kate.Syntax.Actionscript
                      Text.Highlighting.Kate.Syntax.Ada
                      Text.Highlighting.Kate.Syntax.Alert
@@ -188,15 +140,18 @@
                      Text.Highlighting.Kate.Syntax.D
                      Text.Highlighting.Kate.Syntax.Diff
                      Text.Highlighting.Kate.Syntax.Djangotemplate
+                     Text.Highlighting.Kate.Syntax.Dot
                      Text.Highlighting.Kate.Syntax.Doxygen
                      Text.Highlighting.Kate.Syntax.Doxygenlua
                      Text.Highlighting.Kate.Syntax.Dtd
                      Text.Highlighting.Kate.Syntax.Eiffel
                      Text.Highlighting.Kate.Syntax.Email
                      Text.Highlighting.Kate.Syntax.Erlang
+                     Text.Highlighting.Kate.Syntax.Fasm
                      Text.Highlighting.Kate.Syntax.Fortran
                      Text.Highlighting.Kate.Syntax.Fsharp
                      Text.Highlighting.Kate.Syntax.Gcc
+                     Text.Highlighting.Kate.Syntax.Glsl
                      Text.Highlighting.Kate.Syntax.Gnuassembler
                      Text.Highlighting.Kate.Syntax.Go
                      Text.Highlighting.Kate.Syntax.Haskell
@@ -212,14 +167,18 @@
                      Text.Highlighting.Kate.Syntax.Julia
                      Text.Highlighting.Kate.Syntax.Latex
                      Text.Highlighting.Kate.Syntax.Lex
+                     Text.Highlighting.Kate.Syntax.Lilypond
                      Text.Highlighting.Kate.Syntax.LiterateCurry
                      Text.Highlighting.Kate.Syntax.LiterateHaskell
                      Text.Highlighting.Kate.Syntax.Lua
+                     Text.Highlighting.Kate.Syntax.M4
                      Text.Highlighting.Kate.Syntax.Makefile
                      Text.Highlighting.Kate.Syntax.Mandoc
                      Text.Highlighting.Kate.Syntax.Markdown
+                     Text.Highlighting.Kate.Syntax.Mathematica
                      Text.Highlighting.Kate.Syntax.Matlab
                      Text.Highlighting.Kate.Syntax.Maxima
+                     Text.Highlighting.Kate.Syntax.Mediawiki
                      Text.Highlighting.Kate.Syntax.Metafont
                      Text.Highlighting.Kate.Syntax.Mips
                      Text.Highlighting.Kate.Syntax.Modelines
@@ -232,6 +191,7 @@
                      Text.Highlighting.Kate.Syntax.Objectivecpp
                      Text.Highlighting.Kate.Syntax.Ocaml
                      Text.Highlighting.Kate.Syntax.Octave
+                     Text.Highlighting.Kate.Syntax.Opencl
                      Text.Highlighting.Kate.Syntax.Pascal
                      Text.Highlighting.Kate.Syntax.Perl
                      Text.Highlighting.Kate.Syntax.Php
@@ -241,8 +201,9 @@
                      Text.Highlighting.Kate.Syntax.Pure
                      Text.Highlighting.Kate.Syntax.Python
                      Text.Highlighting.Kate.Syntax.R
+                     Text.Highlighting.Kate.Syntax.Relaxng
                      Text.Highlighting.Kate.Syntax.Relaxngcompact
-                     Text.Highlighting.Kate.Syntax.Restructuredtext
+                     Text.Highlighting.Kate.Syntax.Rest
                      Text.Highlighting.Kate.Syntax.Rhtml
                      Text.Highlighting.Kate.Syntax.Roff
                      Text.Highlighting.Kate.Syntax.Ruby
@@ -256,6 +217,7 @@
                      Text.Highlighting.Kate.Syntax.SqlMysql
                      Text.Highlighting.Kate.Syntax.SqlPostgresql
                      Text.Highlighting.Kate.Syntax.Tcl
+                     Text.Highlighting.Kate.Syntax.Tcsh
                      Text.Highlighting.Kate.Syntax.Texinfo
                      Text.Highlighting.Kate.Syntax.Verilog
                      Text.Highlighting.Kate.Syntax.Vhdl
@@ -265,6 +227,7 @@
                      Text.Highlighting.Kate.Syntax.Xul
                      Text.Highlighting.Kate.Syntax.Yacc
                      Text.Highlighting.Kate.Syntax.Yaml
+                     Text.Highlighting.Kate.Syntax.Zsh
   -- disable optimizations; it doesn't hurt performance much and
   -- massively improves compilation speed and memory usage
   Default-Language:    Haskell98
@@ -292,3 +255,11 @@
     Buildable:      True
   else
     Buildable:      False
+
+test-suite test-highlighting-kate
+  Type:           exitcode-stdio-1.0
+  Main-Is:        test-highlighting-kate.hs
+  Hs-Source-Dirs: tests
+  build-depends:  base >= 4, directory, highlighting-kate, filepath,
+                  process, Diff, containers, blaze-html >= 0.4.2 && < 0.8
+  default-language: Haskell98
diff --git a/tests/abc.ada b/tests/abc.ada
new file mode 100644
--- /dev/null
+++ b/tests/abc.ada
@@ -0,0 +1,79 @@
+with Ada.Characters.Handling;
+use Ada.Characters.Handling;
+
+
+package Abc is
+    type Block_Faces is array(1..2) of Character;
+    type Block_List is array(positive range <>) of Block_Faces;
+    function Can_Make_Word(W: String; Blocks: Block_List) return Boolean;
+end Abc;
+
+
+package body Abc is
+
+function Can_Make_Word(W: String; Blocks: Block_List) return Boolean is
+    Used : array(Blocks'Range) of Boolean := (Others => False);
+    subtype wIndex is Integer range W'First..W'Last;
+    wPos : wIndex;
+begin
+    if W'Length = 0 then
+        return True;
+    end if;
+    wPos := W'First;
+    while True loop
+        declare
+            C : Character := To_Upper(W(wPos));
+            X : constant wIndex := wPos;
+        begin
+            for I in Blocks'Range loop
+                if (not Used(I)) then
+                    if C = To_Upper(Blocks(I)(1)) or C = To_Upper(Blocks(I)(2)) then
+                        Used(I) := True;
+                        if wPos = W'Last then
+                            return True;
+                        end if;
+                        wPos := wIndex'Succ(wPos);
+                        exit;
+                    end if;
+                end if;
+            end loop;
+            if X = wPos then
+                return False;
+            end if;
+        end;
+    end loop;
+    return False;
+end Can_Make_Word;
+
+end Abc;
+
+with Ada.Text_IO, Ada.Strings.Unbounded, Abc;
+use Ada.Text_IO, Ada.Strings.Unbounded, Abc;
+
+procedure Abc_Problem is
+    Blocks : Block_List := (
+          ('B','O'), ('X','K'), ('D','Q'), ('C','P')
+        , ('N','A'), ('G','T'), ('R','E'), ('T','G')
+        , ('Q','D'), ('F','S'), ('J','W'), ('H','U')
+        , ('V','I'), ('A','N'), ('O','B'), ('E','R')
+        , ('F','S'), ('L','Y'), ('P','C'), ('Z','M')
+    );
+    function "+" (S : String) return Unbounded_String renames To_Unbounded_String;
+    words : array(positive range <>) of Unbounded_String := (
+          +"A"
+        , +"BARK"
+        , +"BOOK"
+        , +"TREAT"
+        , +"COMMON"
+        , +"SQUAD"
+        , +"CONFUSE"
+        -- Border cases:
+        -- , +"CONFUSE2"
+        -- , +""
+    );
+begin
+    for I in words'Range loop
+        Put_Line ( To_String(words(I)) & ": " & Boolean'Image(Can_Make_Word(To_String(words(I)),Blocks)) );
+    end loop;
+end Abc_Problem;
+
diff --git a/tests/abc.ada.html b/tests/abc.ada.html
new file mode 100644
--- /dev/null
+++ b/tests/abc.ada.html
@@ -0,0 +1,96 @@
+
with Ada.Characters.Handling;
+use Ada.Characters.Handling;
+
+
+package Abc is
+    type Block_Faces is array(1..2) of Character;
+    type Block_List is array(positive range <>) of Block_Faces;
+    function Can_Make_Word(W: String; Blocks: Block_List) return Boolean;
+end Abc;
+
+
+package body Abc is
+
+function Can_Make_Word(W: String; Blocks: Block_List) return Boolean is
+    Used : array(Blocks'Range) of Boolean := (Others => False);
+    subtype wIndex is Integer range W'First..W'Last;
+    wPos : wIndex;
+begin
+    if W'Length = 0 then
+        return True;
+    end if;
+    wPos := W'First;
+    while True loop
+        declare
+            C : Character := To_Upper(W(wPos));
+            X : constant wIndex := wPos;
+        begin
+            for I in Blocks'Range loop
+                if (not Used(I)) then
+                    if C = To_Upper(Blocks(I)(1)) or C = To_Upper(Blocks(I)(2)) then
+                        Used(I) := True;
+                        if wPos = W'Last then
+                            return True;
+                        end if;
+                        wPos := wIndex'Succ(wPos);
+                        exit;
+                    end if;
+                end if;
+            end loop;
+            if X = wPos then
+                return False;
+            end if;
+        end;
+    end loop;
+    return False;
+end Can_Make_Word;
+
+end Abc;
+
+with Ada.Text_IO, Ada.Strings.Unbounded, Abc;
+use Ada.Text_IO, Ada.Strings.Unbounded, Abc;
+
+procedure Abc_Problem is
+    Blocks : Block_List := (
+          ('B','O'), ('X','K'), ('D','Q'), ('C','P')
+        , ('N','A'), ('G','T'), ('R','E'), ('T','G')
+        , ('Q','D'), ('F','S'), ('J','W'), ('H','U')
+        , ('V','I'), ('A','N'), ('O','B'), ('E','R')
+        , ('F','S'), ('L','Y'), ('P','C'), ('Z','M')
+    );
+    function "+" (S : String) return Unbounded_String renames To_Unbounded_String;
+    words : array(positive range <>) of Unbounded_String := (
+          +"A"
+        , +"BARK"
+        , +"BOOK"
+        , +"TREAT"
+        , +"COMMON"
+        , +"SQUAD"
+        , +"CONFUSE"
+        -- Border cases:
+        -- , +"CONFUSE2"
+        -- , +""
+    );
+begin
+    for I in words'Range loop
+        Put_Line ( To_String(words(I)) & ": " & Boolean'Image(Can_Make_Word(To_String(words(I)),Blocks)) );
+    end loop;
+end Abc_Problem;
+

diff --git a/tests/abc.c b/tests/abc.c
new file mode 100644
--- /dev/null
+++ b/tests/abc.c
@@ -0,0 +1,41 @@
+#include 
+#include 
+
+int can_make_words(char **b, char *word)
+{
+        int i, ret = 0, c = toupper(*word);
+
+#define SWAP(a, b) if (a != b) { char * tmp = a; a = b; b = tmp; }
+
+        if (!c) return 1;
+        if (!b[0]) return 0;
+
+        for (i = 0; b[i] && !ret; i++) {
+                if (b[i][0] != c && b[i][1] != c) continue;
+                SWAP(b[i], b[0]);
+                ret = can_make_words(b + 1, word + 1);
+                SWAP(b[i], b[0]);
+        }
+
+        return ret;
+}
+
+int main(void)
+{
+        char* blocks[] = {
+                "BO", "XK", "DQ", "CP", "NA", 
+                "GT", "RE", "TG", "QD", "FS", 
+                "JW", "HU", "VI", "AN", "OB", 
+                "ER", "FS", "LY", "PC", "ZM",
+                0 };
+
+        char *words[] = {
+                "", "A", "BARK", "BOOK", "TREAT", "COMMON", "SQUAD", "Confuse", 0
+        };
+
+        char **w;
+        for (w = words; *w; w++)
+                printf("%s\t%d\n", *w, can_make_words(blocks, *w));
+
+        return 0;
+}
diff --git a/tests/abc.c.html b/tests/abc.c.html
new file mode 100644
--- /dev/null
+++ b/tests/abc.c.html
@@ -0,0 +1,58 @@
+
#include <stdio.h>
+#include <ctype.h>
+
+int can_make_words(char **b, char *word)
+{
+        int i, ret = 0, c = toupper(*word);
+
+#define SWAP(a, b) if (a != b) { char * tmp = a; a = b; b = tmp; }
+
+        if (!c) return 1;
+        if (!b[0]) return 0;
+
+        for (i = 0; b[i] && !ret; i++) {
+                if (b[i][0] != c && b[i][1] != c) continue;
+                SWAP(b[i], b[0]);
+                ret = can_make_words(b + 1, word + 1);
+                SWAP(b[i], b[0]);
+        }
+
+        return ret;
+}
+
+int main(void)
+{
+        char* blocks[] = {
+                "BO", "XK", "DQ", "CP", "NA", 
+                "GT", "RE", "TG", "QD", "FS", 
+                "JW", "HU", "VI", "AN", "OB", 
+                "ER", "FS", "LY", "PC", "ZM",
+                0 };
+
+        char *words[] = {
+                "", "A", "BARK", "BOOK", "TREAT", "COMMON", "SQUAD", "Confuse", 0
+        };
+
+        char **w;
+        for (w = words; *w; w++)
+                printf("%s\t%d\n", *w, can_make_words(blocks, *w));
+
+        return 0;
+}

diff --git a/tests/abc.clojure b/tests/abc.clojure
new file mode 100644
--- /dev/null
+++ b/tests/abc.clojure
@@ -0,0 +1,22 @@
+
+(def blocks
+  (-> "BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM" (.split " ") vec))
+
+(defn omit 
+  "return bs with (one instance of) b omitted"
+  [bs b] 
+  (let [[before after] (split-with #(not= b %) bs)]
+    (concat before (rest after))))
+
+(defn abc 
+  "return lazy sequence of solutions (i.e. block lists)"
+  [blocks [c & cs]]
+  (if-some c
+    (for [b blocks :when (some #(= c %) b)
+          bs (abc (omit blocks b) cs)]
+      (cons b bs))
+    [[]]))
+    
+      
+(doseq [word ["A" "BARK" "Book" "treat" "COMMON" "SQUAD" "CONFUSE"]]
+  (->> word .toUpperCase (abc blocks) first (printf "%s: %b\n" word)))
diff --git a/tests/abc.clojure.html b/tests/abc.clojure.html
new file mode 100644
--- /dev/null
+++ b/tests/abc.clojure.html
@@ -0,0 +1,39 @@
+

+(def blocks
+  (-> "BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM" (.split " ") vec))
+
+(defn omit 
+  "return bs with (one instance of) b omitted"
+  [bs b] 
+  (let [[before after] (split-with #(not= b %) bs)]
+    (concat before (rest after))))
+
+(defn abc 
+  "return lazy sequence of solutions (i.e. block lists)"
+  [blocks [c & cs]]
+  (if-some c
+    (for [b blocks :when (some #(= c %) b)
+          bs (abc (omit blocks b) cs)]
+      (cons b bs))
+    [[]]))
+    
+      
+(doseq [word ["A" "BARK" "Book" "treat" "COMMON" "SQUAD" "CONFUSE"]]
+  (->> word .toUpperCase (abc blocks) first (printf "%s: %b\n" word)))

diff --git a/tests/abc.cpp b/tests/abc.cpp
new file mode 100644
--- /dev/null
+++ b/tests/abc.cpp
@@ -0,0 +1,37 @@
+#include 
+#include 
+#include 
+#include 
+#include 
+
+
+typedef std::pair item_t;
+typedef std::vector list_t;
+
+bool can_make_word(const std::string& w, const list_t& vals) {
+    std::set used;
+    while (used.size() < w.size()) {
+        const char c = toupper(w[used.size()]);
+        uint32_t x = used.size();
+        for (uint32_t i = 0, ii = vals.size(); i < ii; ++i) {
+            if (used.find(i) == used.end()) {
+                if (toupper(vals[i].first) == c || toupper(vals[i].second) == c) {
+                    used.insert(i);
+                    break;
+                }
+            }
+        }
+        if (x == used.size()) break;
+    }
+    return used.size() == w.size();
+}
+
+
+int main() {
+    list_t vals{ {'B','O'}, {'X','K'}, {'D','Q'}, {'C','P'}, {'N','A'}, {'G','T'}, {'R','E'}, {'T','G'}, {'Q','D'}, {'F','S'}, {'J','W'}, {'H','U'}, {'V','I'}, {'A','N'}, {'O','B'}, {'E','R'}, {'F','S'}, {'L','Y'}, {'P','C'}, {'Z','M'} };
+    std::vector words{"A","BARK","BOOK","TREAT","COMMON","SQUAD","CONFUSE"};
+    for (const std::string& w : words) {
+        std::cout << w << ": " << std::boolalpha << can_make_word(w,vals) << ".\n";
+    }
+
+}
diff --git a/tests/abc.cpp.html b/tests/abc.cpp.html
new file mode 100644
--- /dev/null
+++ b/tests/abc.cpp.html
@@ -0,0 +1,54 @@
+
#include <iostream>
+#include <vector>
+#include <string>
+#include <set>
+#include <cctype>
+
+
+typedef std::pair<char,char> item_t;
+typedef std::vector<item_t> list_t;
+
+bool can_make_word(const std::string& w, const list_t& vals) {
+    std::set<uint32_t> used;
+    while (used.size() < w.size()) {
+        const char c = toupper(w[used.size()]);
+        uint32_t x = used.size();
+        for (uint32_t i = 0, ii = vals.size(); i < ii; ++i) {
+            if (used.find(i) == used.end()) {
+                if (toupper(vals[i].first) == c || toupper(vals[i].second) == c) {
+                    used.insert(i);
+                    break;
+                }
+            }
+        }
+        if (x == used.size()) break;
+    }
+    return used.size() == w.size();
+}
+
+
+int main() {
+    list_t vals{ {'B','O'}, {'X','K'}, {'D','Q'}, {'C','P'}, {'N','A'}, {'G','T'}, {'R','E'}, {'T','G'}, {'Q','D'}, {'F','S'}, {'J','W'}, {'H','U'}, {'V','I'}, {'A','N'}, {'O','B'}, {'E','R'}, {'F','S'}, {'L','Y'}, {'P','C'}, {'Z','M'} };
+    std::vector<std::string> words{"A","BARK","BOOK","TREAT","COMMON","SQUAD","CONFUSE"};
+    for (const std::string& w : words) {
+        std::cout << w << ": " << std::boolalpha << can_make_word(w,vals) << ".\n";
+    }
+
+}

diff --git a/tests/abc.cs b/tests/abc.cs
new file mode 100644
--- /dev/null
+++ b/tests/abc.cs
@@ -0,0 +1,83 @@
+using System.Collections.Generic;
+using System.Linq;
+
+void Main()
+{
+        List blocks =
+        new List() { "bo", "xk", "dq", "cp", "na", "gt", "re", "tg", "qd", "fs",
+                "jw", "hu", "vi", "an", "ob", "er", "fs", "ly", "pc", "zm" };
+        List words = new List() {
+                "A", "BARK", "BOOK", "TREAT", "COMMON", "SQUAD", "CONFUSE"};
+        
+        var solver = new ABC(blocks);
+        
+        foreach( var word in words)
+        {
+                Console.WriteLine("{0} :{1}", word, solver.CanMake(word));
+        }
+}
+
+class ABC
+{
+        readonly Dictionary> _blockDict = new Dictionary>();
+        bool[] _used;
+        int _nextBlock;
+
+        readonly List _blocks;
+
+        private void AddBlockChar(char c)
+        {
+                if (!_blockDict.ContainsKey(c))
+                {
+                        _blockDict[c] = new List();
+                }
+                _blockDict[c].Add(_nextBlock);
+        }
+
+        private void AddBlock(string block)
+        {
+                AddBlockChar(block[0]);
+                AddBlockChar(block[1]);
+                _nextBlock++;
+        }
+
+        public ABC(List blocks)
+        {
+                _blocks = blocks;
+                foreach (var block in blocks)
+                {
+                        AddBlock(block);
+                }
+        }
+
+        public bool CanMake(string word)
+        {
+                word = word.ToLower();
+                if (word.Length > _blockDict.Count)
+                {
+                        return false;
+                }
+                _used = new bool[_blocks.Count];
+                return TryMake(word);
+        }
+
+        public bool TryMake(string word)
+        {
+                if (word == string.Empty)
+                {
+                        return true;
+                }
+                var blocks = _blockDict[word[0]].Where(b => !_used[b]);
+                foreach (var block in blocks)
+                {
+                        _used[block] = true;
+                        if (TryMake(word.Substring(1)))
+                        {
+                                return true;
+                        }
+                        _used[block] = false;
+                }
+                return false;
+        }
+}
+
diff --git a/tests/abc.cs.html b/tests/abc.cs.html
new file mode 100644
--- /dev/null
+++ b/tests/abc.cs.html
@@ -0,0 +1,100 @@
+
using System.Collections.Generic;
+using System.Linq;
+
+void Main()
+{
+        List<string> blocks =
+        new List<string>() { "bo", "xk", "dq", "cp", "na", "gt", "re", "tg", "qd", "fs",
+                "jw", "hu", "vi", "an", "ob", "er", "fs", "ly", "pc", "zm" };
+        List<string> words = new List<string>() {
+                "A", "BARK", "BOOK", "TREAT", "COMMON", "SQUAD", "CONFUSE"};
+        
+        var solver = new ABC(blocks);
+        
+        foreach( var word in words)
+        {
+                Console.WriteLine("{0} :{1}", word, solver.CanMake(word));
+        }
+}
+
+class ABC
+{
+        readonly Dictionary<char, List<int>> _blockDict = new Dictionary<char, List<int>>();
+        bool[] _used;
+        int _nextBlock;
+
+        readonly List<string> _blocks;
+
+        private void AddBlockChar(char c)
+        {
+                if (!_blockDict.ContainsKey(c))
+                {
+                        _blockDict[c] = new List<int>();
+                }
+                _blockDict[c].Add(_nextBlock);
+        }
+
+        private void AddBlock(string block)
+        {
+                AddBlockChar(block[0]);
+                AddBlockChar(block[1]);
+                _nextBlock++;
+        }
+
+        public ABC(List<string> blocks)
+        {
+                _blocks = blocks;
+                foreach (var block in blocks)
+                {
+                        AddBlock(block);
+                }
+        }
+
+        public bool CanMake(string word)
+        {
+                word = word.ToLower();
+                if (word.Length > _blockDict.Count)
+                {
+                        return false;
+                }
+                _used = new bool[_blocks.Count];
+                return TryMake(word);
+        }
+
+        public bool TryMake(string word)
+        {
+                if (word == string.Empty)
+                {
+                        return true;
+                }
+                var blocks = _blockDict[word[0]].Where(b => !_used[b]);
+                foreach (var block in blocks)
+                {
+                        _used[block] = true;
+                        if (TryMake(word.Substring(1)))
+                        {
+                                return true;
+                        }
+                        _used[block] = false;
+                }
+                return false;
+        }
+}
+

diff --git a/tests/abc.d b/tests/abc.d
new file mode 100644
--- /dev/null
+++ b/tests/abc.d
@@ -0,0 +1,42 @@
+import std.stdio, std.ascii, std.algorithm, std.array, std.range;
+
+alias Block = char[2];
+
+bool canMakeWord(immutable Block[] blocks, in string word) pure nothrow
+in {
+    assert(blocks.all!(w => w[].all!isAlpha));
+    assert(word.all!isAlpha);
+} body {
+    bool inner(size_t[] indexes, in string w) pure nothrow {
+        if (w.empty)
+            return true;
+
+        immutable c = w[0].toUpper;
+        foreach (ref idx; indexes) {
+            if (blocks[idx][0].toUpper != c &&
+                blocks[idx][1].toUpper != c)
+                continue;
+            indexes[0].swap(idx);
+            if (inner(indexes[1 .. $], w[1 .. $]))
+                return true;
+            indexes[0].swap(idx);
+        }
+
+        return false;
+    }
+
+    return inner(blocks.length.iota.array, word);
+}
+
+void main() {
+    enum Block[] blocks = "BO XK DQ CP NA GT RE TG QD FS
+                           JW HU VI AN OB ER FS LY PC ZM".split;
+
+    foreach (w; "" ~ "A BARK BoOK TrEAT COmMoN SQUAD conFUsE".split)
+        writefln(`"%s" %s`, w, blocks.canMakeWord(w));
+
+    // Extra test.
+    immutable Block[] blocks2 = ["AB", "AB", "AC", "AC"];
+    immutable word = "abba";
+    writefln(`"%s" %s`, word, blocks2.canMakeWord(word));
+}
diff --git a/tests/abc.d.html b/tests/abc.d.html
new file mode 100644
--- /dev/null
+++ b/tests/abc.d.html
@@ -0,0 +1,59 @@
+
import std.stdio, std.ascii, std.algorithm, std.array, std.range;
+
+alias Block = char[2];
+
+bool canMakeWord(immutable Block[] blocks, in string word) pure nothrow
+in {
+    assert(blocks.all!(w => w[].all!isAlpha));
+    assert(word.all!isAlpha);
+} body {
+    bool inner(size_t[] indexes, in string w) pure nothrow {
+        if (w.empty)
+            return true;
+
+        immutable c = w[0].toUpper;
+        foreach (ref idx; indexes) {
+            if (blocks[idx][0].toUpper != c &&
+                blocks[idx][1].toUpper != c)
+                continue;
+            indexes[0].swap(idx);
+            if (inner(indexes[1 .. $], w[1 .. $]))
+                return true;
+            indexes[0].swap(idx);
+        }
+
+        return false;
+    }
+
+    return inner(blocks.length.iota.array, word);
+}
+
+void main() {
+    enum Block[] blocks = "BO XK DQ CP NA GT RE TG QD FS
+                           JW HU VI AN OB ER FS LY PC ZM".split;
+
+    foreach (w; "" ~ "A BARK BoOK TrEAT COmMoN SQUAD conFUsE".split)
+        writefln(`"%s" %s`, w, blocks.canMakeWord(w));
+
+    // Extra test.
+    immutable Block[] blocks2 = ["AB", "AB", "AC", "AC"];
+    immutable word = "abba";
+    writefln(`"%s" %s`, word, blocks2.canMakeWord(word));
+}

diff --git a/tests/abc.fortran b/tests/abc.fortran
new file mode 100644
--- /dev/null
+++ b/tests/abc.fortran
@@ -0,0 +1,70 @@
+!-*- mode: compilation; default-directory: "/tmp/" -*-
+!Compilation started at Thu Jun  5 01:52:03
+!
+!make f && for a in '' a bark book treat common squad confuse ; do echo $a | ./f ; done
+!gfortran -std=f2008 -Wall -fopenmp -ffree-form -fall-intrinsics -fimplicit-none -g f.f08 -o f
+! T                      
+! T  A                    NA
+! T  BARK                 BO NA RE XK
+! F  BOOK                 OB BO -- --
+! T  TREAT                GT RE ER NA TG
+! F  COMMON               PC OB ZM -- -- --
+! T  SQUAD                FS DQ HU NA QD
+! T  CONFUSE              CP BO NA FS HU FS RE
+!
+!Compilation finished at Thu Jun  5 01:52:03
+
+program abc
+  implicit none
+  integer, parameter :: nblocks = 20
+  character(len=nblocks) :: goal
+  integer, dimension(nblocks) :: solution
+  character(len=2), dimension(0:nblocks) :: blocks_copy, blocks = &
+       &(/'--','BO','XK','DQ','CP','NA','GT','RE','TG','QD','FS','JW','HU','VI','AN','OB','ER','FS','LY','PC','ZM'/)
+  logical :: valid
+  integer :: i, iostat
+  read(5,*,iostat=iostat) goal
+  if (iostat .ne. 0) goal = ''
+  call ucase(goal)
+  solution = 0
+  blocks_copy = blocks
+  valid = assign_block(goal(1:len_trim(goal)), blocks, solution, 1)
+  write(6,*) valid, ' '//goal, (' '//blocks_copy(solution(i)), i=1,len_trim(goal))
+
+contains
+
+  recursive function assign_block(goal, blocks, solution, n) result(valid)
+    implicit none
+    logical :: valid
+    character(len=*), intent(in) :: goal
+    character(len=2), dimension(0:), intent(inout) :: blocks
+    integer, dimension(:), intent(out) :: solution
+    integer, intent(in) :: n
+    integer :: i
+    character(len=2) :: backing_store
+    valid = .true.
+    if (len(goal)+1 .eq. n) return
+    do i=1, size(blocks)
+       if (index(blocks(i),goal(n:n)) .ne. 0) then
+          backing_store = blocks(i)
+          blocks(i) = ''
+          solution(n) = i
+          if (assign_block(goal, blocks, solution, n+1)) return
+          blocks(i) = backing_store
+       end if
+    end do
+    valid = .false.
+    return
+  end function assign_block
+
+  subroutine ucase(a)
+    implicit none
+    character(len=*), intent(inout) :: a
+    integer :: i, j
+    do i = 1, len_trim(a)
+       j = index('abcdefghijklmnopqrstuvwxyz',a(i:i))
+       if (j .ne. 0) a(i:i) = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'(j:j)
+    end do
+  end subroutine ucase
+
+end program abc
diff --git a/tests/abc.fortran.html b/tests/abc.fortran.html
new file mode 100644
--- /dev/null
+++ b/tests/abc.fortran.html
@@ -0,0 +1,87 @@
+
!-*- mode: compilation; default-directory: "/tmp/" -*-
+!Compilation started at Thu Jun  5 01:52:03
+!
+!make f && for a in '' a bark book treat common squad confuse ; do echo $a | ./f ; done
+!gfortran -std=f2008 -Wall -fopenmp -ffree-form -fall-intrinsics -fimplicit-none -g f.f08 -o f
+! T                      
+! T  A                    NA
+! T  BARK                 BO NA RE XK
+! F  BOOK                 OB BO -- --
+! T  TREAT                GT RE ER NA TG
+! F  COMMON               PC OB ZM -- -- --
+! T  SQUAD                FS DQ HU NA QD
+! T  CONFUSE              CP BO NA FS HU FS RE
+!
+!Compilation finished at Thu Jun  5 01:52:03
+
+program abc
+  implicit none
+  integer, parameter :: nblocks = 20
+  character(len=nblocks) :: goal
+  integer, dimension(nblocks) :: solution
+  character(len=2), dimension(0:nblocks) :: blocks_copy, blocks = &
+       &(/'--','BO','XK','DQ','CP','NA','GT','RE','TG','QD','FS','JW','HU','VI','AN','OB','ER','FS','LY','PC','ZM'/)
+  logical :: valid
+  integer :: i, iostat
+  read(5,*,iostat=iostat) goal
+  if (iostat .ne. 0) goal = ''
+  call ucase(goal)
+  solution = 0
+  blocks_copy = blocks
+  valid = assign_block(goal(1:len_trim(goal)), blocks, solution, 1)
+  write(6,*) valid, ' '//goal, (' '//blocks_copy(solution(i)), i=1,len_trim(goal))
+
+contains
+
+  recursive function assign_block(goal, blocks, solution, n) result(valid)
+    implicit none
+    logical :: valid
+    character(len=*), intent(in) :: goal
+    character(len=2), dimension(0:), intent(inout) :: blocks
+    integer, dimension(:), intent(out) :: solution
+    integer, intent(in) :: n
+    integer :: i
+    character(len=2) :: backing_store
+    valid = .true.
+    if (len(goal)+1 .eq. n) return
+    do i=1, size(blocks)
+       if (index(blocks(i),goal(n:n)) .ne. 0) then
+          backing_store = blocks(i)
+          blocks(i) = ''
+          solution(n) = i
+          if (assign_block(goal, blocks, solution, n+1)) return
+          blocks(i) = backing_store
+       end if
+    end do
+    valid = .false.
+    return
+  end function assign_block
+
+  subroutine ucase(a)
+    implicit none
+    character(len=*), intent(inout) :: a
+    integer :: i, j
+    do i = 1, len_trim(a)
+       j = index('abcdefghijklmnopqrstuvwxyz',a(i:i))
+       if (j .ne. 0) a(i:i) = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'(j:j)
+    end do
+  end subroutine ucase
+
+end program abc

diff --git a/tests/abc.go b/tests/abc.go
new file mode 100644
--- /dev/null
+++ b/tests/abc.go
@@ -0,0 +1,39 @@
+package main
+
+import (
+        "fmt"
+        "strings"
+)
+
+func newSpeller(blocks string) func(string) bool {
+        bl := strings.Fields(blocks)
+        return func(word string) bool {
+                return r(word, bl)
+        }
+}
+
+func r(word string, bl []string) bool {
+        if word == "" {
+                return true
+        }
+        c := word[0] | 32
+        for i, b := range bl {
+                if c == b[0]|32 || c == b[1]|32 {
+                        bl[i], bl[0] = bl[0], b
+                        if r(word[1:], bl[1:]) == true {
+                                return true
+                        }
+                        bl[i], bl[0] = bl[0], bl[i]
+                }
+        }
+        return false
+}
+
+func main() {
+        sp := newSpeller(
+                "BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM")
+        for _, word := range []string{
+                "A", "BARK", "BOOK", "TREAT", "COMMON", "SQUAD", "CONFUSE"} {
+                fmt.Println(word, sp(word))
+        }
+}
diff --git a/tests/abc.go.html b/tests/abc.go.html
new file mode 100644
--- /dev/null
+++ b/tests/abc.go.html
@@ -0,0 +1,56 @@
+
package main
+
+import (
+        "fmt"
+        "strings"
+)
+
+func newSpeller(blocks string) func(string) bool {
+        bl := strings.Fields(blocks)
+        return func(word string) bool {
+                return r(word, bl)
+        }
+}
+
+func r(word string, bl []string) bool {
+        if word == "" {
+                return true
+        }
+        c := word[0] | 32
+        for i, b := range bl {
+                if c == b[0]|32 || c == b[1]|32 {
+                        bl[i], bl[0] = bl[0], b
+                        if r(word[1:], bl[1:]) == true {
+                                return true
+                        }
+                        bl[i], bl[0] = bl[0], bl[i]
+                }
+        }
+        return false
+}
+
+func main() {
+        sp := newSpeller(
+                "BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM")
+        for _, word := range []string{
+                "A", "BARK", "BOOK", "TREAT", "COMMON", "SQUAD", "CONFUSE"} {
+                fmt.Println(word, sp(word))
+        }
+}

diff --git a/tests/abc.haskell b/tests/abc.haskell
new file mode 100644
--- /dev/null
+++ b/tests/abc.haskell
@@ -0,0 +1,15 @@
+import Data.List (delete)
+import Data.Char (toUpper)
+
+-- returns list of all solutions, each solution being a list of blocks
+abc :: (Eq a) => [[a]] -> [a] -> [[[a]]]
+abc _ [] = [[]]
+abc blocks (c:cs) = [b:ans | b <- blocks, c `elem` b,
+                             ans <- abc (delete b blocks) cs]
+
+blocks = ["BO", "XK", "DQ", "CP", "NA", "GT", "RE", "TG", "QD", "FS",
+          "JW", "HU", "VI", "AN", "OB", "ER", "FS", "LY", "PC", "ZM"]
+
+main :: IO ()
+main = mapM_ (\w -> print (w, not . null $ abc blocks (map toUpper w)))
+         ["", "A", "BARK", "BoOK", "TrEAT", "COmMoN", "SQUAD", "conFUsE"]
diff --git a/tests/abc.haskell.html b/tests/abc.haskell.html
new file mode 100644
--- /dev/null
+++ b/tests/abc.haskell.html
@@ -0,0 +1,32 @@
+
import Data.List (delete)
+import Data.Char (toUpper)
+
+-- returns list of all solutions, each solution being a list of blocks
+abc :: (Eq a) => [[a]] -> [a] -> [[[a]]]
+abc _ [] = [[]]
+abc blocks (c:cs) = [b:ans | b <- blocks, c `elem` b,
+                             ans <- abc (delete b blocks) cs]
+
+blocks = ["BO", "XK", "DQ", "CP", "NA", "GT", "RE", "TG", "QD", "FS",
+          "JW", "HU", "VI", "AN", "OB", "ER", "FS", "LY", "PC", "ZM"]
+
+main :: IO ()
+main = mapM_ (\w -> print (w, not . null $ abc blocks (map toUpper w)))
+         ["", "A", "BARK", "BoOK", "TrEAT", "COmMoN", "SQUAD", "conFUsE"]

diff --git a/tests/abc.java b/tests/abc.java
new file mode 100644
--- /dev/null
+++ b/tests/abc.java
@@ -0,0 +1,44 @@
+import java.util.Arrays;
+
+public class ABC{
+        private static void swap(int i, int j, Object... arr){
+                Object tmp = arr[i];
+                arr[i] = arr[j];
+                arr[j] = tmp;
+        }
+        
+        public static boolean canMakeWord(String word, String... blocks) {
+            if(word.length() == 0)
+                return true;
+         
+            char c = Character.toUpperCase(word.charAt(0));
+            for(int i = 0; i < blocks.length; i++) {
+                String b = blocks[i];
+                if(Character.toUpperCase(b.charAt(0)) != c && Character.toUpperCase(b.charAt(1)) != c)
+                    continue;
+                swap(0, i, blocks);
+                if(canMakeWord(word.substring(1), Arrays.copyOfRange(blocks, 1, blocks.length)))
+                    return true;
+                swap(0, i, blocks);
+            }
+         
+            return false;
+        }
+        
+        public static void main(String[] args){
+                String[] blocks = {"BO", "XK", "DQ", "CP", "NA", 
+                                "GT", "RE", "TG", "QD", "FS", 
+                                "JW", "HU", "VI", "AN", "OB", 
+                                "ER", "FS", "LY", "PC", "ZM"};
+
+                System.out.println("\"\": " + canMakeWord("", blocks));
+                System.out.println("A: " + canMakeWord("A", blocks));
+                System.out.println("BARK: " + canMakeWord("BARK", blocks));
+                System.out.println("book: " + canMakeWord("book", blocks));
+                System.out.println("treat: " + canMakeWord("treat", blocks));
+                System.out.println("COMMON: " + canMakeWord("COMMON", blocks));
+                System.out.println("SQuAd: " + canMakeWord("SQuAd", blocks));
+                System.out.println("CONFUSE: " + canMakeWord("CONFUSE", blocks));
+                
+        }
+}
diff --git a/tests/abc.java.html b/tests/abc.java.html
new file mode 100644
--- /dev/null
+++ b/tests/abc.java.html
@@ -0,0 +1,61 @@
+
import java.util.Arrays;
+
+public class ABC{
+        private static void swap(int i, int j, Object... arr){
+                Object tmp = arr[i];
+                arr[i] = arr[j];
+                arr[j] = tmp;
+        }
+        
+        public static boolean canMakeWord(String word, String... blocks) {
+            if(word.length() == 0)
+                return true;
+         
+            char c = Character.toUpperCase(word.charAt(0));
+            for(int i = 0; i < blocks.length; i++) {
+                String b = blocks[i];
+                if(Character.toUpperCase(b.charAt(0)) != c && Character.toUpperCase(b.charAt(1)) != c)
+                    continue;
+                swap(0, i, blocks);
+                if(canMakeWord(word.substring(1), Arrays.copyOfRange(blocks, 1, blocks.length)))
+                    return true;
+                swap(0, i, blocks);
+            }
+         
+            return false;
+        }
+        
+        public static void main(String[] args){
+                String[] blocks = {"BO", "XK", "DQ", "CP", "NA", 
+                                "GT", "RE", "TG", "QD", "FS", 
+                                "JW", "HU", "VI", "AN", "OB", 
+                                "ER", "FS", "LY", "PC", "ZM"};
+
+                System.out.println("\"\": " + canMakeWord("", blocks));
+                System.out.println("A: " + canMakeWord("A", blocks));
+                System.out.println("BARK: " + canMakeWord("BARK", blocks));
+                System.out.println("book: " + canMakeWord("book", blocks));
+                System.out.println("treat: " + canMakeWord("treat", blocks));
+                System.out.println("COMMON: " + canMakeWord("COMMON", blocks));
+                System.out.println("SQuAd: " + canMakeWord("SQuAd", blocks));
+                System.out.println("CONFUSE: " + canMakeWord("CONFUSE", blocks));
+                
+        }
+}

diff --git a/tests/abc.javascript b/tests/abc.javascript
new file mode 100644
--- /dev/null
+++ b/tests/abc.javascript
@@ -0,0 +1,33 @@
+let characters = "BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM";
+let blocks = characters.split(" ").map(pair => pair.split(""));
+ 
+function isWordPossible(word) {
+  var letters = [...word.toUpperCase()];
+  var length = letters.length;
+  var copy = new Set(blocks);
+
+  for (let letter of letters) {
+    for (let block of copy) {
+      let index = block.indexOf(letter);
+ 
+      if (index !== -1) {
+        length--;
+        copy.delete(block);
+        break;  
+      }
+    }
+
+  }
+  return !length;
+}    
+ 
+[ 
+  "A", 
+  "BARK", 
+  "BOOK", 
+  "TREAT", 
+  "COMMON", 
+  "SQUAD", 
+  "CONFUSE" 
+].forEach(word => console.log(`${word}: ${isWordPossible(word)}`));
+
diff --git a/tests/abc.javascript.html b/tests/abc.javascript.html
new file mode 100644
--- /dev/null
+++ b/tests/abc.javascript.html
@@ -0,0 +1,50 @@
+
let characters = "BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM";
+let blocks = characters.split(" ").map(pair => pair.split(""));
+ 
+function isWordPossible(word) {
+  var letters = [...word.toUpperCase()];
+  var length = letters.length;
+  var copy = new Set(blocks);
+
+  for (let letter of letters) {
+    for (let block of copy) {
+      let index = block.indexOf(letter);
+ 
+      if (index !== -1) {
+        length--;
+        copy.delete(block);
+        break;  
+      }
+    }
+
+  }
+  return !length;
+}    
+ 
+[ 
+  "A", 
+  "BARK", 
+  "BOOK", 
+  "TREAT", 
+  "COMMON", 
+  "SQUAD", 
+  "CONFUSE" 
+].forEach(word => console.log(`${word}: ${isWordPossible(word)}`));
+

diff --git a/tests/abc.julia b/tests/abc.julia
new file mode 100644
--- /dev/null
+++ b/tests/abc.julia
@@ -0,0 +1,9 @@
+function abc (str, list)
+  isempty(str) && return true
+  for i = 1:length(list)
+    str[end] in list[i] && 
+    any([abc(str[1:end-1], deleteat!(copy(list), i))]) &&
+    return true
+  end
+  false
+end
diff --git a/tests/abc.julia.html b/tests/abc.julia.html
new file mode 100644
--- /dev/null
+++ b/tests/abc.julia.html
@@ -0,0 +1,26 @@
+
function abc (str, list)
+  isempty(str) && return true
+  for i = 1:length(list)
+    str[end] in list[i] && 
+    any([abc(str[1:end-1], deleteat!(copy(list), i))]) &&
+    return true
+  end
+  false
+end

diff --git a/tests/abc.lisp b/tests/abc.lisp
new file mode 100644
--- /dev/null
+++ b/tests/abc.lisp
@@ -0,0 +1,15 @@
+
+(defun word-possible-p (word blocks)
+  (cond 
+    ((= (length word) 0) t)
+    ((null blocks) nil)
+    (t (let* 
+         ((c (aref word 0))
+          (bs (remove-if-not #'(lambda (b) 
+                                 (find c b :test #'char-equal))
+                             blocks)))
+         (some #'identity 
+               (loop for b in bs
+                     collect (word-possible-p
+                               (subseq word 1)
+                               (remove b blocks))))))))
diff --git a/tests/abc.lisp.html b/tests/abc.lisp.html
new file mode 100644
--- /dev/null
+++ b/tests/abc.lisp.html
@@ -0,0 +1,32 @@
+

+(defun word-possible-p (word blocks)
+  (cond 
+    ((= (length word) 0) t)
+    ((null blocks) nil)
+    (t (let* 
+         ((c (aref word 0))
+          (bs (remove-if-not #'(lambda (b) 
+                                 (find c b :test #'char-equal))
+                             blocks)))
+         (some #'identity 
+               (loop for b in bs
+                     collect (word-possible-p
+                               (subseq word 1)
+                               (remove b blocks))))))))

diff --git a/tests/abc.matlab b/tests/abc.matlab
new file mode 100644
--- /dev/null
+++ b/tests/abc.matlab
@@ -0,0 +1,26 @@
+function testABC
+    combos = ['BO' ; 'XK' ; 'DQ' ; 'CP' ; 'NA' ; 'GT' ; 'RE' ; 'TG' ; 'QD' ; ...
+        'FS' ; 'JW' ; 'HU' ; 'VI' ; 'AN' ; 'OB' ; 'ER' ; 'FS' ; 'LY' ; ...
+        'PC' ; 'ZM'];
+    words = {'A' 'BARK' 'BOOK' 'TREAT' 'COMMON' 'SQUAD' 'CONFUSE'};
+    for k = 1:length(words)
+        possible = canMakeWord(words{k}, combos);
+        fprintf('Can%s make word %s.\n', char(~possible.*'NOT'), words{k})
+    end
+end
+
+function isPossible = canMakeWord(word, combos)
+    word = lower(word);
+    combos = lower(combos);
+    isPossible = true;
+    k = 1;
+    while isPossible && k <= length(word)
+        [r, c] = find(combos == word(k), 1);
+        if ~isempty(r)
+            combos(r, :) = '';
+        else
+            isPossible = false;
+        end
+        k = k+1;
+    end
+end
diff --git a/tests/abc.matlab.html b/tests/abc.matlab.html
new file mode 100644
--- /dev/null
+++ b/tests/abc.matlab.html
@@ -0,0 +1,43 @@
+
function testABC
+    combos = ['BO' ; 'XK' ; 'DQ' ; 'CP' ; 'NA' ; 'GT' ; 'RE' ; 'TG' ; 'QD' ; ...
+        'FS' ; 'JW' ; 'HU' ; 'VI' ; 'AN' ; 'OB' ; 'ER' ; 'FS' ; 'LY' ; ...
+        'PC' ; 'ZM'];
+    words = {'A' 'BARK' 'BOOK' 'TREAT' 'COMMON' 'SQUAD' 'CONFUSE'};
+    for k = 1:length(words)
+        possible = canMakeWord(words{k}, combos);
+        fprintf('Can%s make word %s.\n', char(~possible.*'NOT'), words{k})
+    end
+end
+
+function isPossible = canMakeWord(word, combos)
+    word = lower(word);
+    combos = lower(combos);
+    isPossible = true;
+    k = 1;
+    while isPossible && k <= length(word)
+        [r, c] = find(combos == word(k), 1);
+        if ~isempty(r)
+            combos(r, :) = '';
+        else
+            isPossible = false;
+        end
+        k = k+1;
+    end
+end

diff --git a/tests/abc.ocaml b/tests/abc.ocaml
new file mode 100644
--- /dev/null
+++ b/tests/abc.ocaml
@@ -0,0 +1,40 @@
+let blocks = [
+  ('B', 'O');  ('X', 'K');  ('D', 'Q');  ('C', 'P');
+  ('N', 'A');  ('G', 'T');  ('R', 'E');  ('T', 'G');
+  ('Q', 'D');  ('F', 'S');  ('J', 'W');  ('H', 'U');
+  ('V', 'I');  ('A', 'N');  ('O', 'B');  ('E', 'R');
+  ('F', 'S');  ('L', 'Y');  ('P', 'C');  ('Z', 'M');
+]
+
+let find_letter blocks c =
+  let found, remaining =
+    List.partition (fun (c1, c2) -> c1 = c || c2 = c) blocks
+  in
+  match found with
+  | _ :: res -> Some (res @ remaining)
+  | _ -> None
+
+let can_make_word w =
+  let n = String.length w in
+  let rec aux i _blocks =
+    if i >= n then true else
+      match find_letter _blocks w.[i] with
+      | None -> false
+      | Some rem_blocks ->
+          aux (succ i) rem_blocks
+  in
+  aux 0 blocks
+
+let test label f (word, should) =
+  Printf.printf "- %s %S = %B  (should: %B)\n" label word (f word) should
+
+let () =
+  List.iter (test "can make word" can_make_word) [
+    "A", true;
+    "BARK", true;
+    "BOOK", false;
+    "TREAT", true;
+    "COMMON", false;
+    "SQUAD", true;
+    "CONFUSE", true;
+  ]
diff --git a/tests/abc.ocaml.html b/tests/abc.ocaml.html
new file mode 100644
--- /dev/null
+++ b/tests/abc.ocaml.html
@@ -0,0 +1,57 @@
+
let blocks = [
+  ('B', 'O');  ('X', 'K');  ('D', 'Q');  ('C', 'P');
+  ('N', 'A');  ('G', 'T');  ('R', 'E');  ('T', 'G');
+  ('Q', 'D');  ('F', 'S');  ('J', 'W');  ('H', 'U');
+  ('V', 'I');  ('A', 'N');  ('O', 'B');  ('E', 'R');
+  ('F', 'S');  ('L', 'Y');  ('P', 'C');  ('Z', 'M');
+]
+
+let find_letter blocks c =
+  let found, remaining =
+    List.partition (fun (c1, c2) -> c1 = c || c2 = c) blocks
+  in
+  match found with
+  | _ :: res -> Some (res @ remaining)
+  | _ -> None
+
+let can_make_word w =
+  let n = String.length w in
+  let rec aux i _blocks =
+    if i >= n then true else
+      match find_letter _blocks w.[i] with
+      | None -> false
+      | Some rem_blocks ->
+          aux (succ i) rem_blocks
+  in
+  aux 0 blocks
+
+let test label f (word, should) =
+  Printf.printf "- %s %S = %B  (should: %B)\n" label word (f word) should
+
+let () =
+  List.iter (test "can make word" can_make_word) [
+    "A", true;
+    "BARK", true;
+    "BOOK", false;
+    "TREAT", true;
+    "COMMON", false;
+    "SQUAD", true;
+    "CONFUSE", true;
+  ]

diff --git a/tests/abc.perl b/tests/abc.perl
new file mode 100644
--- /dev/null
+++ b/tests/abc.perl
@@ -0,0 +1,14 @@
+use Test::More tests => 8;
+
+my @blocks1 = qw(BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM);
+is(can_make_word("A",       @blocks1), 1);
+is(can_make_word("BARK",    @blocks1), 1);
+is(can_make_word("BOOK",    @blocks1), undef);
+is(can_make_word("TREAT",   @blocks1), 1);
+is(can_make_word("COMMON",  @blocks1), undef);
+is(can_make_word("SQUAD",   @blocks1), 1);
+is(can_make_word("CONFUSE", @blocks1), 1);
+
+my @blocks2 = qw(US TZ AO QA);
+is(can_make_word('auto', @blocks2), 1);
+
diff --git a/tests/abc.perl.html b/tests/abc.perl.html
new file mode 100644
--- /dev/null
+++ b/tests/abc.perl.html
@@ -0,0 +1,31 @@
+
use Test::More tests => 8;
+
+my @blocks1 = qw(BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM);
+is(can_make_word("A",       @blocks1), 1);
+is(can_make_word("BARK",    @blocks1), 1);
+is(can_make_word("BOOK",    @blocks1), undef);
+is(can_make_word("TREAT",   @blocks1), 1);
+is(can_make_word("COMMON",  @blocks1), undef);
+is(can_make_word("SQUAD",   @blocks1), 1);
+is(can_make_word("CONFUSE", @blocks1), 1);
+
+my @blocks2 = qw(US TZ AO QA);
+is(can_make_word('auto', @blocks2), 1);
+

diff --git a/tests/abc.php b/tests/abc.php
new file mode 100644
--- /dev/null
+++ b/tests/abc.php
@@ -0,0 +1,30 @@
+
+ $block) {
+            if (strpos($block, $char) !== FALSE) {
+                unset($blocks[$k]);
+                continue(2);
+            }
+        }
+        return false;
+    }
+    return true;
+}
+
+foreach ($words as $word) {
+    echo $word.': ';
+    echo canMakeWord($word) ? "True" : "False";
+    echo "\r\n";
+}
diff --git a/tests/abc.php.html b/tests/abc.php.html
new file mode 100644
--- /dev/null
+++ b/tests/abc.php.html
@@ -0,0 +1,47 @@
+

+<?php
+$words = array("A", "BARK", "BOOK", "TREAT", "COMMON", "SQUAD", "Confuse");
+
+function canMakeWord($word) {
+    $word = strtoupper($word);
+    $blocks = array(
+            "BO", "XK", "DQ", "CP", "NA",
+            "GT", "RE", "TG", "QD", "FS",
+            "JW", "HU", "VI", "AN", "OB",
+            "ER", "FS", "LY", "PC", "ZM",
+    );
+
+    foreach (str_split($word) as $char) {
+        foreach ($blocks as $k => $block) {
+            if (strpos($block, $char) !== FALSE) {
+                unset($blocks[$k]);
+                continue(2);
+            }
+        }
+        return false;
+    }
+    return true;
+}
+
+foreach ($words as $word) {
+    echo $word.': ';
+    echo canMakeWord($word) ? "True" : "False";
+    echo "\r\n";
+}

diff --git a/tests/abc.prolog b/tests/abc.prolog
new file mode 100644
--- /dev/null
+++ b/tests/abc.prolog
@@ -0,0 +1,23 @@
+abc_problem :-
+        maplist(abc_problem, ['', 'A', bark, bOOk, treAT, 'COmmon', sQuaD, 'CONFUSE']).
+
+
+abc_problem(Word) :-
+        L = [[b,o],[x,k],[d,q],[c,p],[n,a],[g,t],[r,e],[t,g],[q,d],[f,s],
+             [j,w],[h,u],[v,i],[a,n],[o,b],[e,r],[f,s],[l,y],[p,c],[z,m]],
+
+        (   abc_problem(L, Word)
+        ->  format('~w OK~n', [Word])
+        ;   format('~w KO~n', [Word])).
+
+abc_problem(L, Word) :-
+        atom_chars(Word, C_Words),
+        maplist(downcase_atom, C_Words, D_Words),
+        can_makeword(L, D_Words).
+
+can_makeword(_L, []).
+
+can_makeword(L, [H | T]) :-
+        (   select([H, _], L, L1); select([_, H], L, L1)),
+        can_makeword(L1, T).
+
diff --git a/tests/abc.prolog.html b/tests/abc.prolog.html
new file mode 100644
--- /dev/null
+++ b/tests/abc.prolog.html
@@ -0,0 +1,40 @@
+
abc_problem :-
+        maplist(abc_problem, ['', 'A', bark, bOOk, treAT, 'COmmon', sQuaD, 'CONFUSE']).
+
+
+abc_problem(Word) :-
+        L = [[b,o],[x,k],[d,q],[c,p],[n,a],[g,t],[r,e],[t,g],[q,d],[f,s],
+             [j,w],[h,u],[v,i],[a,n],[o,b],[e,r],[f,s],[l,y],[p,c],[z,m]],
+
+        (   abc_problem(L, Word)
+        ->  format('~w OK~n', [Word])
+        ;   format('~w KO~n', [Word])).
+
+abc_problem(L, Word) :-
+        atom_chars(Word, C_Words),
+        maplist(downcase_atom, C_Words, D_Words),
+        can_makeword(L, D_Words).
+
+can_makeword(_L, []).
+
+can_makeword(L, [H | T]) :-
+        (   select([H, _], L, L1); select([_, H], L, L1)),
+        can_makeword(L1, T).
+

diff --git a/tests/abc.python b/tests/abc.python
new file mode 100644
--- /dev/null
+++ b/tests/abc.python
@@ -0,0 +1,16 @@
+def mkword(w, b):
+    if not w: return []
+
+    c,w = w[0],w[1:]
+    for i in range(len(b)):
+        if c in b[i]:
+            m = mkword(w, b[0:i] + b[i+1:])
+            if m != None: return [b[i]] + m
+
+def abc(w, blk):
+    return mkword(w.upper(), [a.upper() for a in blk])
+
+blocks = 'BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM'.split()
+
+for w in ", A, bark, book, treat, common, SQUAD, conFUsEd".split(', '):
+    print '\'' + w + '\'' + ' ->', abc(w, blocks)
diff --git a/tests/abc.python.html b/tests/abc.python.html
new file mode 100644
--- /dev/null
+++ b/tests/abc.python.html
@@ -0,0 +1,33 @@
+
def mkword(w, b):
+    if not w: return []
+
+    c,w = w[0],w[1:]
+    for i in range(len(b)):
+        if c in b[i]:
+            m = mkword(w, b[0:i] + b[i+1:])
+            if m != None: return [b[i]] + m
+
+def abc(w, blk):
+    return mkword(w.upper(), [a.upper() for a in blk])
+
+blocks = 'BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM'.split()
+
+for w in ", A, bark, book, treat, common, SQUAD, conFUsEd".split(', '):
+    print '\'' + w + '\'' + ' ->', abc(w, blocks)

diff --git a/tests/abc.r b/tests/abc.r
new file mode 100644
--- /dev/null
+++ b/tests/abc.r
@@ -0,0 +1,21 @@
+canMakeNoRecursion <- function(x) {
+  x <- toupper(x)
+  charList <- strsplit(x, character(0))
+  getCombos <- function(chars) {
+    charBlocks <-  data.matrix(expand.grid(lapply(chars, function(char) which(blocks == char, arr.ind=TRUE)[, 1L])))
+    charBlocks <- charBlocks[!apply(charBlocks, 1, function(row) any(duplicated(row))), , drop=FALSE]
+    if (dim(charBlocks)[1L] > 0L) {
+      t(apply(charBlocks, 1, function(row) apply(blocks[row, , drop=FALSE], 1, paste, collapse="")))
+    } else {
+      character(0)
+    }
+  }
+  setNames(lapply(charList, getCombos), x)
+}
+canMakeNoRecursion(c("A",
+           "BARK",
+           "BOOK",
+           "TREAT",
+           "COMMON",
+           "SQUAD",
+           "CONFUSE"))
diff --git a/tests/abc.r.html b/tests/abc.r.html
new file mode 100644
--- /dev/null
+++ b/tests/abc.r.html
@@ -0,0 +1,38 @@
+
canMakeNoRecursion <- function(x) {
+  x <- toupper(x)
+  charList <- strsplit(x, character(0))
+  getCombos <- function(chars) {
+    charBlocks <-  data.matrix(expand.grid(lapply(chars, function(char) which(blocks == char, arr.ind=TRUE)[, 1L])))
+    charBlocks <- charBlocks[!apply(charBlocks, 1, function(row) any(duplicated(row))), , drop=FALSE]
+    if (dim(charBlocks)[1L] > 0L) {
+      t(apply(charBlocks, 1, function(row) apply(blocks[row, , drop=FALSE], 1, paste, collapse="")))
+    } else {
+      character(0)
+    }
+  }
+  setNames(lapply(charList, getCombos), x)
+}
+canMakeNoRecursion(c("A",
+           "BARK",
+           "BOOK",
+           "TREAT",
+           "COMMON",
+           "SQUAD",
+           "CONFUSE"))

diff --git a/tests/abc.ruby b/tests/abc.ruby
new file mode 100644
--- /dev/null
+++ b/tests/abc.ruby
@@ -0,0 +1,8 @@
+words = %w(A BaRK BOoK tREaT COmMOn SqUAD CoNfuSE) << ""
+
+words.each do |word|
+  blocks = "BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM"
+  res = word.each_char.all?{|c| blocks.sub!(/\w?#{c}\w?/i, "")}  #regexps can be interpolated like strings
+  puts "#{word.inspect}: #{res}"
+end
+
diff --git a/tests/abc.ruby.html b/tests/abc.ruby.html
new file mode 100644
--- /dev/null
+++ b/tests/abc.ruby.html
@@ -0,0 +1,25 @@
+
words = %w(A BaRK BOoK tREaT COmMOn SqUAD CoNfuSE) << ""
+
+words.each do |word|
+  blocks = "BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM"
+  res = word.each_char.all?{|c| blocks.sub!(/\w?#{c}\w?/i, "")}  #regexps can be interpolated like strings
+  puts "#{word.inspect}: #{res}"
+end
+

diff --git a/tests/abc.scala b/tests/abc.scala
new file mode 100644
--- /dev/null
+++ b/tests/abc.scala
@@ -0,0 +1,50 @@
+object AbcBlocks extends App {
+
+  protected class Block(face1: Char, face2: Char) {
+
+    def isFacedWith(that: Char) = { that == face1 || that == face2 }
+    override def toString() = face1.toString + face2
+  }
+  protected object Block {
+    def apply(faces: String) = new Block(faces.head, faces.last)
+  }
+
+  type word = Seq[Block]
+
+  private val blocks = List(Block("BO"), Block("XK"), Block("DQ"), Block("CP"), Block("NA"),
+    Block("GT"), Block("RE"), Block("TG"), Block("QD"), Block("FS"),
+    Block("JW"), Block("HU"), Block("VI"), Block("AN"), Block("OB"),
+    Block("ER"), Block("FS"), Block("LY"), Block("PC"), Block("ZM"))
+
+  private def isMakeable(word: String, blocks: word) = {
+
+    def getTheBlocks(word: String, blocks: word) = {
+
+      def inner(word: String, toCompare: word, rest: word, accu: word): word = {
+        if (word.isEmpty || rest.isEmpty || toCompare.isEmpty) accu
+        else if (toCompare.head.isFacedWith(word.head)) {
+          val restant = rest diff List(toCompare.head)
+          inner(word.tail, restant, restant, accu :+ toCompare.head)
+        } else inner(word, toCompare.tail, rest, accu)
+      }
+      inner(word, blocks, blocks, Nil)
+    }
+
+    word.lengthCompare(getTheBlocks(word, blocks).size) == 0
+  }
+
+  val words = List("A", "BARK", "BOOK", "TREAT", "COMMON", "SQUAD", "CONFUSED", "ANBOCPDQERSFTGUVWXLZ")
+  // Automatic tests
+  assert(isMakeable(words(0), blocks))
+  assert(isMakeable(words(1), blocks))
+  assert(!isMakeable(words(2), blocks)) // BOOK not
+  assert(isMakeable(words(3), blocks))
+  assert(!isMakeable(words(4), blocks)) // COMMON not
+  assert(isMakeable(words(5), blocks))
+  assert(isMakeable(words(6), blocks))
+  assert(isMakeable(words(7), blocks))
+
+  //words(7).mkString.permutations.foreach(s => assert(isMakeable(s, blocks)))
+
+  words.foreach(w => println(s"$w can${if (isMakeable(w, blocks)) " " else "not "}be made."))
+}
diff --git a/tests/abc.scala.html b/tests/abc.scala.html
new file mode 100644
--- /dev/null
+++ b/tests/abc.scala.html
@@ -0,0 +1,67 @@
+
object AbcBlocks extends App {
+
+  protected class Block(face1: Char, face2: Char) {
+
+    def isFacedWith(that: Char) = { that == face1 || that == face2 }
+    override def toString() = face1.toString + face2
+  }
+  protected object Block {
+    def apply(faces: String) = new Block(faces.head, faces.last)
+  }
+
+  type word = Seq[Block]
+
+  private val blocks = List(Block("BO"), Block("XK"), Block("DQ"), Block("CP"), Block("NA"),
+    Block("GT"), Block("RE"), Block("TG"), Block("QD"), Block("FS"),
+    Block("JW"), Block("HU"), Block("VI"), Block("AN"), Block("OB"),
+    Block("ER"), Block("FS"), Block("LY"), Block("PC"), Block("ZM"))
+
+  private def isMakeable(word: String, blocks: word) = {
+
+    def getTheBlocks(word: String, blocks: word) = {
+
+      def inner(word: String, toCompare: word, rest: word, accu: word): word = {
+        if (word.isEmpty || rest.isEmpty || toCompare.isEmpty) accu
+        else if (toCompare.head.isFacedWith(word.head)) {
+          val restant = rest diff List(toCompare.head)
+          inner(word.tail, restant, restant, accu :+ toCompare.head)
+        } else inner(word, toCompare.tail, rest, accu)
+      }
+      inner(word, blocks, blocks, Nil)
+    }
+
+    word.lengthCompare(getTheBlocks(word, blocks).size) == 0
+  }
+
+  val words = List("A", "BARK", "BOOK", "TREAT", "COMMON", "SQUAD", "CONFUSED", "ANBOCPDQERSFTGUVWXLZ")
+  // Automatic tests
+  assert(isMakeable(words(0), blocks))
+  assert(isMakeable(words(1), blocks))
+  assert(!isMakeable(words(2), blocks)) // BOOK not
+  assert(isMakeable(words(3), blocks))
+  assert(!isMakeable(words(4), blocks)) // COMMON not
+  assert(isMakeable(words(5), blocks))
+  assert(isMakeable(words(6), blocks))
+  assert(isMakeable(words(7), blocks))
+
+  //words(7).mkString.permutations.foreach(s => assert(isMakeable(s, blocks)))
+
+  words.foreach(w => println(s"$w can${if (isMakeable(w, blocks)) " " else "not "}be made."))
+}

diff --git a/tests/abc.scheme b/tests/abc.scheme
new file mode 100644
--- /dev/null
+++ b/tests/abc.scheme
@@ -0,0 +1,43 @@
+#lang racket
+(define block-strings
+  (list "BO" "XK" "DQ" "CP" "NA"
+        "GT" "RE" "TG" "QD" "FS"
+        "JW" "HU" "VI" "AN" "OB"
+        "ER" "FS" "LY" "PC" "ZM"))
+(define BLOCKS (map string->list block-strings))
+
+(define (can-make-word? w)
+  (define (usable-block blocks word-char)
+    (for/first ((b (in-list blocks)) #:when (memf (curry char-ci=? word-char) b)) b))
+  
+  (define (inner word-chars blocks tried-blocks)
+    (cond
+      [(null? word-chars) #t]
+      [(usable-block blocks (car word-chars))
+       =>
+       (lambda (b)
+         (or
+          (inner (cdr word-chars) (append tried-blocks (remove b blocks)) null)
+          (inner word-chars (remove b blocks) (cons b tried-blocks))))]
+      [else #f]))
+  (inner (string->list w) BLOCKS null))
+
+(define WORD-LIST '("" "A" "BARK" "BOOK" "TREAT" "COMMON" "SQUAD" "CONFUSE"))
+(define (report-word w)
+  (printf "Can we make: ~a? ~a~%"
+          (~s w #:min-width 9)
+          (if (can-make-word? w) "yes" "no")))
+
+(module+ main
+  (for-each report-word WORD-LIST))  
+
+(module+ test
+  (require rackunit)
+  (check-true  (can-make-word? ""))
+  (check-true  (can-make-word? "A"))
+  (check-true  (can-make-word? "BARK"))
+  (check-false (can-make-word? "BOOK"))
+  (check-true  (can-make-word? "TREAT"))
+  (check-false (can-make-word? "COMMON"))
+  (check-true  (can-make-word? "SQUAD"))
+  (check-true  (can-make-word? "CONFUSE")))
diff --git a/tests/abc.scheme.html b/tests/abc.scheme.html
new file mode 100644
--- /dev/null
+++ b/tests/abc.scheme.html
@@ -0,0 +1,60 @@
+
#lang racket
+(define block-strings
+  (list "BO" "XK" "DQ" "CP" "NA"
+        "GT" "RE" "TG" "QD" "FS"
+        "JW" "HU" "VI" "AN" "OB"
+        "ER" "FS" "LY" "PC" "ZM"))
+(define BLOCKS (map string->list block-strings))
+
+(define (can-make-word? w)
+  (define (usable-block blocks word-char)
+    (for/first ((b (in-list blocks)) #:when (memf (curry char-ci=? word-char) b)) b))
+  
+  (define (inner word-chars blocks tried-blocks)
+    (cond
+      [(null? word-chars) #t]
+      [(usable-block blocks (car word-chars))
+       =>
+       (lambda (b)
+         (or
+          (inner (cdr word-chars) (append tried-blocks (remove b blocks)) null)
+          (inner word-chars (remove b blocks) (cons b tried-blocks))))]
+      [else #f]))
+  (inner (string->list w) BLOCKS null))
+
+(define WORD-LIST '("" "A" "BARK" "BOOK" "TREAT" "COMMON" "SQUAD" "CONFUSE"))
+(define (report-word w)
+  (printf "Can we make: ~a? ~a~%"
+          (~s w #:min-width 9)
+          (if (can-make-word? w) "yes" "no")))
+
+(module+ main
+  (for-each report-word WORD-LIST))  
+
+(module+ test
+  (require rackunit)
+  (check-true  (can-make-word? ""))
+  (check-true  (can-make-word? "A"))
+  (check-true  (can-make-word? "BARK"))
+  (check-false (can-make-word? "BOOK"))
+  (check-true  (can-make-word? "TREAT"))
+  (check-false (can-make-word? "COMMON"))
+  (check-true  (can-make-word? "SQUAD"))
+  (check-true  (can-make-word? "CONFUSE")))

diff --git a/tests/abc.tcl b/tests/abc.tcl
new file mode 100644
--- /dev/null
+++ b/tests/abc.tcl
@@ -0,0 +1,21 @@
+package require Tcl 8.6
+
+proc abc {word {blocks {BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM}}} {
+    set abc {{letters blocks abc} {
+        set rest [lassign $letters ch]
+        set i 0
+        foreach blk $blocks {
+            if {$ch in $blk && (![llength $rest]
+                    || [apply $abc $rest [lreplace $blocks $i $i] $abc])} {
+                return true
+            }
+            incr i
+        }
+        return false
+    }}
+    return [apply $abc [split $word ""] [lmap b $blocks {split $b ""}] $abc]
+}
+
+foreach word {"" A BARK BOOK TREAT COMMON SQUAD CONFUSE} {
+    puts [format "Can we spell %9s? %s" '$word' [abc $word]]
+}
diff --git a/tests/abc.tcl.html b/tests/abc.tcl.html
new file mode 100644
--- /dev/null
+++ b/tests/abc.tcl.html
@@ -0,0 +1,38 @@
+
package require Tcl 8.6
+
+proc abc {word {blocks {BO XK DQ CP NA GT RE TG QD FS JW HU VI AN OB ER FS LY PC ZM}}} {
+    set abc {{letters blocks abc} {
+        set rest [lassign $letters ch]
+        set i 0
+        foreach blk $blocks {
+            if {$ch in $blk && (![llength $rest]
+                    || [apply $abc $rest [lreplace $blocks $i $i] $abc])} {
+                return true
+            }
+            incr i
+        }
+        return false
+    }}
+    return [apply $abc [split $word ""] [lmap b $blocks {split $b ""}] $abc]
+}
+
+foreach word {"" A BARK BOOK TREAT COMMON SQUAD CONFUSE} {
+    puts [format "Can we spell %9s? %s" '$word' [abc $word]]
+}

diff --git a/tests/archive.rhtml b/tests/archive.rhtml
new file mode 100644
--- /dev/null
+++ b/tests/archive.rhtml
@@ -0,0 +1,23 @@
+
Event Archive

+
+
+<% form_for :to_date, @to_date, :url => {:action => 'archive'} do |f| %>
+  

+  <%= select_date @from_date, :prefix => 'from' %>
+  
+  <%= select_date @to_date, :prefix => 'to', :start_year => 2000 %>

+  

+  <%= select_tag "series", options_for_select(series_list('All'), @series) %>
+  <%= f.submit 'Show events' %>
+  

+<% end %>
+
+
    
+<%
+if @events
+%>
+  <%= render :partial => 'events' %>
+<%
+end
+%>
+

diff --git a/tests/archive.rhtml.html b/tests/archive.rhtml.html
new file mode 100644
--- /dev/null
+++ b/tests/archive.rhtml.html
@@ -0,0 +1,40 @@
+
<h1>Event Archive</h1>
+
+
+<% form_for :to_date, @to_date, :url => {:action => 'archive'} do |f| %>
+  <p><label for="start_date">From</label>
+  <%= select_date @from_date, :prefix => 'from' %>
+  <label for="end_date">To</label>
+  <%= select_date @to_date, :prefix => 'to', :start_year => 2000 %></p>
+  <p><label for="event_series">Series</label>
+  <%= select_tag "series", options_for_select(series_list('All'), @series) %>
+  <%= f.submit 'Show events' %>
+  </p>
+<% end %>
+
+<ul>
+<%
+if @events
+%>
+  <%= render :partial => 'events' %>
+<%
+end
+%>
+</ul>

diff --git a/tests/life.lua b/tests/life.lua
new file mode 100644
--- /dev/null
+++ b/tests/life.lua
@@ -0,0 +1,111 @@
+-- life.lua
+-- original by Dave Bollinger  posted to lua-l
+-- modified to use ANSI terminal escape sequences
+-- modified to use for instead of while
+
+local write=io.write
+
+ALIVE="¥"	DEAD="þ"
+ALIVE="O"	DEAD="-"
+
+function delay() -- NOTE: SYSTEM-DEPENDENT, adjust as necessary
+  for i=1,10000 do end
+  -- local i=os.clock()+1 while(os.clock() 0 do
+    local xm1,x,xp1,xi=self.w-1,self.w,1,self.w
+    while xi > 0 do
+      local sum = self[ym1][xm1] + self[ym1][x] + self[ym1][xp1] +
+                  self[y][xm1] + self[y][xp1] +
+                  self[yp1][xm1] + self[yp1][x] + self[yp1][xp1]
+      next[y][x] = ((sum==2) and self[y][x]) or ((sum==3) and 1) or 0
+      xm1,x,xp1,xi = x,xp1,xp1+1,xi-1
+    end
+    ym1,y,yp1,yi = y,yp1,yp1+1,yi-1
+  end
+end
+
+-- output the array to screen
+function _CELLS:draw()
+  local out="" -- accumulate to reduce flicker
+  for y=1,self.h do
+   for x=1,self.w do
+      out=out..(((self[y][x]>0) and ALIVE) or DEAD)
+    end
+    out=out.."\n"
+  end
+  write(out)
+end
+
+-- constructor
+function CELLS(w,h)
+  local c = ARRAY2D(w,h)
+  c.spawn = _CELLS.spawn
+  c.evolve = _CELLS.evolve
+  c.draw = _CELLS.draw
+  return c
+end
+
+--
+-- shapes suitable for use with spawn() above
+--
+HEART = { 1,0,1,1,0,1,1,1,1; w=3,h=3 }
+GLIDER = { 0,0,1,1,0,1,0,1,1; w=3,h=3 }
+EXPLODE = { 0,1,0,1,1,1,1,0,1,0,1,0; w=3,h=4 }
+FISH = { 0,1,1,1,1,1,0,0,0,1,0,0,0,0,1,1,0,0,1,0; w=5,h=4 }
+BUTTERFLY = { 1,0,0,0,1,0,1,1,1,0,1,0,0,0,1,1,0,1,0,1,1,0,0,0,1; w=5,h=5 }
+
+-- the main routine
+function LIFE(w,h)
+  -- create two arrays
+  local thisgen = CELLS(w,h)
+  local nextgen = CELLS(w,h)
+
+  -- create some life
+  -- about 1000 generations of fun, then a glider steady-state
+  thisgen:spawn(GLIDER,5,4)
+  thisgen:spawn(EXPLODE,25,10)
+  thisgen:spawn(FISH,4,12)
+
+  -- run until break
+  local gen=1
+  write("\027[2J")	-- ANSI clear screen
+  while 1 do
+    thisgen:evolve(nextgen)
+    thisgen,nextgen = nextgen,thisgen
+    write("\027[H")	-- ANSI home cursor
+    thisgen:draw()
+    write("Life - generation ",gen,"\n")
+    gen=gen+1
+    if gen>2000 then break end
+    --delay()		-- no delay
+  end
+end
+
+LIFE(40,20)
diff --git a/tests/life.lua.html b/tests/life.lua.html
new file mode 100644
--- /dev/null
+++ b/tests/life.lua.html
@@ -0,0 +1,128 @@
+
-- life.lua
+-- original by Dave Bollinger <DBollinger@compuserve.com> posted to lua-l
+-- modified to use ANSI terminal escape sequences
+-- modified to use for instead of while
+
+local write=io.write
+
+ALIVE="¥"	DEAD="þ"
+ALIVE="O"	DEAD="-"
+
+function delay() -- NOTE: SYSTEM-DEPENDENT, adjust as necessary
+  for i=1,10000 do end
+  -- local i=os.clock()+1 while(os.clock()<i) do end
+end
+
+function ARRAY2D(w,h)
+  local t = {w=w,h=h}
+  for y=1,h do
+    t[y] = {}
+    for x=1,w do
+      t[y][x]=0
+    end
+  end
+  return t
+end
+
+_CELLS = {}
+
+-- give birth to a "shape" within the cell array
+function _CELLS:spawn(shape,left,top)
+  for y=0,shape.h-1 do
+    for x=0,shape.w-1 do
+      self[top+y][left+x] = shape[y*shape.w+x+1]
+    end
+  end
+end
+
+-- run the CA and produce the next generation
+function _CELLS:evolve(next)
+  local ym1,y,yp1,yi=self.h-1,self.h,1,self.h
+  while yi > 0 do
+    local xm1,x,xp1,xi=self.w-1,self.w,1,self.w
+    while xi > 0 do
+      local sum = self[ym1][xm1] + self[ym1][x] + self[ym1][xp1] +
+                  self[y][xm1] + self[y][xp1] +
+                  self[yp1][xm1] + self[yp1][x] + self[yp1][xp1]
+      next[y][x] = ((sum==2) and self[y][x]) or ((sum==3) and 1) or 0
+      xm1,x,xp1,xi = x,xp1,xp1+1,xi-1
+    end
+    ym1,y,yp1,yi = y,yp1,yp1+1,yi-1
+  end
+end
+
+-- output the array to screen
+function _CELLS:draw()
+  local out="" -- accumulate to reduce flicker
+  for y=1,self.h do
+   for x=1,self.w do
+      out=out..(((self[y][x]>0) and ALIVE) or DEAD)
+    end
+    out=out.."\n"
+  end
+  write(out)
+end
+
+-- constructor
+function CELLS(w,h)
+  local c = ARRAY2D(w,h)
+  c.spawn = _CELLS.spawn
+  c.evolve = _CELLS.evolve
+  c.draw = _CELLS.draw
+  return c
+end
+
+--
+-- shapes suitable for use with spawn() above
+--
+HEART = { 1,0,1,1,0,1,1,1,1; w=3,h=3 }
+GLIDER = { 0,0,1,1,0,1,0,1,1; w=3,h=3 }
+EXPLODE = { 0,1,0,1,1,1,1,0,1,0,1,0; w=3,h=4 }
+FISH = { 0,1,1,1,1,1,0,0,0,1,0,0,0,0,1,1,0,0,1,0; w=5,h=4 }
+BUTTERFLY = { 1,0,0,0,1,0,1,1,1,0,1,0,0,0,1,1,0,1,0,1,1,0,0,0,1; w=5,h=5 }
+
+-- the main routine
+function LIFE(w,h)
+  -- create two arrays
+  local thisgen = CELLS(w,h)
+  local nextgen = CELLS(w,h)
+
+  -- create some life
+  -- about 1000 generations of fun, then a glider steady-state
+  thisgen:spawn(GLIDER,5,4)
+  thisgen:spawn(EXPLODE,25,10)
+  thisgen:spawn(FISH,4,12)
+
+  -- run until break
+  local gen=1
+  write("\027[2J")	-- ANSI clear screen
+  while 1 do
+    thisgen:evolve(nextgen)
+    thisgen,nextgen = nextgen,thisgen
+    write("\027[H")	-- ANSI home cursor
+    thisgen:draw()
+    write("Life - generation ",gen,"\n")
+    gen=gen+1
+    if gen>2000 then break end
+    --delay()		-- no delay
+  end
+end
+
+LIFE(40,20)

diff --git a/tests/test-highlighting-kate.hs b/tests/test-highlighting-kate.hs
new file mode 100644
--- /dev/null
+++ b/tests/test-highlighting-kate.hs
@@ -0,0 +1,83 @@
+{-# LANGUAGE CPP, OverloadedStrings #-}
+module Main where
+import Data.Char (toLower)
+import Control.Monad
+import System.Exit
+import System.Directory
+import System.FilePath
+import Data.Maybe (fromMaybe)
+import Text.Printf
+import System.IO
+import Data.Monoid (mempty)
+import Text.Printf
+import Text.Highlighting.Kate
+import Data.Algorithm.Diff
+import Control.Applicative
+import System.Environment (getArgs)
+#if MIN_VERSION_blaze_html(0,5,0)
+import Text.Blaze.Html
+import Text.Blaze.Html.Renderer.String
+#else
+import Text.Blaze
+import Text.Blaze.Renderer.String
+#endif
+import qualified Text.Blaze.Html5 as H
+import qualified Text.Blaze.Html5.Attributes as A
+
+data TestResult = Pass | Fail | Error
+                  deriving (Eq, Show)
+
+main = do
+  inputs <- map ("tests" ) <$>
+            filter isTestFile <$> getDirectoryContents "tests"
+  args <- getArgs
+  let regen = "--regenerate" `elem` args
+  results <- forM inputs (runTest regen)
+  let numfailures = length $ filter (== Fail) results
+  let numerrors = length $ filter (== Error) results
+  exitWith $ if numfailures == 0 && numerrors == 0
+                then ExitSuccess
+                else ExitFailure $ numfailures + numerrors
+
+isTestFile :: FilePath -> Bool
+isTestFile f = case drop 1 $ takeExtension f of
+                    x -> x `elem` map (map toLower) languages &&
+                          null (takeExtension (dropExtension f))
+
+err :: String -> IO ()
+err = hPutStrLn stderr
+
+runTest regen inpFile = do
+  code <- readFile inpFile
+  let lang = drop 1 $ takeExtension inpFile
+  let actual = formatHtml $ highlightAs lang code
+  when regen $
+    writeFile (inpFile <.> "html") actual
+  expectedString <- readFile (inpFile <.> "html")
+  if expectedString == actual
+     then do
+       putStrLn $ "[PASSED] " ++ inpFile
+       return Pass
+     else do
+       putStrLn $ "[FAILED] " ++ inpFile
+       putStrLn $ "--- " ++ inpFile <.> "html"
+       putStrLn $ "+++ actual"
+       printDiff expectedString actual
+       return Fail
+
+formatHtml toks =
+  renderHtml $ H.head (metadata >> css) >> H.body (toHtml fragment)
+  where css = H.style ! A.type_ "text/css" $ toHtml $ styleToCss pygments
+        fragment = formatHtmlBlock opts toks
+        metadata = H.meta ! A.httpEquiv "Content-Type"
+                              ! A.content "text/html; charset=UTF-8"
+        opts = defaultFormatOpts{ titleAttributes = True }
+
+vividize :: Diff String -> String
+vividize (Both s _) = "  " ++ s
+vividize (First s)  = "- " ++ s
+vividize (Second s) = "+ " ++ s
+
+printDiff :: String -> String -> IO ()
+printDiff expected actual = do
+  mapM_ putStrLn $ map vividize $ getDiff (lines expected) (lines actual)
diff --git a/xml/abc.xml b/xml/abc.xml
new file mode 100644
--- /dev/null
+++ b/xml/abc.xml
@@ -0,0 +1,88 @@
+
+
+
+
+    
+        
+           
+
+	    
+
+	    
+
+	    
+
+	    
+
+	    
+	    
+	    
+
+	    
+	    
+	    
+
+	    
+
+	    
+	    
+	    
+	    
+	    
+	    
+	    
+
+	    
+	   
+	   
+	   
+	   
+	   
+	   
+
+	   
+	   	
+
+		
+
+		
+
+	    
+
+	    
+
+		
+	   
+
+	   
+
+		
+
+		
+	   
+
+	   
+       
+        
+          
+          
+	  
+	  
+	  
+	  
+	  
+	  
+	  
+	  
+	  
+	  
+	
+ 
+  
+    
+      
+    
+    
+  
+
diff --git a/xml/actionscript.xml b/xml/actionscript.xml
--- a/xml/actionscript.xml
+++ b/xml/actionscript.xml
@@ -259,14 +259,14 @@
         
         
         
-          
-          
-          
-          
-          
-          
-          
-          
+          
+          
+          
+          
+          
+          
+          
+          
         
         
         
diff --git a/xml/alert_indent.xml b/xml/alert_indent.xml
--- a/xml/alert_indent.xml
+++ b/xml/alert_indent.xml
@@ -26,17 +26,18 @@
  This file is included in every file that highlights the "alerts" keywords.
  That's why extensions and mimetype are empty.
 -->
-