diff --git a/Makefile b/Makefile
--- a/Makefile
+++ b/Makefile
@@ -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."
diff --git a/ParseSyntaxFiles.hs b/ParseSyntaxFiles.hs
--- a/ParseSyntaxFiles.hs
+++ b/ParseSyntaxFiles.hs
@@ -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)
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -32,6 +32,7 @@
 - D
 - Diff
 - Djangotemplate
+- Dockerfile
 - Dot
 - Doxygen
 - Dtd
diff --git a/Text/Highlighting/Kate/Common.hs b/Text/Highlighting/Kate/Common.hs
--- a/Text/Highlighting/Kate/Common.hs
+++ b/Text/Highlighting/Kate/Common.hs
@@ -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')
diff --git a/Text/Highlighting/Kate/Syntax.hs b/Text/Highlighting/Kate/Syntax.hs
--- a/Text/Highlighting/Kate/Syntax.hs
+++ b/Text/Highlighting/Kate/Syntax.hs
@@ -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
diff --git a/Text/Highlighting/Kate/Syntax/Abc.hs b/Text/Highlighting/Kate/Syntax/Abc.hs
--- a/Text/Highlighting/Kate/Syntax/Abc.hs
+++ b/Text/Highlighting/Kate/Syntax/Abc.hs
@@ -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
diff --git a/Text/Highlighting/Kate/Syntax/Actionscript.hs b/Text/Highlighting/Kate/Syntax/Actionscript.hs
--- a/Text/Highlighting/Kate/Syntax/Actionscript.hs
+++ b/Text/Highlighting/Kate/Syntax/Actionscript.hs
@@ -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
diff --git a/Text/Highlighting/Kate/Syntax/Ada.hs b/Text/Highlighting/Kate/Syntax/Ada.hs
--- a/Text/Highlighting/Kate/Syntax/Ada.hs
+++ b/Text/Highlighting/Kate/Syntax/Ada.hs
@@ -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
diff --git a/Text/Highlighting/Kate/Syntax/Agda.hs b/Text/Highlighting/Kate/Syntax/Agda.hs
--- a/Text/Highlighting/Kate/Syntax/Agda.hs
+++ b/Text/Highlighting/Kate/Syntax/Agda.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Alert.hs b/Text/Highlighting/Kate/Syntax/Alert.hs
--- a/Text/Highlighting/Kate/Syntax/Alert.hs
+++ b/Text/Highlighting/Kate/Syntax/Alert.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Alert_indent.hs b/Text/Highlighting/Kate/Syntax/Alert_indent.hs
--- a/Text/Highlighting/Kate/Syntax/Alert_indent.hs
+++ b/Text/Highlighting/Kate/Syntax/Alert_indent.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Apache.hs b/Text/Highlighting/Kate/Syntax/Apache.hs
--- a/Text/Highlighting/Kate/Syntax/Apache.hs
+++ b/Text/Highlighting/Kate/Syntax/Apache.hs
@@ -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
diff --git a/Text/Highlighting/Kate/Syntax/Asn1.hs b/Text/Highlighting/Kate/Syntax/Asn1.hs
--- a/Text/Highlighting/Kate/Syntax/Asn1.hs
+++ b/Text/Highlighting/Kate/Syntax/Asn1.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Asp.hs b/Text/Highlighting/Kate/Syntax/Asp.hs
--- a/Text/Highlighting/Kate/Syntax/Asp.hs
+++ b/Text/Highlighting/Kate/Syntax/Asp.hs
@@ -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
diff --git a/Text/Highlighting/Kate/Syntax/Awk.hs b/Text/Highlighting/Kate/Syntax/Awk.hs
--- a/Text/Highlighting/Kate/Syntax/Awk.hs
+++ b/Text/Highlighting/Kate/Syntax/Awk.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Bash.hs b/Text/Highlighting/Kate/Syntax/Bash.hs
--- a/Text/Highlighting/Kate/Syntax/Bash.hs
+++ b/Text/Highlighting/Kate/Syntax/Bash.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Bibtex.hs b/Text/Highlighting/Kate/Syntax/Bibtex.hs
--- a/Text/Highlighting/Kate/Syntax/Bibtex.hs
+++ b/Text/Highlighting/Kate/Syntax/Bibtex.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Boo.hs b/Text/Highlighting/Kate/Syntax/Boo.hs
--- a/Text/Highlighting/Kate/Syntax/Boo.hs
+++ b/Text/Highlighting/Kate/Syntax/Boo.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/C.hs b/Text/Highlighting/Kate/Syntax/C.hs
--- a/Text/Highlighting/Kate/Syntax/C.hs
+++ b/Text/Highlighting/Kate/Syntax/C.hs
@@ -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
diff --git a/Text/Highlighting/Kate/Syntax/Changelog.hs b/Text/Highlighting/Kate/Syntax/Changelog.hs
--- a/Text/Highlighting/Kate/Syntax/Changelog.hs
+++ b/Text/Highlighting/Kate/Syntax/Changelog.hs
@@ -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
diff --git a/Text/Highlighting/Kate/Syntax/Clojure.hs b/Text/Highlighting/Kate/Syntax/Clojure.hs
--- a/Text/Highlighting/Kate/Syntax/Clojure.hs
+++ b/Text/Highlighting/Kate/Syntax/Clojure.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Cmake.hs b/Text/Highlighting/Kate/Syntax/Cmake.hs
--- a/Text/Highlighting/Kate/Syntax/Cmake.hs
+++ b/Text/Highlighting/Kate/Syntax/Cmake.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Coffee.hs b/Text/Highlighting/Kate/Syntax/Coffee.hs
--- a/Text/Highlighting/Kate/Syntax/Coffee.hs
+++ b/Text/Highlighting/Kate/Syntax/Coffee.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Coldfusion.hs b/Text/Highlighting/Kate/Syntax/Coldfusion.hs
--- a/Text/Highlighting/Kate/Syntax/Coldfusion.hs
+++ b/Text/Highlighting/Kate/Syntax/Coldfusion.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Commonlisp.hs b/Text/Highlighting/Kate/Syntax/Commonlisp.hs
--- a/Text/Highlighting/Kate/Syntax/Commonlisp.hs
+++ b/Text/Highlighting/Kate/Syntax/Commonlisp.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Cpp.hs b/Text/Highlighting/Kate/Syntax/Cpp.hs
--- a/Text/Highlighting/Kate/Syntax/Cpp.hs
+++ b/Text/Highlighting/Kate/Syntax/Cpp.hs
@@ -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
diff --git a/Text/Highlighting/Kate/Syntax/Cs.hs b/Text/Highlighting/Kate/Syntax/Cs.hs
--- a/Text/Highlighting/Kate/Syntax/Cs.hs
+++ b/Text/Highlighting/Kate/Syntax/Cs.hs
@@ -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
diff --git a/Text/Highlighting/Kate/Syntax/Css.hs b/Text/Highlighting/Kate/Syntax/Css.hs
--- a/Text/Highlighting/Kate/Syntax/Css.hs
+++ b/Text/Highlighting/Kate/Syntax/Css.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Curry.hs b/Text/Highlighting/Kate/Syntax/Curry.hs
--- a/Text/Highlighting/Kate/Syntax/Curry.hs
+++ b/Text/Highlighting/Kate/Syntax/Curry.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/D.hs b/Text/Highlighting/Kate/Syntax/D.hs
--- a/Text/Highlighting/Kate/Syntax/D.hs
+++ b/Text/Highlighting/Kate/Syntax/D.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Diff.hs b/Text/Highlighting/Kate/Syntax/Diff.hs
--- a/Text/Highlighting/Kate/Syntax/Diff.hs
+++ b/Text/Highlighting/Kate/Syntax/Diff.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Djangotemplate.hs b/Text/Highlighting/Kate/Syntax/Djangotemplate.hs
--- a/Text/Highlighting/Kate/Syntax/Djangotemplate.hs
+++ b/Text/Highlighting/Kate/Syntax/Djangotemplate.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Dockerfile.hs b/Text/Highlighting/Kate/Syntax/Dockerfile.hs
new file mode 100644
--- /dev/null
+++ b/Text/Highlighting/Kate/Syntax/Dockerfile.hs
@@ -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)
diff --git a/Text/Highlighting/Kate/Syntax/Dot.hs b/Text/Highlighting/Kate/Syntax/Dot.hs
--- a/Text/Highlighting/Kate/Syntax/Dot.hs
+++ b/Text/Highlighting/Kate/Syntax/Dot.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Doxygen.hs b/Text/Highlighting/Kate/Syntax/Doxygen.hs
--- a/Text/Highlighting/Kate/Syntax/Doxygen.hs
+++ b/Text/Highlighting/Kate/Syntax/Doxygen.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Doxygenlua.hs b/Text/Highlighting/Kate/Syntax/Doxygenlua.hs
--- a/Text/Highlighting/Kate/Syntax/Doxygenlua.hs
+++ b/Text/Highlighting/Kate/Syntax/Doxygenlua.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Dtd.hs b/Text/Highlighting/Kate/Syntax/Dtd.hs
--- a/Text/Highlighting/Kate/Syntax/Dtd.hs
+++ b/Text/Highlighting/Kate/Syntax/Dtd.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Eiffel.hs b/Text/Highlighting/Kate/Syntax/Eiffel.hs
--- a/Text/Highlighting/Kate/Syntax/Eiffel.hs
+++ b/Text/Highlighting/Kate/Syntax/Eiffel.hs
@@ -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
diff --git a/Text/Highlighting/Kate/Syntax/Email.hs b/Text/Highlighting/Kate/Syntax/Email.hs
--- a/Text/Highlighting/Kate/Syntax/Email.hs
+++ b/Text/Highlighting/Kate/Syntax/Email.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Erlang.hs b/Text/Highlighting/Kate/Syntax/Erlang.hs
--- a/Text/Highlighting/Kate/Syntax/Erlang.hs
+++ b/Text/Highlighting/Kate/Syntax/Erlang.hs
@@ -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
diff --git a/Text/Highlighting/Kate/Syntax/Fasm.hs b/Text/Highlighting/Kate/Syntax/Fasm.hs
--- a/Text/Highlighting/Kate/Syntax/Fasm.hs
+++ b/Text/Highlighting/Kate/Syntax/Fasm.hs
@@ -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
diff --git a/Text/Highlighting/Kate/Syntax/Fortran.hs b/Text/Highlighting/Kate/Syntax/Fortran.hs
--- a/Text/Highlighting/Kate/Syntax/Fortran.hs
+++ b/Text/Highlighting/Kate/Syntax/Fortran.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Fsharp.hs b/Text/Highlighting/Kate/Syntax/Fsharp.hs
--- a/Text/Highlighting/Kate/Syntax/Fsharp.hs
+++ b/Text/Highlighting/Kate/Syntax/Fsharp.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Gcc.hs b/Text/Highlighting/Kate/Syntax/Gcc.hs
--- a/Text/Highlighting/Kate/Syntax/Gcc.hs
+++ b/Text/Highlighting/Kate/Syntax/Gcc.hs
@@ -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
diff --git a/Text/Highlighting/Kate/Syntax/Glsl.hs b/Text/Highlighting/Kate/Syntax/Glsl.hs
--- a/Text/Highlighting/Kate/Syntax/Glsl.hs
+++ b/Text/Highlighting/Kate/Syntax/Glsl.hs
@@ -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
diff --git a/Text/Highlighting/Kate/Syntax/Gnuassembler.hs b/Text/Highlighting/Kate/Syntax/Gnuassembler.hs
--- a/Text/Highlighting/Kate/Syntax/Gnuassembler.hs
+++ b/Text/Highlighting/Kate/Syntax/Gnuassembler.hs
@@ -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
diff --git a/Text/Highlighting/Kate/Syntax/Go.hs b/Text/Highlighting/Kate/Syntax/Go.hs
--- a/Text/Highlighting/Kate/Syntax/Go.hs
+++ b/Text/Highlighting/Kate/Syntax/Go.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Haskell.hs b/Text/Highlighting/Kate/Syntax/Haskell.hs
--- a/Text/Highlighting/Kate/Syntax/Haskell.hs
+++ b/Text/Highlighting/Kate/Syntax/Haskell.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Haxe.hs b/Text/Highlighting/Kate/Syntax/Haxe.hs
--- a/Text/Highlighting/Kate/Syntax/Haxe.hs
+++ b/Text/Highlighting/Kate/Syntax/Haxe.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Html.hs b/Text/Highlighting/Kate/Syntax/Html.hs
--- a/Text/Highlighting/Kate/Syntax/Html.hs
+++ b/Text/Highlighting/Kate/Syntax/Html.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Ini.hs b/Text/Highlighting/Kate/Syntax/Ini.hs
--- a/Text/Highlighting/Kate/Syntax/Ini.hs
+++ b/Text/Highlighting/Kate/Syntax/Ini.hs
@@ -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
diff --git a/Text/Highlighting/Kate/Syntax/Isocpp.hs b/Text/Highlighting/Kate/Syntax/Isocpp.hs
--- a/Text/Highlighting/Kate/Syntax/Isocpp.hs
+++ b/Text/Highlighting/Kate/Syntax/Isocpp.hs
@@ -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
diff --git a/Text/Highlighting/Kate/Syntax/Java.hs b/Text/Highlighting/Kate/Syntax/Java.hs
--- a/Text/Highlighting/Kate/Syntax/Java.hs
+++ b/Text/Highlighting/Kate/Syntax/Java.hs
@@ -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
diff --git a/Text/Highlighting/Kate/Syntax/Javadoc.hs b/Text/Highlighting/Kate/Syntax/Javadoc.hs
--- a/Text/Highlighting/Kate/Syntax/Javadoc.hs
+++ b/Text/Highlighting/Kate/Syntax/Javadoc.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Javascript.hs b/Text/Highlighting/Kate/Syntax/Javascript.hs
--- a/Text/Highlighting/Kate/Syntax/Javascript.hs
+++ b/Text/Highlighting/Kate/Syntax/Javascript.hs
@@ -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
diff --git a/Text/Highlighting/Kate/Syntax/Json.hs b/Text/Highlighting/Kate/Syntax/Json.hs
--- a/Text/Highlighting/Kate/Syntax/Json.hs
+++ b/Text/Highlighting/Kate/Syntax/Json.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Jsp.hs b/Text/Highlighting/Kate/Syntax/Jsp.hs
--- a/Text/Highlighting/Kate/Syntax/Jsp.hs
+++ b/Text/Highlighting/Kate/Syntax/Jsp.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Julia.hs b/Text/Highlighting/Kate/Syntax/Julia.hs
--- a/Text/Highlighting/Kate/Syntax/Julia.hs
+++ b/Text/Highlighting/Kate/Syntax/Julia.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Latex.hs b/Text/Highlighting/Kate/Syntax/Latex.hs
--- a/Text/Highlighting/Kate/Syntax/Latex.hs
+++ b/Text/Highlighting/Kate/Syntax/Latex.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Lex.hs b/Text/Highlighting/Kate/Syntax/Lex.hs
--- a/Text/Highlighting/Kate/Syntax/Lex.hs
+++ b/Text/Highlighting/Kate/Syntax/Lex.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Lilypond.hs b/Text/Highlighting/Kate/Syntax/Lilypond.hs
--- a/Text/Highlighting/Kate/Syntax/Lilypond.hs
+++ b/Text/Highlighting/Kate/Syntax/Lilypond.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/LiterateCurry.hs b/Text/Highlighting/Kate/Syntax/LiterateCurry.hs
--- a/Text/Highlighting/Kate/Syntax/LiterateCurry.hs
+++ b/Text/Highlighting/Kate/Syntax/LiterateCurry.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/LiterateHaskell.hs b/Text/Highlighting/Kate/Syntax/LiterateHaskell.hs
--- a/Text/Highlighting/Kate/Syntax/LiterateHaskell.hs
+++ b/Text/Highlighting/Kate/Syntax/LiterateHaskell.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Lua.hs b/Text/Highlighting/Kate/Syntax/Lua.hs
--- a/Text/Highlighting/Kate/Syntax/Lua.hs
+++ b/Text/Highlighting/Kate/Syntax/Lua.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/M4.hs b/Text/Highlighting/Kate/Syntax/M4.hs
--- a/Text/Highlighting/Kate/Syntax/M4.hs
+++ b/Text/Highlighting/Kate/Syntax/M4.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Makefile.hs b/Text/Highlighting/Kate/Syntax/Makefile.hs
--- a/Text/Highlighting/Kate/Syntax/Makefile.hs
+++ b/Text/Highlighting/Kate/Syntax/Makefile.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Mandoc.hs b/Text/Highlighting/Kate/Syntax/Mandoc.hs
--- a/Text/Highlighting/Kate/Syntax/Mandoc.hs
+++ b/Text/Highlighting/Kate/Syntax/Mandoc.hs
@@ -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
diff --git a/Text/Highlighting/Kate/Syntax/Markdown.hs b/Text/Highlighting/Kate/Syntax/Markdown.hs
--- a/Text/Highlighting/Kate/Syntax/Markdown.hs
+++ b/Text/Highlighting/Kate/Syntax/Markdown.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Mathematica.hs b/Text/Highlighting/Kate/Syntax/Mathematica.hs
--- a/Text/Highlighting/Kate/Syntax/Mathematica.hs
+++ b/Text/Highlighting/Kate/Syntax/Mathematica.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Matlab.hs b/Text/Highlighting/Kate/Syntax/Matlab.hs
--- a/Text/Highlighting/Kate/Syntax/Matlab.hs
+++ b/Text/Highlighting/Kate/Syntax/Matlab.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Maxima.hs b/Text/Highlighting/Kate/Syntax/Maxima.hs
--- a/Text/Highlighting/Kate/Syntax/Maxima.hs
+++ b/Text/Highlighting/Kate/Syntax/Maxima.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Mediawiki.hs b/Text/Highlighting/Kate/Syntax/Mediawiki.hs
--- a/Text/Highlighting/Kate/Syntax/Mediawiki.hs
+++ b/Text/Highlighting/Kate/Syntax/Mediawiki.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Metafont.hs b/Text/Highlighting/Kate/Syntax/Metafont.hs
--- a/Text/Highlighting/Kate/Syntax/Metafont.hs
+++ b/Text/Highlighting/Kate/Syntax/Metafont.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Mips.hs b/Text/Highlighting/Kate/Syntax/Mips.hs
--- a/Text/Highlighting/Kate/Syntax/Mips.hs
+++ b/Text/Highlighting/Kate/Syntax/Mips.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Modelines.hs b/Text/Highlighting/Kate/Syntax/Modelines.hs
--- a/Text/Highlighting/Kate/Syntax/Modelines.hs
+++ b/Text/Highlighting/Kate/Syntax/Modelines.hs
@@ -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
diff --git a/Text/Highlighting/Kate/Syntax/Modula2.hs b/Text/Highlighting/Kate/Syntax/Modula2.hs
--- a/Text/Highlighting/Kate/Syntax/Modula2.hs
+++ b/Text/Highlighting/Kate/Syntax/Modula2.hs
@@ -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
diff --git a/Text/Highlighting/Kate/Syntax/Modula3.hs b/Text/Highlighting/Kate/Syntax/Modula3.hs
--- a/Text/Highlighting/Kate/Syntax/Modula3.hs
+++ b/Text/Highlighting/Kate/Syntax/Modula3.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Monobasic.hs b/Text/Highlighting/Kate/Syntax/Monobasic.hs
--- a/Text/Highlighting/Kate/Syntax/Monobasic.hs
+++ b/Text/Highlighting/Kate/Syntax/Monobasic.hs
@@ -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
diff --git a/Text/Highlighting/Kate/Syntax/Nasm.hs b/Text/Highlighting/Kate/Syntax/Nasm.hs
--- a/Text/Highlighting/Kate/Syntax/Nasm.hs
+++ b/Text/Highlighting/Kate/Syntax/Nasm.hs
@@ -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
diff --git a/Text/Highlighting/Kate/Syntax/Noweb.hs b/Text/Highlighting/Kate/Syntax/Noweb.hs
--- a/Text/Highlighting/Kate/Syntax/Noweb.hs
+++ b/Text/Highlighting/Kate/Syntax/Noweb.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Objectivec.hs b/Text/Highlighting/Kate/Syntax/Objectivec.hs
--- a/Text/Highlighting/Kate/Syntax/Objectivec.hs
+++ b/Text/Highlighting/Kate/Syntax/Objectivec.hs
@@ -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
diff --git a/Text/Highlighting/Kate/Syntax/Objectivecpp.hs b/Text/Highlighting/Kate/Syntax/Objectivecpp.hs
--- a/Text/Highlighting/Kate/Syntax/Objectivecpp.hs
+++ b/Text/Highlighting/Kate/Syntax/Objectivecpp.hs
@@ -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
diff --git a/Text/Highlighting/Kate/Syntax/Ocaml.hs b/Text/Highlighting/Kate/Syntax/Ocaml.hs
--- a/Text/Highlighting/Kate/Syntax/Ocaml.hs
+++ b/Text/Highlighting/Kate/Syntax/Ocaml.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Octave.hs b/Text/Highlighting/Kate/Syntax/Octave.hs
--- a/Text/Highlighting/Kate/Syntax/Octave.hs
+++ b/Text/Highlighting/Kate/Syntax/Octave.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Opencl.hs b/Text/Highlighting/Kate/Syntax/Opencl.hs
--- a/Text/Highlighting/Kate/Syntax/Opencl.hs
+++ b/Text/Highlighting/Kate/Syntax/Opencl.hs
@@ -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
diff --git a/Text/Highlighting/Kate/Syntax/Pascal.hs b/Text/Highlighting/Kate/Syntax/Pascal.hs
--- a/Text/Highlighting/Kate/Syntax/Pascal.hs
+++ b/Text/Highlighting/Kate/Syntax/Pascal.hs
@@ -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
diff --git a/Text/Highlighting/Kate/Syntax/Perl.hs b/Text/Highlighting/Kate/Syntax/Perl.hs
--- a/Text/Highlighting/Kate/Syntax/Perl.hs
+++ b/Text/Highlighting/Kate/Syntax/Perl.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Php.hs b/Text/Highlighting/Kate/Syntax/Php.hs
--- a/Text/Highlighting/Kate/Syntax/Php.hs
+++ b/Text/Highlighting/Kate/Syntax/Php.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Pike.hs b/Text/Highlighting/Kate/Syntax/Pike.hs
--- a/Text/Highlighting/Kate/Syntax/Pike.hs
+++ b/Text/Highlighting/Kate/Syntax/Pike.hs
@@ -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
diff --git a/Text/Highlighting/Kate/Syntax/Postscript.hs b/Text/Highlighting/Kate/Syntax/Postscript.hs
--- a/Text/Highlighting/Kate/Syntax/Postscript.hs
+++ b/Text/Highlighting/Kate/Syntax/Postscript.hs
@@ -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
diff --git a/Text/Highlighting/Kate/Syntax/Prolog.hs b/Text/Highlighting/Kate/Syntax/Prolog.hs
--- a/Text/Highlighting/Kate/Syntax/Prolog.hs
+++ b/Text/Highlighting/Kate/Syntax/Prolog.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Pure.hs b/Text/Highlighting/Kate/Syntax/Pure.hs
--- a/Text/Highlighting/Kate/Syntax/Pure.hs
+++ b/Text/Highlighting/Kate/Syntax/Pure.hs
@@ -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
diff --git a/Text/Highlighting/Kate/Syntax/Python.hs b/Text/Highlighting/Kate/Syntax/Python.hs
--- a/Text/Highlighting/Kate/Syntax/Python.hs
+++ b/Text/Highlighting/Kate/Syntax/Python.hs
@@ -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
diff --git a/Text/Highlighting/Kate/Syntax/R.hs b/Text/Highlighting/Kate/Syntax/R.hs
--- a/Text/Highlighting/Kate/Syntax/R.hs
+++ b/Text/Highlighting/Kate/Syntax/R.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Relaxng.hs b/Text/Highlighting/Kate/Syntax/Relaxng.hs
--- a/Text/Highlighting/Kate/Syntax/Relaxng.hs
+++ b/Text/Highlighting/Kate/Syntax/Relaxng.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Relaxngcompact.hs b/Text/Highlighting/Kate/Syntax/Relaxngcompact.hs
--- a/Text/Highlighting/Kate/Syntax/Relaxngcompact.hs
+++ b/Text/Highlighting/Kate/Syntax/Relaxngcompact.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Rest.hs b/Text/Highlighting/Kate/Syntax/Rest.hs
--- a/Text/Highlighting/Kate/Syntax/Rest.hs
+++ b/Text/Highlighting/Kate/Syntax/Rest.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Rhtml.hs b/Text/Highlighting/Kate/Syntax/Rhtml.hs
--- a/Text/Highlighting/Kate/Syntax/Rhtml.hs
+++ b/Text/Highlighting/Kate/Syntax/Rhtml.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Roff.hs b/Text/Highlighting/Kate/Syntax/Roff.hs
--- a/Text/Highlighting/Kate/Syntax/Roff.hs
+++ b/Text/Highlighting/Kate/Syntax/Roff.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Ruby.hs b/Text/Highlighting/Kate/Syntax/Ruby.hs
--- a/Text/Highlighting/Kate/Syntax/Ruby.hs
+++ b/Text/Highlighting/Kate/Syntax/Ruby.hs
@@ -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
diff --git a/Text/Highlighting/Kate/Syntax/Rust.hs b/Text/Highlighting/Kate/Syntax/Rust.hs
--- a/Text/Highlighting/Kate/Syntax/Rust.hs
+++ b/Text/Highlighting/Kate/Syntax/Rust.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Scala.hs b/Text/Highlighting/Kate/Syntax/Scala.hs
--- a/Text/Highlighting/Kate/Syntax/Scala.hs
+++ b/Text/Highlighting/Kate/Syntax/Scala.hs
@@ -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
diff --git a/Text/Highlighting/Kate/Syntax/Scheme.hs b/Text/Highlighting/Kate/Syntax/Scheme.hs
--- a/Text/Highlighting/Kate/Syntax/Scheme.hs
+++ b/Text/Highlighting/Kate/Syntax/Scheme.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Sci.hs b/Text/Highlighting/Kate/Syntax/Sci.hs
--- a/Text/Highlighting/Kate/Syntax/Sci.hs
+++ b/Text/Highlighting/Kate/Syntax/Sci.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Sed.hs b/Text/Highlighting/Kate/Syntax/Sed.hs
--- a/Text/Highlighting/Kate/Syntax/Sed.hs
+++ b/Text/Highlighting/Kate/Syntax/Sed.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Sgml.hs b/Text/Highlighting/Kate/Syntax/Sgml.hs
--- a/Text/Highlighting/Kate/Syntax/Sgml.hs
+++ b/Text/Highlighting/Kate/Syntax/Sgml.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Sql.hs b/Text/Highlighting/Kate/Syntax/Sql.hs
--- a/Text/Highlighting/Kate/Syntax/Sql.hs
+++ b/Text/Highlighting/Kate/Syntax/Sql.hs
@@ -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
diff --git a/Text/Highlighting/Kate/Syntax/SqlMysql.hs b/Text/Highlighting/Kate/Syntax/SqlMysql.hs
--- a/Text/Highlighting/Kate/Syntax/SqlMysql.hs
+++ b/Text/Highlighting/Kate/Syntax/SqlMysql.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/SqlPostgresql.hs b/Text/Highlighting/Kate/Syntax/SqlPostgresql.hs
--- a/Text/Highlighting/Kate/Syntax/SqlPostgresql.hs
+++ b/Text/Highlighting/Kate/Syntax/SqlPostgresql.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Tcl.hs b/Text/Highlighting/Kate/Syntax/Tcl.hs
--- a/Text/Highlighting/Kate/Syntax/Tcl.hs
+++ b/Text/Highlighting/Kate/Syntax/Tcl.hs
@@ -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
diff --git a/Text/Highlighting/Kate/Syntax/Tcsh.hs b/Text/Highlighting/Kate/Syntax/Tcsh.hs
--- a/Text/Highlighting/Kate/Syntax/Tcsh.hs
+++ b/Text/Highlighting/Kate/Syntax/Tcsh.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Texinfo.hs b/Text/Highlighting/Kate/Syntax/Texinfo.hs
--- a/Text/Highlighting/Kate/Syntax/Texinfo.hs
+++ b/Text/Highlighting/Kate/Syntax/Texinfo.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Verilog.hs b/Text/Highlighting/Kate/Syntax/Verilog.hs
--- a/Text/Highlighting/Kate/Syntax/Verilog.hs
+++ b/Text/Highlighting/Kate/Syntax/Verilog.hs
@@ -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
diff --git a/Text/Highlighting/Kate/Syntax/Vhdl.hs b/Text/Highlighting/Kate/Syntax/Vhdl.hs
--- a/Text/Highlighting/Kate/Syntax/Vhdl.hs
+++ b/Text/Highlighting/Kate/Syntax/Vhdl.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Xml.hs b/Text/Highlighting/Kate/Syntax/Xml.hs
--- a/Text/Highlighting/Kate/Syntax/Xml.hs
+++ b/Text/Highlighting/Kate/Syntax/Xml.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Xorg.hs b/Text/Highlighting/Kate/Syntax/Xorg.hs
--- a/Text/Highlighting/Kate/Syntax/Xorg.hs
+++ b/Text/Highlighting/Kate/Syntax/Xorg.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Xslt.hs b/Text/Highlighting/Kate/Syntax/Xslt.hs
--- a/Text/Highlighting/Kate/Syntax/Xslt.hs
+++ b/Text/Highlighting/Kate/Syntax/Xslt.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Xul.hs b/Text/Highlighting/Kate/Syntax/Xul.hs
--- a/Text/Highlighting/Kate/Syntax/Xul.hs
+++ b/Text/Highlighting/Kate/Syntax/Xul.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Yacc.hs b/Text/Highlighting/Kate/Syntax/Yacc.hs
--- a/Text/Highlighting/Kate/Syntax/Yacc.hs
+++ b/Text/Highlighting/Kate/Syntax/Yacc.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Syntax/Yaml.hs b/Text/Highlighting/Kate/Syntax/Yaml.hs
--- a/Text/Highlighting/Kate/Syntax/Yaml.hs
+++ b/Text/Highlighting/Kate/Syntax/Yaml.hs
@@ -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
diff --git a/Text/Highlighting/Kate/Syntax/Zsh.hs b/Text/Highlighting/Kate/Syntax/Zsh.hs
--- a/Text/Highlighting/Kate/Syntax/Zsh.hs
+++ b/Text/Highlighting/Kate/Syntax/Zsh.hs
@@ -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 ()
diff --git a/Text/Highlighting/Kate/Types.hs b/Text/Highlighting/Kate/Types.hs
--- a/Text/Highlighting/Kate/Types.hs
+++ b/Text/Highlighting/Kate/Types.hs
@@ -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
diff --git a/changelog b/changelog
--- a/changelog
+++ b/changelog
@@ -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).
diff --git a/highlighting-kate.cabal b/highlighting-kate.cabal
--- a/highlighting-kate.cabal
+++ b/highlighting-kate.cabal
@@ -1,5 +1,5 @@
 Name:                highlighting-kate
-Version:             0.5.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
diff --git a/xml/dockerfile.xml b/xml/dockerfile.xml
new file mode 100644
--- /dev/null
+++ b/xml/dockerfile.xml
@@ -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; -->
+