highlighting-kate 0.5.10 → 0.5.11

raw patch · 125 files changed

+534/−121 lines, 125 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

+ Text.Highlighting.Kate.Types: synStContinuation :: SyntaxState -> Bool

- Text.Highlighting.Kate.Types: SyntaxState :: ContextStack -> Int -> Char -> Bool -> Bool -> Bool -> [String] -> SyntaxState

+ Text.Highlighting.Kate.Types: SyntaxState :: ContextStack -> Int -> Char -> Bool -> Bool -> Bool -> Bool -> [String] -> SyntaxState

Files

Makefile +0/−1
ParseSyntaxFiles.hs +2/−0
README.md +1/−0
Text/Highlighting/Kate/Common.hs +5/−1
Text/Highlighting/Kate/Syntax.hs +5/−3
Text/Highlighting/Kate/Syntax/Abc.hs +3/−1
Text/Highlighting/Kate/Syntax/Actionscript.hs +3/−1
Text/Highlighting/Kate/Syntax/Ada.hs +3/−1
Text/Highlighting/Kate/Syntax/Agda.hs +3/−1
Text/Highlighting/Kate/Syntax/Alert.hs +3/−1
Text/Highlighting/Kate/Syntax/Alert_indent.hs +3/−1
Text/Highlighting/Kate/Syntax/Apache.hs +3/−1
Text/Highlighting/Kate/Syntax/Asn1.hs +3/−1
Text/Highlighting/Kate/Syntax/Asp.hs +3/−1
Text/Highlighting/Kate/Syntax/Awk.hs +3/−1
Text/Highlighting/Kate/Syntax/Bash.hs +3/−1
Text/Highlighting/Kate/Syntax/Bibtex.hs +3/−1
Text/Highlighting/Kate/Syntax/Boo.hs +3/−1
Text/Highlighting/Kate/Syntax/C.hs +3/−1
Text/Highlighting/Kate/Syntax/Changelog.hs +3/−1
Text/Highlighting/Kate/Syntax/Clojure.hs +3/−1
Text/Highlighting/Kate/Syntax/Cmake.hs +3/−1
Text/Highlighting/Kate/Syntax/Coffee.hs +3/−1
Text/Highlighting/Kate/Syntax/Coldfusion.hs +3/−1
Text/Highlighting/Kate/Syntax/Commonlisp.hs +3/−1
Text/Highlighting/Kate/Syntax/Cpp.hs +3/−1
Text/Highlighting/Kate/Syntax/Cs.hs +3/−1
Text/Highlighting/Kate/Syntax/Css.hs +3/−1
Text/Highlighting/Kate/Syntax/Curry.hs +3/−1
Text/Highlighting/Kate/Syntax/D.hs +3/−1
Text/Highlighting/Kate/Syntax/Diff.hs +3/−1
Text/Highlighting/Kate/Syntax/Djangotemplate.hs +3/−1
Text/Highlighting/Kate/Syntax/Dockerfile.hs +101/−0
Text/Highlighting/Kate/Syntax/Dot.hs +3/−1
Text/Highlighting/Kate/Syntax/Doxygen.hs +3/−1
Text/Highlighting/Kate/Syntax/Doxygenlua.hs +3/−1
Text/Highlighting/Kate/Syntax/Dtd.hs +3/−1
Text/Highlighting/Kate/Syntax/Eiffel.hs +3/−1
Text/Highlighting/Kate/Syntax/Email.hs +3/−1
Text/Highlighting/Kate/Syntax/Erlang.hs +3/−1
Text/Highlighting/Kate/Syntax/Fasm.hs +3/−1
Text/Highlighting/Kate/Syntax/Fortran.hs +3/−1
Text/Highlighting/Kate/Syntax/Fsharp.hs +3/−1
Text/Highlighting/Kate/Syntax/Gcc.hs +3/−1
Text/Highlighting/Kate/Syntax/Glsl.hs +3/−1
Text/Highlighting/Kate/Syntax/Gnuassembler.hs +3/−1
Text/Highlighting/Kate/Syntax/Go.hs +3/−1
Text/Highlighting/Kate/Syntax/Haskell.hs +3/−1
Text/Highlighting/Kate/Syntax/Haxe.hs +3/−1
Text/Highlighting/Kate/Syntax/Html.hs +3/−1
Text/Highlighting/Kate/Syntax/Ini.hs +3/−1
Text/Highlighting/Kate/Syntax/Isocpp.hs +3/−1
Text/Highlighting/Kate/Syntax/Java.hs +3/−1
Text/Highlighting/Kate/Syntax/Javadoc.hs +3/−1
Text/Highlighting/Kate/Syntax/Javascript.hs +3/−1
Text/Highlighting/Kate/Syntax/Json.hs +3/−1
Text/Highlighting/Kate/Syntax/Jsp.hs +3/−1
Text/Highlighting/Kate/Syntax/Julia.hs +3/−1
Text/Highlighting/Kate/Syntax/Latex.hs +3/−1
Text/Highlighting/Kate/Syntax/Lex.hs +3/−1
Text/Highlighting/Kate/Syntax/Lilypond.hs +3/−1
Text/Highlighting/Kate/Syntax/LiterateCurry.hs +3/−1
Text/Highlighting/Kate/Syntax/LiterateHaskell.hs +3/−1
Text/Highlighting/Kate/Syntax/Lua.hs +3/−1
Text/Highlighting/Kate/Syntax/M4.hs +3/−1
Text/Highlighting/Kate/Syntax/Makefile.hs +3/−1
Text/Highlighting/Kate/Syntax/Mandoc.hs +3/−1
Text/Highlighting/Kate/Syntax/Markdown.hs +3/−1
Text/Highlighting/Kate/Syntax/Mathematica.hs +3/−1
Text/Highlighting/Kate/Syntax/Matlab.hs +3/−1
Text/Highlighting/Kate/Syntax/Maxima.hs +3/−1
Text/Highlighting/Kate/Syntax/Mediawiki.hs +3/−1
Text/Highlighting/Kate/Syntax/Metafont.hs +3/−1
Text/Highlighting/Kate/Syntax/Mips.hs +3/−1
Text/Highlighting/Kate/Syntax/Modelines.hs +3/−1
Text/Highlighting/Kate/Syntax/Modula2.hs +3/−1
Text/Highlighting/Kate/Syntax/Modula3.hs +3/−1
Text/Highlighting/Kate/Syntax/Monobasic.hs +3/−1
Text/Highlighting/Kate/Syntax/Nasm.hs +3/−1
Text/Highlighting/Kate/Syntax/Noweb.hs +3/−1
Text/Highlighting/Kate/Syntax/Objectivec.hs +3/−1
Text/Highlighting/Kate/Syntax/Objectivecpp.hs +3/−1
Text/Highlighting/Kate/Syntax/Ocaml.hs +3/−1
Text/Highlighting/Kate/Syntax/Octave.hs +3/−1
Text/Highlighting/Kate/Syntax/Opencl.hs +3/−1
Text/Highlighting/Kate/Syntax/Pascal.hs +3/−1
Text/Highlighting/Kate/Syntax/Perl.hs +3/−1
Text/Highlighting/Kate/Syntax/Php.hs +3/−1
Text/Highlighting/Kate/Syntax/Pike.hs +3/−1
Text/Highlighting/Kate/Syntax/Postscript.hs +3/−1
Text/Highlighting/Kate/Syntax/Prolog.hs +3/−1
Text/Highlighting/Kate/Syntax/Pure.hs +3/−1
Text/Highlighting/Kate/Syntax/Python.hs +3/−1
Text/Highlighting/Kate/Syntax/R.hs +3/−1
Text/Highlighting/Kate/Syntax/Relaxng.hs +3/−1
Text/Highlighting/Kate/Syntax/Relaxngcompact.hs +3/−1
Text/Highlighting/Kate/Syntax/Rest.hs +3/−1
Text/Highlighting/Kate/Syntax/Rhtml.hs +3/−1
Text/Highlighting/Kate/Syntax/Roff.hs +3/−1
Text/Highlighting/Kate/Syntax/Ruby.hs +3/−1
Text/Highlighting/Kate/Syntax/Rust.hs +3/−1
Text/Highlighting/Kate/Syntax/Scala.hs +3/−1
Text/Highlighting/Kate/Syntax/Scheme.hs +3/−1
Text/Highlighting/Kate/Syntax/Sci.hs +3/−1
Text/Highlighting/Kate/Syntax/Sed.hs +3/−1
Text/Highlighting/Kate/Syntax/Sgml.hs +3/−1
Text/Highlighting/Kate/Syntax/Sql.hs +3/−1
Text/Highlighting/Kate/Syntax/SqlMysql.hs +3/−1
Text/Highlighting/Kate/Syntax/SqlPostgresql.hs +3/−1
Text/Highlighting/Kate/Syntax/Tcl.hs +3/−1
Text/Highlighting/Kate/Syntax/Tcsh.hs +3/−1
Text/Highlighting/Kate/Syntax/Texinfo.hs +3/−1
Text/Highlighting/Kate/Syntax/Verilog.hs +3/−1
Text/Highlighting/Kate/Syntax/Vhdl.hs +3/−1
Text/Highlighting/Kate/Syntax/Xml.hs +3/−1
Text/Highlighting/Kate/Syntax/Xorg.hs +3/−1
Text/Highlighting/Kate/Syntax/Xslt.hs +3/−1
Text/Highlighting/Kate/Syntax/Xul.hs +3/−1
Text/Highlighting/Kate/Syntax/Yacc.hs +3/−1
Text/Highlighting/Kate/Syntax/Yaml.hs +3/−1
Text/Highlighting/Kate/Syntax/Zsh.hs +3/−1
Text/Highlighting/Kate/Types.hs +3/−0
changelog +9/−0
highlighting-kate.cabal +2/−1
xml/dockerfile.xml +61/−0

Makefile view

@@ -19,7 +19,6 @@ 	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."

ParseSyntaxFiles.hs view

@@ -254,8 +254,10 @@                       (nest 2 $ text "updateState $ \\st -> st{ synStPrevNonspace = False }" $$                                 text "context <- currentContext" $$                                 text "contexts <- synStContexts `fmap` getState" $$+                                text "st <- getState" $$                                 text "if length contexts >= 2" $$                                 text "  then case context of" $$+                                (nest 4 $ text "_ | synStContinuation st -> updateState $ \\st -> st{ synStContinuation = False }") $$                                 (nest 4 $ (vcat $ map (\cont -> text (show (synLanguage syntax, contName cont)) <> text " -> " <>                                             switchContext (synLanguage syntax, contLineEndContext cont) (<> text " >> ") <>                                             if "#pop" `isPrefixOf` (contLineEndContext cont)

README.md view

@@ -32,6 +32,7 @@ - D - Diff - Djangotemplate+- Dockerfile - Dot - Doxygen - Dtd

Text/Highlighting/Kate/Common.hs view

@@ -287,7 +287,11 @@   return $ startChar : (body ++ [endChar])  pLineContinue :: KateParser String-pLineContinue = try $ char '\\' >> eof >> return "\\"+pLineContinue = try $ do+  char '\\'+  eof+  updateState $ \st -> st{ synStContinuation = True }+  return "\\"  pDetectSpaces :: KateParser [Char] pDetectSpaces = many1 (satisfy $ \c -> c == ' ' || c == '\t')

Text/Highlighting/Kate/Syntax.hs view

@@ -42,6 +42,7 @@ 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.Dockerfile as Dockerfile 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@@ -133,11 +134,11 @@  -- | List of supported languages. languages :: [String]-languages = ["Abc","Actionscript","Ada","Agda","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"]+languages = ["Abc","Actionscript","Ada","Agda","Alert","Alert_indent","Apache","Asn1","Asp","Awk","Bash","Bibtex","Boo","C","Changelog","Clojure","Cmake","Coffee","Coldfusion","Commonlisp","Cpp","Cs","Css","Curry","D","Diff","Djangotemplate","Dockerfile","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 = [("Abc", Abc.syntaxExtensions), ("Actionscript", Actionscript.syntaxExtensions), ("Ada", Ada.syntaxExtensions), ("Agda", Agda.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)]+languageExtensions = [("Abc", Abc.syntaxExtensions), ("Actionscript", Actionscript.syntaxExtensions), ("Ada", Ada.syntaxExtensions), ("Agda", Agda.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), ("Dockerfile", Dockerfile.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]@@ -153,7 +154,7 @@ -- extension (if unique). -- The parsers read the input lazily and parse line by line; -- results are returned immediately.--- Supported languages: @abc@, @actionscript@, @ada@, @agda@, @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@.+-- Supported languages: @abc@, @actionscript@, @ada@, @agda@, @alert@, @alert_indent@, @apache@, @asn1@, @asp@, @awk@, @bash@, @bibtex@, @boo@, @c@, @changelog@, @clojure@, @cmake@, @coffee@, @coldfusion@, @commonlisp@, @cpp@, @cs@, @css@, @curry@, @d@, @diff@, @djangotemplate@, @dockerfile@, @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@@ -192,6 +193,7 @@         "d" -> D.highlight         "diff" -> Diff.highlight         "djangotemplate" -> Djangotemplate.highlight+        "dockerfile" -> Dockerfile.highlight         "dot" -> Dot.highlight         "doxygen" -> Doxygen.highlight         "doxygenlua" -> Doxygenlua.highlight

Text/Highlighting/Kate/Syntax/Abc.hs view

@@ -36,14 +36,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("ABC","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("ABC","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("ABC","Normal") -> return ()       ("ABC","Preprocessor") -> (popContext) >> pEndLine       ("ABC","Lyrics") -> (popContext) >> pEndLine

Text/Highlighting/Kate/Syntax/Actionscript.hs view

@@ -38,14 +38,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("ActionScript 2.0","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("ActionScript 2.0","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("ActionScript 2.0","Normal") -> return ()       ("ActionScript 2.0","String") -> (popContext) >> pEndLine       ("ActionScript 2.0","Member") -> (popContext) >> pEndLine

Text/Highlighting/Kate/Syntax/Ada.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Ada","Default")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Ada","Default")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Ada","Default") -> return ()       ("Ada","Region Marker") -> (popContext) >> pEndLine       ("Ada","String") -> (popContext) >> pEndLine

Text/Highlighting/Kate/Syntax/Agda.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Agda","code")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Agda","code")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Agda","code") -> return ()       ("Agda","comment") -> (popContext) >> pEndLine       ("Agda","comments") -> return ()

Text/Highlighting/Kate/Syntax/Alert.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Alerts","Normal Text")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Alerts","Normal Text")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Alerts","Normal Text") -> (popContext) >> pEndLine       _ -> return ()     else return ()

Text/Highlighting/Kate/Syntax/Alert_indent.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Alerts_indent","Normal Text")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Alerts_indent","Normal Text")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Alerts_indent","Normal Text") -> (popContext) >> pEndLine       _ -> return ()     else return ()

Text/Highlighting/Kate/Syntax/Apache.hs view

@@ -38,14 +38,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Apache Configuration","apache")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Apache Configuration","apache")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Apache Configuration","apache") -> return ()       ("Apache Configuration","String Directives") -> (popContext) >> pEndLine       ("Apache Configuration","Integer Directives") -> (popContext) >> pEndLine

Text/Highlighting/Kate/Syntax/Asn1.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("ASN.1","Normal Text")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("ASN.1","Normal Text")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("ASN.1","Normal Text") -> return ()       ("ASN.1","Comment") -> (popContext) >> pEndLine       _ -> return ()

Text/Highlighting/Kate/Syntax/Asp.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("ASP","nosource")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("ASP","nosource")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("ASP","nosource") -> return ()       ("ASP","aspsource") -> return ()       ("ASP","asp_onelinecomment") -> (popContext) >> pEndLine

Text/Highlighting/Kate/Syntax/Awk.hs view

@@ -38,14 +38,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("AWK","Pattern")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("AWK","Pattern")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("AWK","Pattern") -> return ()       ("AWK","Block") -> return ()       ("AWK","base") -> return ()

Text/Highlighting/Kate/Syntax/Bash.hs view

@@ -39,14 +39,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Bash","Start")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Bash","Start")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Bash","Start") -> return ()       ("Bash","FindAll") -> return ()       ("Bash","FindMost") -> return ()

Text/Highlighting/Kate/Syntax/Bibtex.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("BibTeX","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("BibTeX","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("BibTeX","Normal") -> return ()       ("BibTeX","PreambleCommand") -> return ()       ("BibTeX","StringCommand") -> return ()

Text/Highlighting/Kate/Syntax/Boo.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Boo","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Boo","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Boo","Normal") -> return ()       ("Boo","parenthesised") -> return ()       ("Boo","Quasi-Quotation") -> return ()

Text/Highlighting/Kate/Syntax/C.hs view

@@ -39,14 +39,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("C","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("C","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("C","Normal") -> return ()       ("C","String") -> (popContext) >> pEndLine       ("C","Region Marker") -> (popContext) >> pEndLine

Text/Highlighting/Kate/Syntax/Changelog.hs view

@@ -36,14 +36,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("ChangeLog","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("ChangeLog","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("ChangeLog","Normal") -> return ()       ("ChangeLog","line") -> (popContext) >> pEndLine       ("ChangeLog","entry") -> (popContext) >> pEndLine

Text/Highlighting/Kate/Syntax/Clojure.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Clojure","Level0")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Clojure","Level0")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Clojure","Level0") -> return ()       ("Clojure","Default") -> return ()       ("Clojure","function_decl") -> return ()

Text/Highlighting/Kate/Syntax/Cmake.hs view

@@ -39,14 +39,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("CMake","Normal Text")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("CMake","Normal Text")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("CMake","Normal Text") -> return ()       ("CMake","Detect More Builtin Variables") -> return ()       ("CMake","Detect Builtin Variables") -> return ()

Text/Highlighting/Kate/Syntax/Coffee.hs view

@@ -39,14 +39,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("CoffeeScript","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("CoffeeScript","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("CoffeeScript","Normal") -> return ()       ("CoffeeScript","Multiline Regex") -> return ()       ("CoffeeScript","Class") -> return ()

Text/Highlighting/Kate/Syntax/Coldfusion.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("ColdFusion","Normal Text")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("ColdFusion","Normal Text")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("ColdFusion","Normal Text") -> return ()       ("ColdFusion","ctxCFSCRIPT Tag") -> return ()       ("ColdFusion","ctxSCRIPT Tag") -> return ()

Text/Highlighting/Kate/Syntax/Commonlisp.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Common Lisp","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Common Lisp","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Common Lisp","Normal") -> return ()       ("Common Lisp","MultiLineComment") -> return ()       ("Common Lisp","function_decl") -> return ()

Text/Highlighting/Kate/Syntax/Cpp.hs view

@@ -38,14 +38,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("C++","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("C++","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("C++","Normal") -> return ()       ("C++","DetectQt4Extensions") -> return ()       ("C++","QtClassMember") -> (popContext) >> pEndLine

Text/Highlighting/Kate/Syntax/Cs.hs view

@@ -38,14 +38,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("C#","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("C#","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("C#","Normal") -> return ()       ("C#","String") -> (popContext) >> pEndLine       ("C#","Member") -> (popContext) >> pEndLine

Text/Highlighting/Kate/Syntax/Css.hs view

@@ -38,14 +38,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("CSS","Base")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("CSS","Base")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("CSS","Base") -> return ()       ("CSS","FindRuleSets") -> return ()       ("CSS","FindValues") -> return ()

Text/Highlighting/Kate/Syntax/Curry.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Curry","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Curry","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Curry","Normal") -> return ()       ("Curry","Pragma") -> return ()       ("Curry","Multiline Comment") -> return ()

Text/Highlighting/Kate/Syntax/D.hs view

@@ -38,14 +38,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("D","normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("D","normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("D","normal") -> return ()       ("D","StartingLetter") -> (popContext) >> pEndLine       ("D","Properties") -> return ()

Text/Highlighting/Kate/Syntax/Diff.hs view

@@ -36,14 +36,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Diff","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Diff","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Diff","Normal") -> return ()       ("Diff","FindDiff") -> return ()       ("Diff","File") -> return ()

Text/Highlighting/Kate/Syntax/Djangotemplate.hs view

@@ -40,14 +40,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Django HTML Template","Start")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Django HTML Template","Start")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Django HTML Template","Start") -> return ()       ("Django HTML Template","In Block") -> return ()       ("Django HTML Template","FindTemplate") -> return ()

+ Text/Highlighting/Kate/Syntax/Dockerfile.hs view

@@ -0,0 +1,101 @@+{- This module was generated from data in the Kate syntax+   highlighting file dockerfile.xml, version 1.1, by James Turnbull (james@lovedthanlost.net) -}++module Text.Highlighting.Kate.Syntax.Dockerfile+          (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 = "Dockerfile"++-- | Filename extensions for this language.+syntaxExtensions :: String+syntaxExtensions = "Dockerfile"++-- | 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 = [("Dockerfile","normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}++pEndLine = do+  updateState $ \st -> st{ synStPrevNonspace = False }+  context <- currentContext+  contexts <- synStContexts `fmap` getState+  st <- getState+  if length contexts >= 2+    then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }+      ("Dockerfile","normal") -> return ()+      ("Dockerfile","Comment") -> (popContext) >> pEndLine+      ("Dockerfile","string\"") -> (popContext) >> pEndLine+      ("Dockerfile","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_keywords = Set.fromList $ words $ "FROM MAINTAINER ENV RUN ONBUILD COPY ADD VOLUME EXPOSE ENTRYPOINT CMD WORKDIR USER"+++parseRules ("Dockerfile","normal") =+  (((pDetectSpaces >>= withAttribute NormalTok))+   <|>+   ((pDetectChar False '#' >>= withAttribute CommentTok) >>~ pushContext ("Dockerfile","Comment"))+   <|>+   ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_keywords >>= withAttribute KeywordTok))+   <|>+   ((pDetectIdentifier >>= withAttribute NormalTok))+   <|>+   ((pDetectChar False '"' >>= withAttribute StringTok) >>~ pushContext ("Dockerfile","string\""))+   <|>+   ((pDetectChar False '\'' >>= withAttribute StringTok) >>~ pushContext ("Dockerfile","string'"))+   <|>+   (currentContext >>= \x -> guard (x == ("Dockerfile","normal")) >> pDefault >>= withAttribute NormalTok))++parseRules ("Dockerfile","Comment") =+  (((pLineContinue >>= withAttribute CommentTok))+   <|>+   (currentContext >>= \x -> guard (x == ("Dockerfile","Comment")) >> pDefault >>= withAttribute CommentTok))++parseRules ("Dockerfile","string\"") =+  (((pLineContinue >>= withAttribute NormalTok))+   <|>+   ((pDetectChar False '"' >>= withAttribute StringTok) >>~ (popContext))+   <|>+   (currentContext >>= \x -> guard (x == ("Dockerfile","string\"")) >> pDefault >>= withAttribute StringTok))++parseRules ("Dockerfile","string'") =+  (((pLineContinue >>= withAttribute StringTok))+   <|>+   ((pDetectChar False '\'' >>= withAttribute StringTok) >>~ (popContext))+   <|>+   (currentContext >>= \x -> guard (x == ("Dockerfile","string'")) >> pDefault >>= withAttribute StringTok))+++parseRules x = parseRules ("Dockerfile","normal") <|> fail ("Unknown context" ++ show x)

Text/Highlighting/Kate/Syntax/Dot.hs view

@@ -38,14 +38,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("dot","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("dot","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("dot","Normal") -> return ()       ("dot","DetectAll") -> return ()       ("dot","DetectComments") -> return ()

Text/Highlighting/Kate/Syntax/Doxygen.hs view

@@ -38,14 +38,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Doxygen","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Doxygen","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Doxygen","Normal") -> return ()       ("Doxygen","LineComment") -> (popContext) >> pEndLine       ("Doxygen","BlockComment") -> return ()

Text/Highlighting/Kate/Syntax/Doxygenlua.hs view

@@ -38,14 +38,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("DoxygenLua","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("DoxygenLua","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("DoxygenLua","Normal") -> return ()       ("DoxygenLua","LineComment") -> (popContext) >> pEndLine       ("DoxygenLua","BlockComment") -> return ()

Text/Highlighting/Kate/Syntax/Dtd.hs view

@@ -38,14 +38,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("DTD","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("DTD","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("DTD","Normal") -> return ()       ("DTD","Comment") -> return ()       ("DTD","PI") -> return ()

Text/Highlighting/Kate/Syntax/Eiffel.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Eiffel","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Eiffel","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Eiffel","Normal") -> return ()       ("Eiffel","Quoted String") -> (popContext) >> pEndLine       ("Eiffel","Documentation") -> (popContext) >> pEndLine

Text/Highlighting/Kate/Syntax/Email.hs view

@@ -36,14 +36,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Email","headder")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Email","headder")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Email","headder") -> return ()       _ -> return ()     else return ()

Text/Highlighting/Kate/Syntax/Erlang.hs view

@@ -38,14 +38,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Erlang","Normal Text")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Erlang","Normal Text")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Erlang","Normal Text") -> return ()       ("Erlang","isfunction") -> (popContext) >> pEndLine       ("Erlang","atomquote") -> (popContext) >> pEndLine

Text/Highlighting/Kate/Syntax/Fasm.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Intel x86 (FASM)","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Intel x86 (FASM)","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Intel x86 (FASM)","Normal") -> return ()       ("Intel x86 (FASM)","Comment") -> (popContext) >> pEndLine       ("Intel x86 (FASM)","Preprocessor") -> (popContext) >> pEndLine

Text/Highlighting/Kate/Syntax/Fortran.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Fortran","default")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Fortran","default")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Fortran","default") -> return ()       ("Fortran","find_preprocessor") -> return ()       ("Fortran","find_op_and_log") -> return ()

Text/Highlighting/Kate/Syntax/Fsharp.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("FSharp","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("FSharp","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("FSharp","Normal") -> return ()       ("FSharp","Singleline Comment") -> (popContext) >> pEndLine       ("FSharp","Multiline Comment") -> return ()

Text/Highlighting/Kate/Syntax/Gcc.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("GCCExtensions","DetectGccExtensions")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("GCCExtensions","DetectGccExtensions")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("GCCExtensions","DetectGccExtensions") -> return ()       ("GCCExtensions","GNUMacros") -> return ()       ("GCCExtensions","AttrArgs") -> (popContext) >> pEndLine

Text/Highlighting/Kate/Syntax/Glsl.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("GLSL","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("GLSL","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("GLSL","Normal") -> return ()       ("GLSL","Member") -> (popContext) >> pEndLine       ("GLSL","Commentar 1") -> (popContext) >> pEndLine

Text/Highlighting/Kate/Syntax/Gnuassembler.hs view

@@ -38,14 +38,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("GNU Assembler","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("GNU Assembler","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("GNU Assembler","Normal") -> return ()       ("GNU Assembler","Commentar 1") -> return ()       ("GNU Assembler","Commentar 2") -> (popContext) >> pEndLine

Text/Highlighting/Kate/Syntax/Go.hs view

@@ -38,14 +38,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Go","normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Go","normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Go","normal") -> return ()       ("Go","Commentar 1") -> (popContext) >> pEndLine       ("Go","Commentar 2") -> return ()

Text/Highlighting/Kate/Syntax/Haskell.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Haskell","code")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Haskell","code")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Haskell","code") -> return ()       ("Haskell","comment") -> (popContext) >> pEndLine       ("Haskell","comments") -> return ()

Text/Highlighting/Kate/Syntax/Haxe.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Haxe","normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Haxe","normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Haxe","normal") -> return ()       ("Haxe","ModuleName") -> return ()       ("Haxe","RawString") -> return ()

Text/Highlighting/Kate/Syntax/Html.hs view

@@ -39,14 +39,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("HTML","Start")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("HTML","Start")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("HTML","Start") -> return ()       ("HTML","FindHTML") -> return ()       ("HTML","FindEntityRefs") -> return ()

Text/Highlighting/Kate/Syntax/Ini.hs view

@@ -38,14 +38,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("INI Files","ini")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("INI Files","ini")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("INI Files","ini") -> return ()       ("INI Files","Value") -> (popContext) >> pEndLine       ("INI Files","Comment") -> (popContext) >> pEndLine

Text/Highlighting/Kate/Syntax/Isocpp.hs view

@@ -41,14 +41,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("ISO C++","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("ISO C++","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("ISO C++","Normal") -> return ()       ("ISO C++","Main") -> return ()       ("ISO C++","UDLOperator") -> (popContext) >> pEndLine

Text/Highlighting/Kate/Syntax/Java.hs view

@@ -38,14 +38,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Java","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Java","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Java","Normal") -> return ()       ("Java","InFunctionCall") -> return ()       ("Java","String") -> (popContext) >> pEndLine

Text/Highlighting/Kate/Syntax/Javadoc.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Javadoc","Start")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Javadoc","Start")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Javadoc","Start") -> return ()       ("Javadoc","FindJavadoc") -> return ()       ("Javadoc","JavadocFSar") -> return ()

Text/Highlighting/Kate/Syntax/Javascript.hs view

@@ -40,14 +40,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("JavaScript","Shebang")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("JavaScript","Shebang")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("JavaScript","Shebang") -> pushContext ("JavaScript","Normal") >> return ()       ("JavaScript","Normal") -> return ()       ("JavaScript","Object Member") -> (popContext) >> pEndLine

Text/Highlighting/Kate/Syntax/Json.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("JSON","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("JSON","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("JSON","Normal") -> return ()       ("JSON","Pair") -> return ()       ("JSON","String_Key") -> return ()

Text/Highlighting/Kate/Syntax/Jsp.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("JSP","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("JSP","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("JSP","Normal") -> return ()       ("JSP","Jsp Standard Directive") -> return ()       ("JSP","Jsp Xml Directive") -> return ()

Text/Highlighting/Kate/Syntax/Julia.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Julia","_normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Julia","_normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Julia","_normal") -> return ()       ("Julia","region_marker") -> (popContext) >> pEndLine       ("Julia","nested") -> return ()

Text/Highlighting/Kate/Syntax/Latex.hs view

@@ -38,14 +38,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("LaTeX","Normal Text")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("LaTeX","Normal Text")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("LaTeX","Normal Text") -> return ()       ("LaTeX","NoWeb") -> return ()       ("LaTeX","Sectioning") -> return ()

Text/Highlighting/Kate/Syntax/Lex.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Lex/Flex","Pre Start")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Lex/Flex","Pre Start")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Lex/Flex","Pre Start") -> return ()       ("Lex/Flex","Definitions") -> return ()       ("Lex/Flex","Rules") -> return ()

Text/Highlighting/Kate/Syntax/Lilypond.hs view

@@ -38,14 +38,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("LilyPond","lilypond")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("LilyPond","lilypond")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("LilyPond","lilypond") -> return ()       ("LilyPond","music") -> return ()       ("LilyPond","default") -> return ()

Text/Highlighting/Kate/Syntax/LiterateCurry.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Literate Curry","Text")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Literate Curry","Text")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Literate Curry","Text") -> return ()       ("Literate Curry","Code") -> (popContext) >> pEndLine       ("Literate Curry","normals") -> return ()

Text/Highlighting/Kate/Syntax/LiterateHaskell.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Literate Haskell","text")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Literate Haskell","text")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Literate Haskell","text") -> return ()       ("Literate Haskell","normal") -> (popContext) >> pEndLine       ("Literate Haskell","normals") -> return ()

Text/Highlighting/Kate/Syntax/Lua.hs view

@@ -38,14 +38,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Lua","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Lua","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Lua","Normal") -> return ()       ("Lua","Comment") -> (popContext) >> pEndLine       ("Lua","Block Comment") -> return ()

Text/Highlighting/Kate/Syntax/M4.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("GNU M4","Normal Text")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("GNU M4","Normal Text")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("GNU M4","Normal Text") -> return ()       ("GNU M4","inparenthesis") -> return ()       _ -> return ()

Text/Highlighting/Kate/Syntax/Makefile.hs view

@@ -39,14 +39,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Makefile","normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Makefile","normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Makefile","normal") -> return ()       ("Makefile","prereq") -> pushContext ("Makefile","rule") >> return ()       ("Makefile","rule") -> return ()

Text/Highlighting/Kate/Syntax/Mandoc.hs view

@@ -38,14 +38,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Troff Mandoc","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Troff Mandoc","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Troff Mandoc","Normal") -> return ()       ("Troff Mandoc","DetectDirective") -> (popContext) >> pEndLine       ("Troff Mandoc","Directive") -> (popContext) >> pEndLine

Text/Highlighting/Kate/Syntax/Markdown.hs view

@@ -36,14 +36,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Markdown","Normal Text")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Markdown","Normal Text")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Markdown","Normal Text") -> return ()       ("Markdown","blockquote") -> return ()       ("Markdown","bullet") -> return ()

Text/Highlighting/Kate/Syntax/Mathematica.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Mathematica","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Mathematica","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Mathematica","Normal") -> return ()       _ -> return ()     else return ()

Text/Highlighting/Kate/Syntax/Matlab.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Matlab","_normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Matlab","_normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Matlab","_normal") -> return ()       ("Matlab","_adjoint") -> (popContext) >> pEndLine       _ -> return ()

Text/Highlighting/Kate/Syntax/Maxima.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Maxima","Normal Text")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Maxima","Normal Text")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Maxima","Normal Text") -> (popContext) >> pEndLine       ("Maxima","String") -> return ()       ("Maxima","Comment") -> return ()

Text/Highlighting/Kate/Syntax/Mediawiki.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("MediaWiki","normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("MediaWiki","normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("MediaWiki","normal") -> return ()       ("MediaWiki","TableHeader") -> pushContext ("MediaWiki","TableContent") >> return ()       ("MediaWiki","TableContent") -> return ()

Text/Highlighting/Kate/Syntax/Metafont.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Metapost/Metafont","Normal Text")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Metapost/Metafont","Normal Text")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Metapost/Metafont","Normal Text") -> return ()       ("Metapost/Metafont","string") -> return ()       ("Metapost/Metafont","TeXMode") -> return ()

Text/Highlighting/Kate/Syntax/Mips.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("MIPS Assembler","normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("MIPS Assembler","normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("MIPS Assembler","normal") -> return ()       ("MIPS Assembler","string") -> return ()       _ -> return ()

Text/Highlighting/Kate/Syntax/Modelines.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Modelines","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Modelines","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Modelines","Normal") -> (popContext) >> pEndLine       ("Modelines","Modeline") -> (popContext) >> pEndLine       ("Modelines","Booleans") -> (popContext) >> pEndLine

Text/Highlighting/Kate/Syntax/Modula2.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Modula-2","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Modula-2","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Modula-2","Normal") -> return ()       ("Modula-2","String1") -> (popContext) >> pEndLine       ("Modula-2","String2") -> (popContext) >> pEndLine

Text/Highlighting/Kate/Syntax/Modula3.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Modula-3","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Modula-3","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Modula-3","Normal") -> return ()       ("Modula-3","String1") -> (popContext) >> pEndLine       ("Modula-3","Comment2") -> return ()

Text/Highlighting/Kate/Syntax/Monobasic.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("MonoBasic","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("MonoBasic","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("MonoBasic","Normal") -> return ()       ("MonoBasic","String") -> (popContext) >> pEndLine       ("MonoBasic","Comment") -> (popContext) >> pEndLine

Text/Highlighting/Kate/Syntax/Nasm.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Intel x86 (NASM)","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Intel x86 (NASM)","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Intel x86 (NASM)","Normal") -> return ()       ("Intel x86 (NASM)","Comment") -> (popContext) >> pEndLine       ("Intel x86 (NASM)","Preprocessor") -> (popContext) >> pEndLine

Text/Highlighting/Kate/Syntax/Noweb.hs view

@@ -38,14 +38,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("noweb","RawDocumentation")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("noweb","RawDocumentation")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("noweb","RawDocumentation") -> return ()       ("noweb","CodeQuote") -> return ()       ("noweb","CodeSection") -> return ()

Text/Highlighting/Kate/Syntax/Objectivec.hs view

@@ -38,14 +38,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Objective-C","Default")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Objective-C","Default")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Objective-C","Default") -> return ()       ("Objective-C","String") -> (popContext) >> pEndLine       ("Objective-C","SingleLineComment") -> (popContext) >> pEndLine

Text/Highlighting/Kate/Syntax/Objectivecpp.hs view

@@ -39,14 +39,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Objective-C++","Default")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Objective-C++","Default")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Objective-C++","Default") -> return ()       ("Objective-C++","String") -> (popContext) >> pEndLine       ("Objective-C++","SingleLineComment") -> (popContext) >> pEndLine

Text/Highlighting/Kate/Syntax/Ocaml.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Objective Caml","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Objective Caml","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Objective Caml","Normal") -> return ()       ("Objective Caml","Multiline Comment") -> return ()       ("Objective Caml","String Constant") -> return ()

Text/Highlighting/Kate/Syntax/Octave.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Octave","_normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Octave","_normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Octave","_normal") -> return ()       ("Octave","_adjoint") -> (popContext) >> pEndLine       _ -> return ()

Text/Highlighting/Kate/Syntax/Opencl.hs view

@@ -39,14 +39,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("OpenCL","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("OpenCL","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("OpenCL","Normal") -> return ()       ("OpenCL","String") -> (popContext) >> pEndLine       ("OpenCL","Region Marker") -> (popContext) >> pEndLine

Text/Highlighting/Kate/Syntax/Pascal.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Pascal","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Pascal","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Pascal","Normal") -> return ()       ("Pascal","CharNum") -> (popContext) >> pEndLine       ("Pascal","HexCharNum") -> (popContext) >> pEndLine

Text/Highlighting/Kate/Syntax/Perl.hs view

@@ -38,14 +38,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Perl","normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Perl","normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Perl","normal") -> return ()       ("Perl","find_quoted") -> return ()       ("Perl","find_qqx") -> return ()

Text/Highlighting/Kate/Syntax/Php.hs view

@@ -43,14 +43,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("PHP/PHP","start")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("PHP/PHP","start")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("PHP/PHP","start") -> return ()       ("PHP/PHP","phpsource") -> return ()       ("PHP/PHP","ternary") -> return ()

Text/Highlighting/Kate/Syntax/Pike.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Pike","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Pike","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Pike","Normal") -> return ()       ("Pike","String") -> (popContext) >> pEndLine       ("Pike","Line Comment") -> (popContext) >> pEndLine

Text/Highlighting/Kate/Syntax/Postscript.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("PostScript","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("PostScript","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("PostScript","Normal") -> return ()       ("PostScript","Comment") -> (popContext) >> pEndLine       ("PostScript","Header") -> (popContext) >> pEndLine

Text/Highlighting/Kate/Syntax/Prolog.hs view

@@ -38,14 +38,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Prolog","shebang")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Prolog","shebang")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Prolog","shebang") -> pushContext ("Prolog","clause") >> return ()       ("Prolog","syntax_error") -> return ()       ("Prolog","clause") -> return ()

Text/Highlighting/Kate/Syntax/Pure.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Pure","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Pure","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Pure","Normal") -> return ()       ("Pure","String") -> (popContext) >> pEndLine       ("Pure","Region Marker") -> (popContext) >> pEndLine

Text/Highlighting/Kate/Syntax/Python.hs view

@@ -40,14 +40,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Python","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Python","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Python","Normal") -> return ()       ("Python","#CheckForString") -> (popContext) >> pEndLine       ("Python","CheckForStringNext") -> (popContext) >> pEndLine

Text/Highlighting/Kate/Syntax/R.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("R Script","level0")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("R Script","level0")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("R Script","level0") -> return ()       ("R Script","ctx0") -> return ()       ("R Script","parenthesis") -> return ()

Text/Highlighting/Kate/Syntax/Relaxng.hs view

@@ -38,14 +38,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("RELAX NG","normalText")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("RELAX NG","normalText")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("RELAX NG","normalText") -> return ()       ("RELAX NG","detectEntRef") -> return ()       ("RELAX NG","tagname") -> return ()

Text/Highlighting/Kate/Syntax/Relaxngcompact.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("RelaxNG-Compact","Normal Text")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("RelaxNG-Compact","Normal Text")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("RelaxNG-Compact","Normal Text") -> return ()       ("RelaxNG-Compact","Comments") -> (popContext) >> pEndLine       ("RelaxNG-Compact","String") -> return ()

Text/Highlighting/Kate/Syntax/Rest.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("reStructuredText","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("reStructuredText","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("reStructuredText","Normal") -> return ()       ("reStructuredText","InlineMarkup") -> return ()       ("reStructuredText","Field") -> return ()

Text/Highlighting/Kate/Syntax/Rhtml.hs view

@@ -40,14 +40,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Ruby/Rails/RHTML","Start")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Ruby/Rails/RHTML","Start")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Ruby/Rails/RHTML","Start") -> return ()       ("Ruby/Rails/RHTML","FindHTML") -> return ()       ("Ruby/Rails/RHTML","FindEntityRefs") -> return ()

Text/Highlighting/Kate/Syntax/Roff.hs view

@@ -38,14 +38,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Roff","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Roff","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Roff","Normal") -> return ()       ("Roff","DetectComments") -> return ()       ("Roff","DetectOthers") -> return ()

Text/Highlighting/Kate/Syntax/Ruby.hs view

@@ -38,14 +38,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Ruby","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Ruby","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Ruby","Normal") -> return ()       ("Ruby","check_div_1") -> (popContext) >> pEndLine       ("Ruby","check_div_1_pop") -> (popContext >> popContext) >> pEndLine

Text/Highlighting/Kate/Syntax/Rust.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Rust","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Rust","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Rust","Normal") -> return ()       ("Rust","Attribute") -> return ()       ("Rust","Function") -> return ()

Text/Highlighting/Kate/Syntax/Scala.hs view

@@ -38,14 +38,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Scala","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Scala","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Scala","Normal") -> return ()       ("Scala","String") -> (popContext) >> pEndLine       ("Scala","Printf") -> (popContext) >> pEndLine

Text/Highlighting/Kate/Syntax/Scheme.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Scheme","Level0")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Scheme","Level0")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Scheme","Level0") -> return ()       ("Scheme","Default") -> return ()       ("Scheme","MultiLineComment") -> return ()

Text/Highlighting/Kate/Syntax/Sci.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("scilab","main")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("scilab","main")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("scilab","main") -> return ()       _ -> return ()     else return ()

Text/Highlighting/Kate/Syntax/Sed.hs view

@@ -36,14 +36,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("sed","BeginningOfLine")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("sed","BeginningOfLine")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("sed","BeginningOfLine") -> return ()       ("sed","FirstAddressRegex") -> pushContext ("sed","Error") >> return ()       ("sed","AfterFirstAddress") -> pushContext ("sed","BeginningOfLine") >> return ()

Text/Highlighting/Kate/Syntax/Sgml.hs view

@@ -36,14 +36,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("SGML","Normal Text")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("SGML","Normal Text")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("SGML","Normal Text") -> return ()       ("SGML","Attribute") -> return ()       ("SGML","Value") -> return ()

Text/Highlighting/Kate/Syntax/Sql.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("SQL","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("SQL","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("SQL","Normal") -> return ()       ("SQL","String literal") -> return ()       ("SQL","Singleline PL/SQL-style comment") -> (popContext) >> pEndLine

Text/Highlighting/Kate/Syntax/SqlMysql.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("SQL (MySQL)","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("SQL (MySQL)","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("SQL (MySQL)","Normal") -> return ()       ("SQL (MySQL)","String") -> return ()       ("SQL (MySQL)","String2") -> return ()

Text/Highlighting/Kate/Syntax/SqlPostgresql.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("SQL (PostgreSQL)","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("SQL (PostgreSQL)","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("SQL (PostgreSQL)","Normal") -> return ()       ("SQL (PostgreSQL)","CreateFunction") -> return ()       ("SQL (PostgreSQL)","FunctionBody") -> return ()

Text/Highlighting/Kate/Syntax/Tcl.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Tcl/Tk","Base")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Tcl/Tk","Base")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Tcl/Tk","Base") -> return ()       ("Tcl/Tk","String") -> return ()       ("Tcl/Tk","Comment") -> (popContext) >> pEndLine

Text/Highlighting/Kate/Syntax/Tcsh.hs view

@@ -38,14 +38,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Tcsh","Start")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Tcsh","Start")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Tcsh","Start") -> return ()       ("Tcsh","FindAll") -> return ()       ("Tcsh","FindMost") -> return ()

Text/Highlighting/Kate/Syntax/Texinfo.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Texinfo","Normal Text")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Texinfo","Normal Text")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Texinfo","Normal Text") -> return ()       ("Texinfo","singleLineComment") -> (popContext) >> pEndLine       ("Texinfo","multiLineComment") -> return ()

Text/Highlighting/Kate/Syntax/Verilog.hs view

@@ -38,14 +38,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Verilog","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Verilog","Normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Verilog","Normal") -> return ()       ("Verilog","String") -> (popContext) >> pEndLine       ("Verilog","Commentar 1") -> (popContext) >> pEndLine

Text/Highlighting/Kate/Syntax/Vhdl.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("VHDL","start")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("VHDL","start")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("VHDL","start") -> return ()       ("VHDL","package") -> return ()       ("VHDL","packagemain") -> return ()

Text/Highlighting/Kate/Syntax/Xml.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("XML","Start")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("XML","Start")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("XML","Start") -> return ()       ("XML","FindXML") -> return ()       ("XML","FindEntityRefs") -> return ()

Text/Highlighting/Kate/Syntax/Xorg.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("x.org Configuration","xorg")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("x.org Configuration","xorg")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("x.org Configuration","xorg") -> return ()       ("x.org Configuration","Section") -> return ()       ("x.org Configuration","Section Content") -> return ()

Text/Highlighting/Kate/Syntax/Xslt.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("xslt","normalText")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("xslt","normalText")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = False, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("xslt","normalText") -> return ()       ("xslt","CDATA") -> return ()       ("xslt","PI") -> return ()

Text/Highlighting/Kate/Syntax/Xul.hs view

@@ -38,14 +38,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("XUL","Start")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("XUL","Start")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("XUL","Start") -> return ()       ("XUL","FindXML") -> return ()       ("XUL","FindEntityRefs") -> return ()

Text/Highlighting/Kate/Syntax/Yacc.hs view

@@ -37,14 +37,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Yacc/Bison","Pre Start")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Yacc/Bison","Pre Start")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Yacc/Bison","Pre Start") -> return ()       ("Yacc/Bison","C Declarations") -> return ()       ("Yacc/Bison","Declarations") -> return ()

Text/Highlighting/Kate/Syntax/Yaml.hs view

@@ -38,14 +38,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("YAML","normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("YAML","normal")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("YAML","normal") -> return ()       ("YAML","dash") -> (popContext) >> pEndLine       ("YAML","header") -> (popContext) >> pEndLine

Text/Highlighting/Kate/Syntax/Zsh.hs view

@@ -38,14 +38,16 @@                 pEndLine   return result -startingState = SyntaxState {synStContexts = [("Zsh","Start")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}+startingState = SyntaxState {synStContexts = [("Zsh","Start")], synStLineNumber = 0, synStPrevChar = '\n', synStPrevNonspace = False, synStContinuation = False, synStCaseSensitive = True, synStKeywordCaseSensitive = True, synStCaptures = []}  pEndLine = do   updateState $ \st -> st{ synStPrevNonspace = False }   context <- currentContext   contexts <- synStContexts `fmap` getState+  st <- getState   if length contexts >= 2     then case context of+      _ | synStContinuation st -> updateState $ \st -> st{ synStContinuation = False }       ("Zsh","Start") -> return ()       ("Zsh","FindAll") -> return ()       ("Zsh","FindMost") -> return ()

Text/Highlighting/Kate/Types.hs view

@@ -29,6 +29,8 @@   , synStLineNumber           :: Int          -- ^ Number of current line   , synStPrevChar             :: Char         -- ^ Last character parsed   , synStPrevNonspace         :: Bool         -- ^ True if we've parsed a nonspace+  , synStContinuation         :: Bool         -- ^ True if last thing parsed is+                                              --   a LineContinue   , synStCaseSensitive        :: Bool         -- ^ Language is case-sensitive   , synStKeywordCaseSensitive :: Bool         -- ^ Keywords are case-sensitive   , synStCaptures             :: [String]     -- ^ List of regex captures from@@ -40,6 +42,7 @@     synStContexts = []   , synStLineNumber = 0   , synStPrevNonspace = False+  , synStContinuation = False   , synStPrevChar = '\n'   , synStCaseSensitive = True   , synStKeywordCaseSensitive = True

changelog view

@@ -1,3 +1,12 @@+highlighting-kate 0.5.11 (11 Nov 2014)++  * Fixed line continuations (#51).+    API change:  Added synStContinuation field to SyntaxState.++  * Added Dockerfile syntax (James Turnbull, #49).++  * Fixed 'prep' target in Makefile.+ highlighting-kate 0.5.10 (09 Nov 2014)    * Added support for Agda (Matthias C. M. Troffaes).

highlighting-kate.cabal view

@@ -1,5 +1,5 @@ Name:                highlighting-kate-Version:             0.5.10+Version:             0.5.11 Cabal-Version:       >= 1.10 Build-Type:          Simple Category:            Text@@ -141,6 +141,7 @@                      Text.Highlighting.Kate.Syntax.D                      Text.Highlighting.Kate.Syntax.Diff                      Text.Highlighting.Kate.Syntax.Djangotemplate+                     Text.Highlighting.Kate.Syntax.Dockerfile                      Text.Highlighting.Kate.Syntax.Dot                      Text.Highlighting.Kate.Syntax.Doxygen                      Text.Highlighting.Kate.Syntax.Doxygenlua

+ xml/dockerfile.xml view

@@ -0,0 +1,61 @@+<?xml version="1.0" encoding="UTF-8"?>+<!DOCTYPE language SYSTEM "language.dtd">+<!-- Dockerfile syntaxfile v1.0 by James Turnbull <james@lovedthanlost.net> -->+<language name="Dockerfile" section="Other" version="1.1" kateversion="3.4" extensions="Dockerfile" author="James Turnbull (james@lovedthanlost.net)" license="LGPLv2+">+  <highlighting>+    <list name="keywords">+      <item> FROM </item>+      <item> MAINTAINER </item>+      <item> ENV </item>+      <item> RUN </item>+      <item> ONBUILD </item>+      <item> COPY </item>+      <item> ADD </item>+      <item> VOLUME </item>+      <item> EXPOSE </item>+      <item> ENTRYPOINT </item>+      <item> CMD </item>+      <item> WORKDIR </item>+      <item> USER </item>+    </list>++    <contexts>+      <context name="normal" attribute="Normal" lineEndContext="#stay">+        <DetectSpaces/>+        <DetectChar attribute="Comment" context="Comment" char="#"/>+        <keyword attribute="Keyword"  context="#stay" String="keywords"/>+        <DetectIdentifier/>+        <DetectChar attribute="String" context="string&quot;" char="&quot;"/>+        <DetectChar attribute="String" context="string'" char="'"/>+      </context>++      <context attribute="Comment" lineEndContext="#pop" name="Comment">+        <LineContinue attribute="Comment" context="#stay" />+      </context>++      <context name="string&quot;" attribute="String" lineEndContext="#pop">+        <LineContinue attribute="Operator" context="#stay"/>+        <DetectChar attribute="String" context="#pop" char="&quot;"/>+      </context>++      <context name="string'" attribute="String" lineEndContext="#pop">+        <LineContinue attribute="String" context="#stay"/>+        <DetectChar attribute="String" context="#pop" char="'"/>+      </context>++    </contexts>+    <itemDatas>+      <itemData name="Normal"    defStyleNum="dsNormal" spellChecking="0"/>+      <itemData name="Keyword"   defStyleNum="dsKeyword" spellChecking="0"/>+      <itemData name="Comment"   defStyleNum="dsComment"/>+      <itemData name="String"    defStyleNum="dsString" spellChecking="0"/>+    </itemDatas>+  </highlighting>+  <general>+    <comments>+      <comment name = "singleLine" start = "#"/>+    </comments>+  </general>+</language>+<!-- kate: space-indent on; indent-width 2; replace-tabs on; -->+