Hello community, here is the log from the commit of package highlighting-kate for openSUSE:Factory checked in at 2016-03-26 15:26:02 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/highlighting-kate (Old) and /work/SRC/openSUSE:Factory/.highlighting-kate.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "highlighting-kate" Changes: -------- --- /work/SRC/openSUSE:Factory/highlighting-kate/highlighting-kate.changes 2015-12-23 08:49:16.000000000 +0100 +++ /work/SRC/openSUSE:Factory/.highlighting-kate.new/highlighting-kate.changes 2016-03-26 15:26:07.000000000 +0100 @@ -1,0 +2,9 @@ +Sun Mar 20 10:49:55 UTC 2016 - mimi...@gmail.com + +- update to 0.6.2 +- drop add-rpmspec-syntax.patch -- need rework +* Added support for WordDetect. +* Added hamlet. +* Added elixir (supernullset). + +------------------------------------------------------------------- Old: ---- add-rpmspec-syntax.patch highlighting-kate-0.6.1.tar.gz New: ---- highlighting-kate-0.6.2.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ highlighting-kate.spec ++++++ --- /var/tmp/diff_new_pack.O12dd5/_old 2016-03-26 15:26:08.000000000 +0100 +++ /var/tmp/diff_new_pack.O12dd5/_new 2016-03-26 15:26:08.000000000 +0100 @@ -21,7 +21,7 @@ %bcond_with tests Name: highlighting-kate -Version: 0.6.1 +Version: 0.6.2 Release: 0 Summary: Syntax highlighting License: GPL-2.0 @@ -29,9 +29,6 @@ Url: https://hackage.haskell.org/package/%{name} Source0: https://hackage.haskell.org/package/%{name}-%{version}/%{name}-%{version}.tar.gz -# temporary disabled .. need rebase/rework -# PATCH-FEATURE-UPSTREAM add-rpmspec-syntax.patch sbahl...@suse.com -Patch1: add-rpmspec-syntax.patch BuildRoot: %{_tmppath}/%{name}-%{version}-build @@ -83,7 +80,6 @@ %prep %setup -q -%patch1 -p2 %build %define cabal_configure_options -f'executable' ++++++ highlighting-kate-0.6.1.tar.gz -> highlighting-kate-0.6.2.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/highlighting-kate-0.6.1/ParseSyntaxFiles.hs new/highlighting-kate-0.6.2/ParseSyntaxFiles.hs --- old/highlighting-kate-0.6.1/ParseSyntaxFiles.hs 2015-12-12 21:42:37.000000000 +0100 +++ new/highlighting-kate-0.6.2/ParseSyntaxFiles.hs 2016-03-18 02:40:36.000000000 +0100 @@ -333,6 +333,14 @@ "RegExpr" -> if parserDynamic parser then "pRegExprDynamic " ++ show (parserString parser) else "pRegExpr " ++ compiledRegexName (parserString parser) + "WordDetect" -> if parserDynamic parser + then "pRegExprDynamic " ++ wordRe + else "pRegExpr (compileRegex " ++ show caseSensitive ++ " " ++ show wordRe ++ ")" + where wordRe = "\\b" ++ concatMap esc (parserString parser) ++ "\\b" + esc c = if c `elem` "[]{}^$\\-*.+?" + then ['\\',c] + else [c] + caseSensitive = synCaseSensitive syntax "keyword" -> "pKeyword " ++ show (keywordDelims $ synKeywordAttr syntax) ++ " " ++ list where list = case lookup string (synLists syntax) of Just _ -> listName string diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/highlighting-kate-0.6.1/README.md new/highlighting-kate-0.6.2/README.md --- old/highlighting-kate-0.6.1/README.md 2015-12-12 21:42:37.000000000 +0100 +++ new/highlighting-kate-0.6.2/README.md 2016-03-18 02:40:36.000000000 +0100 @@ -7,119 +7,19 @@ It can produce both HTML and LaTeX output. Currently, the following languages/formats are supported: -- Abc -- Actionscript -- Ada -- Agda -- Apache -- Asn1 -- Asp -- Awk -- Bash -- Bibtex -- Boo -- C -- Changelog -- Clojure -- Cmake -- Coffeescript -- Coldfusion -- Commonlisp -- Cpp -- Cs -- Css -- Curry -- D -- Diff -- Djangotemplate -- Dockerfile -- Dot -- Doxygen -- Dtd -- Eiffel -- Email -- Erlang -- Fasm -- Fortran -- Fsharp -- Gcc -- Glsl -- Gnuassembler -- Go -- Haskell -- Haxe -- Html -- Idris -- Ini -- Isocpp -- Java -- Javadoc -- Javascript -- Json -- Jsp -- Julia -- Latex -- Lex -- Lilypond -- LiterateCurry -- LiterateHaskell -- Lua -- M4 -- Makefile -- Mandoc -- Markdown -- Mathematica -- Matlab -- Maxima -- Mediawiki -- Metafont -- Mips -- 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 +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 Elixir Email Erlang Fasm Fortran +Fsharp Gcc Glsl Gnuassembler Go Hamlet Haskell Haxe Html Idris +Ini Isocpp Java Javadoc Javascript Json Jsp Julia Kotlin Latex +Lex Lilypond LiterateCurry LiterateHaskell Llvm 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 To install, use the cabal tool: diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/highlighting-kate-0.6.1/Text/Highlighting/Kate/Syntax/Elixir.hs new/highlighting-kate-0.6.2/Text/Highlighting/Kate/Syntax/Elixir.hs --- old/highlighting-kate-0.6.1/Text/Highlighting/Kate/Syntax/Elixir.hs 1970-01-01 01:00:00.000000000 +0100 +++ new/highlighting-kate-0.6.2/Text/Highlighting/Kate/Syntax/Elixir.hs 2016-03-18 02:40:36.000000000 +0100 @@ -0,0 +1,298 @@ +{- This module was generated from data in the Kate syntax + highlighting file elixir.xml, version 0.1, by Rubén Caro (ruben.caro.este...@gmail.com) -} + +module Text.Highlighting.Kate.Syntax.Elixir + (highlight, parseExpression, syntaxName, syntaxExtensions) +where +import Text.Highlighting.Kate.Types +import Text.Highlighting.Kate.Common +import qualified Text.Highlighting.Kate.Syntax.Markdown +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 = "Elixir" + +-- | Filename extensions for this language. +syntaxExtensions :: String +syntaxExtensions = "*.ex;*.exs;*.eex;*.xml.eex;*.js.eex" + +-- | 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 = [("Elixir","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 } + ("Elixir","Normal") -> return () + ("Elixir","Find closing block brace") -> return () + ("Elixir","Documentation") -> return () + ("Elixir","Triple Quoted String") -> return () + ("Elixir","Quoted String") -> return () + ("Elixir","Apostrophed String") -> return () + ("Elixir","Command String") -> return () + ("Elixir","RegEx 1") -> return () + ("Elixir","Subst") -> return () + ("Elixir","Short Subst") -> (popContext) >> pEndLine + ("Elixir","Comment Line") -> (popContext) >> pEndLine + ("Elixir","General Comment") -> (popContext) >> pEndLine + ("Elixir","regexpr_rules") -> return () + ("Elixir","Markdown Code") -> return () + _ -> return () + else return () + +withAttribute attr txt = do + when (null txt) $ fail "Parser matched no text" + updateState $ \st -> st { synStPrevChar = last txt + , synStPrevNonspace = synStPrevNonspace st || not (all isSpace txt) } + return (attr, txt) + +list_keywords = Set.fromList $ words $ "do end case bc lc for if cond unless try receive exit after rescue catch else raise throw quote unquote super and not or when xor in inlist inbits" +list_pseudo'2dvariables = Set.fromList $ words $ "nil true false" +list_definitions = Set.fromList $ words $ "fn defmodule def defp defprotocol defimpl defrecord defstruct defmacro defmacrop defdelegate defcallback defmacrocallback defexception defoverridable" +list_mixin'2dmacros = Set.fromList $ words $ "import require alias use" + +regex_'23'21'5c'2f'2e'2a = compileRegex True "#!\\/.*" +regex_'5cb'5b'5fA'2dZ'5d'2b'5bA'2dZ'5f0'2d9'5d'2b'5cb = compileRegex True "\\b[_A-Z]+[A-Z_0-9]+\\b" +regex_'5cb'5bA'2dZ'5d'2b'5f'2a'28'5b0'2d9'5d'7c'5ba'2dz'5d'29'5b'5fa'2dzA'2dZ0'2d9'5d'2a'5cb = compileRegex True "\\b[A-Z]+_*([0-9]|[a-z])[_a-zA-Z0-9]*\\b" +regex_'5cb'5c'2d'3f0'5bxX'5d'28'5b0'2d9a'2dfA'2dF'5d'7c'5f'5b0'2d9a'2dfA'2dF'5d'29'2b = compileRegex True "\\b\\-?0[xX]([0-9a-fA-F]|_[0-9a-fA-F])+" +regex_'5cb'5c'2d'3f0'5bbB'5d'28'5b01'5d'7c'5f'5b01'5d'29'2b = compileRegex True "\\b\\-?0[bB]([01]|_[01])+" +regex_'5cb'5c'2d'3f0'5b1'2d7'5d'28'5b0'2d7'5d'7c'5f'5b0'2d7'5d'29'2a = compileRegex True "\\b\\-?0[1-7]([0-7]|_[0-7])*" +regex_'5cb'5c'2d'3f'5b0'2d9'5d'28'5b0'2d9'5d'7c'5f'5b0'2d9'5d'29'2a'5c'2e'5b0'2d9'5d'28'5b0'2d9'5d'7c'5f'5b0'2d9'5d'29'2a'28'5beE'5d'5c'2d'3f'5b1'2d9'5d'28'5b0'2d9'5d'7c'5f'5b0'2d9'5d'29'2a'28'5c'2e'5b0'2d9'5d'2a'29'3f'29'3f = compileRegex True "\\b\\-?[0-9]([0-9]|_[0-9])*\\.[0-9]([0-9]|_[0-9])*([eE]\\-?[1-9]([0-9]|_[0-9])*(\\.[0-9]*)?)?" +regex_'5cb'5c'2d'3f'5b1'2d9'5d'28'5b0'2d9'5d'7c'5f'5b0'2d9'5d'29'2a'5cb = compileRegex True "\\b\\-?[1-9]([0-9]|_[0-9])*\\b" +regex_'5cs'5b'5c'3f'5c'3a'5c'25'5d'5cs = compileRegex True "\\s[\\?\\:\\%]\\s" +regex_'5b'7c'26'3c'3e'5c'5e'5c'2b'2a'7e'5c'2d'3d'5d'2b = compileRegex True "[|&<>\\^\\+*~\\-=]+" +regex_'5cs'21 = compileRegex True "\\s!" +regex_'2f'3d'5cs = compileRegex True "/=\\s" +regex_'3a'28'40'7b1'2c2'7d'7c'5c'24'29'3f'5ba'2dzA'2dZ'5f'5d'5ba'2dzA'2dZ0'2d9'5f'5d'2a'5b'3d'3f'21'5d'3f = compileRegex True ":(@{1,2}|\\$)?[a-zA-Z_][a-zA-Z0-9_]*[=?!]?" +regex_'5cb'28'40'7b1'2c2'7d'7c'5c'24'29'3f'5ba'2dzA'2dZ'5f'5d'5ba'2dzA'2dZ0'2d9'5f'5d'2a'5b'3d'3f'21'5d'3f'3a = compileRegex True "\\b(@{1,2}|\\$)?[a-zA-Z_][a-zA-Z0-9_]*[=?!]?:" +regex_'3a'5c'5b'5c'5d'3d'3f = compileRegex True ":\\[\\]=?" +regex_'40'28module'29'3fdoc'5cs'2b'22'22'22 = compileRegex True "@(module)?doc\\s+\"\"\"" +regex_'40'5ba'2dzA'2dZ'5f0'2d9'5d'2b = compileRegex True "@[a-zA-Z_0-9]+" +regex_'5cs'2a'23'2b'5cs'2e'2a'5b'23'5d'3f'24 = compileRegex True "\\s*#+\\s.*[#]?$" +regex_'5cs'2a'5b'5c'2a'5c'2b'5c'2d'5d'5cs = compileRegex True "\\s*[\\*\\+\\-]\\s" +regex_'5cs'2a'5b'5cd'5d'2b'5c'2e'5cs = compileRegex True "\\s*[\\d]+\\.\\s" +regex_'5cs'2a'5c'60'5c'60'5c'60'5cs'2a'24 = compileRegex True "\\s*\\`\\`\\`\\s*$" +regex_'5c'5c'5c'22 = compileRegex True "\\\\\\\"" +regex_'23'40'7b1'2c2'7d = compileRegex True "#@{1,2}" +regex_'5c'5c'5c'27 = compileRegex True "\\\\\\'" +regex_'5c'5c'5c'60 = compileRegex True "\\\\\\`" +regex_'5c'5c'5c'2f = compileRegex True "\\\\\\/" +regex_'2f'5buiomxn'5d'2a = compileRegex True "/[uiomxn]*" +regex_'5cw'28'3f'21'5cw'29 = compileRegex True "\\w(?!\\w)" + +parseRules ("Elixir","Normal") = + (((pColumn 0 >> pRegExpr regex_'23'21'5c'2f'2e'2a >>= withAttribute KeywordTok)) + <|> + ((pKeyword " \n\t.():+,-<=>%&*/;[]^{|}~\\" list_keywords >>= withAttribute KeywordTok)) + <|> + ((pKeyword " \n\t.():+,-<=>%&*/;[]^{|}~\\" list_definitions >>= withAttribute KeywordTok)) + <|> + ((pKeyword " \n\t.():+,-<=>%&*/;[]^{|}~\\" list_pseudo'2dvariables >>= withAttribute DecValTok)) + <|> + ((pKeyword " \n\t.():+,-<=>%&*/;[]^{|}~\\" list_mixin'2dmacros >>= withAttribute KeywordTok)) + <|> + ((pRegExpr regex_'5cb'5b'5fA'2dZ'5d'2b'5bA'2dZ'5f0'2d9'5d'2b'5cb >>= withAttribute DataTypeTok)) + <|> + ((pRegExpr regex_'5cb'5bA'2dZ'5d'2b'5f'2a'28'5b0'2d9'5d'7c'5ba'2dz'5d'29'5b'5fa'2dzA'2dZ0'2d9'5d'2a'5cb >>= withAttribute DataTypeTok)) + <|> + ((pRegExpr regex_'5cb'5c'2d'3f0'5bxX'5d'28'5b0'2d9a'2dfA'2dF'5d'7c'5f'5b0'2d9a'2dfA'2dF'5d'29'2b >>= withAttribute BaseNTok)) + <|> + ((pRegExpr regex_'5cb'5c'2d'3f0'5bbB'5d'28'5b01'5d'7c'5f'5b01'5d'29'2b >>= withAttribute BaseNTok)) + <|> + ((pRegExpr regex_'5cb'5c'2d'3f0'5b1'2d7'5d'28'5b0'2d7'5d'7c'5f'5b0'2d7'5d'29'2a >>= withAttribute BaseNTok)) + <|> + ((pRegExpr regex_'5cb'5c'2d'3f'5b0'2d9'5d'28'5b0'2d9'5d'7c'5f'5b0'2d9'5d'29'2a'5c'2e'5b0'2d9'5d'28'5b0'2d9'5d'7c'5f'5b0'2d9'5d'29'2a'28'5beE'5d'5c'2d'3f'5b1'2d9'5d'28'5b0'2d9'5d'7c'5f'5b0'2d9'5d'29'2a'28'5c'2e'5b0'2d9'5d'2a'29'3f'29'3f >>= withAttribute FloatTok)) + <|> + ((pRegExpr regex_'5cb'5c'2d'3f'5b1'2d9'5d'28'5b0'2d9'5d'7c'5f'5b0'2d9'5d'29'2a'5cb >>= withAttribute DecValTok)) + <|> + ((pInt >>= withAttribute DecValTok)) + <|> + ((pHlCChar >>= withAttribute CharTok)) + <|> + ((pDetectChar False '.' >>= withAttribute NormalTok)) + <|> + ((pDetect2Chars False '&' '&' >>= withAttribute NormalTok)) + <|> + ((pDetect2Chars False '|' '|' >>= withAttribute NormalTok)) + <|> + ((pRegExpr regex_'5cs'5b'5c'3f'5c'3a'5c'25'5d'5cs >>= withAttribute NormalTok)) + <|> + ((pRegExpr regex_'5b'7c'26'3c'3e'5c'5e'5c'2b'2a'7e'5c'2d'3d'5d'2b >>= withAttribute NormalTok)) + <|> + ((pRegExpr regex_'5cs'21 >>= withAttribute NormalTok)) + <|> + ((pRegExpr regex_'2f'3d'5cs >>= withAttribute NormalTok)) + <|> + ((pString False "%=" >>= withAttribute NormalTok)) + <|> + ((pRegExpr regex_'3a'28'40'7b1'2c2'7d'7c'5c'24'29'3f'5ba'2dzA'2dZ'5f'5d'5ba'2dzA'2dZ0'2d9'5f'5d'2a'5b'3d'3f'21'5d'3f >>= withAttribute StringTok)) + <|> + ((pRegExpr regex_'5cb'28'40'7b1'2c2'7d'7c'5c'24'29'3f'5ba'2dzA'2dZ'5f'5d'5ba'2dzA'2dZ0'2d9'5f'5d'2a'5b'3d'3f'21'5d'3f'3a >>= withAttribute StringTok)) + <|> + ((pRegExpr regex_'3a'5c'5b'5c'5d'3d'3f >>= withAttribute StringTok)) + <|> + ((pRegExpr regex_'40'28module'29'3fdoc'5cs'2b'22'22'22 >>= withAttribute OtherTok) >>~ pushContext ("Elixir","Documentation")) + <|> + ((pString False "\"\"\"" >>= withAttribute StringTok) >>~ pushContext ("Elixir","Triple Quoted String")) + <|> + ((pDetectChar False '"' >>= withAttribute StringTok) >>~ pushContext ("Elixir","Quoted String")) + <|> + ((pDetectChar False '\'' >>= withAttribute StringTok) >>~ pushContext ("Elixir","Apostrophed String")) + <|> + ((pDetectChar False '`' >>= withAttribute StringTok) >>~ pushContext ("Elixir","Command String")) + <|> + ((pString False "?#" >>= withAttribute NormalTok)) + <|> + ((pDetectChar False '#' >>= withAttribute CommentTok) >>~ pushContext ("Elixir","General Comment")) + <|> + ((pDetectChar False '[' >>= withAttribute NormalTok)) + <|> + ((pDetectChar False ']' >>= withAttribute NormalTok)) + <|> + ((pRegExpr regex_'40'5ba'2dzA'2dZ'5f0'2d9'5d'2b >>= withAttribute OtherTok)) + <|> + ((pDetectChar False '/' >>= withAttribute OtherTok) >>~ pushContext ("Elixir","RegEx 1")) + <|> + ((pDetectChar False ')' >>= withAttribute NormalTok)) + <|> + ((pDetectIdentifier >>= withAttribute NormalTok)) + <|> + (currentContext >>= \x -> guard (x == ("Elixir","Normal")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("Elixir","Find closing block brace") = + (((pDetectChar False '}' >>= withAttribute NormalTok) >>~ (popContext)) + <|> + ((parseRules ("Elixir","Normal"))) + <|> + (currentContext >>= \x -> guard (x == ("Elixir","Find closing block brace")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("Elixir","Documentation") = + (((pString False "\"\"\"" >>= withAttribute OtherTok) >>~ (popContext)) + <|> + ((pColumn 0 >> pRegExpr regex_'5cs'2a'23'2b'5cs'2e'2a'5b'23'5d'3f'24 >>= withAttribute FunctionTok)) + <|> + ((pColumn 0 >> pRegExpr regex_'5cs'2a'5b'5c'2a'5c'2b'5c'2d'5d'5cs >>= withAttribute FunctionTok)) + <|> + ((pColumn 0 >> pRegExpr regex_'5cs'2a'5b'5cd'5d'2b'5c'2e'5cs >>= withAttribute FunctionTok)) + <|> + ((pColumn 0 >> pRegExpr regex_'5cs'2a'5c'60'5c'60'5c'60'5cs'2a'24 >>= withAttribute FunctionTok) >>~ pushContext ("Elixir","Markdown Code")) + <|> + ((pDetectSpaces >>= withAttribute CommentTok)) + <|> + ((Text.Highlighting.Kate.Syntax.Markdown.parseExpression (Just ("Markdown","Normal Text")) >>= ((withAttribute CommentTok) . snd))) + <|> + (currentContext >>= \x -> guard (x == ("Elixir","Documentation")) >> pDefault >>= withAttribute CommentTok)) + +parseRules ("Elixir","Triple Quoted String") = + (((pString False "\"\"\"" >>= withAttribute StringTok) >>~ (popContext)) + <|> + (currentContext >>= \x -> guard (x == ("Elixir","Triple Quoted String")) >> pDefault >>= withAttribute StringTok)) + +parseRules ("Elixir","Quoted String") = + (((pString False "\\\\" >>= withAttribute StringTok)) + <|> + ((pRegExpr regex_'5c'5c'5c'22 >>= withAttribute StringTok)) + <|> + ((pRegExpr regex_'23'40'7b1'2c2'7d >>= withAttribute OtherTok) >>~ pushContext ("Elixir","Short Subst")) + <|> + ((pDetect2Chars False '#' '{' >>= withAttribute OtherTok) >>~ pushContext ("Elixir","Subst")) + <|> + ((pDetectChar False '"' >>= withAttribute StringTok) >>~ (popContext)) + <|> + (currentContext >>= \x -> guard (x == ("Elixir","Quoted String")) >> pDefault >>= withAttribute StringTok)) + +parseRules ("Elixir","Apostrophed String") = + (((pString False "\\\\" >>= withAttribute StringTok)) + <|> + ((pRegExpr regex_'5c'5c'5c'27 >>= withAttribute StringTok)) + <|> + ((pDetectChar False '\'' >>= withAttribute StringTok) >>~ (popContext)) + <|> + (currentContext >>= \x -> guard (x == ("Elixir","Apostrophed String")) >> pDefault >>= withAttribute StringTok)) + +parseRules ("Elixir","Command String") = + (((pString False "\\\\" >>= withAttribute StringTok)) + <|> + ((pRegExpr regex_'5c'5c'5c'60 >>= withAttribute StringTok)) + <|> + ((pRegExpr regex_'23'40'7b1'2c2'7d >>= withAttribute OtherTok) >>~ pushContext ("Elixir","Short Subst")) + <|> + ((pDetect2Chars False '#' '{' >>= withAttribute OtherTok) >>~ pushContext ("Elixir","Subst")) + <|> + ((pDetectChar False '`' >>= withAttribute StringTok) >>~ (popContext)) + <|> + (currentContext >>= \x -> guard (x == ("Elixir","Command String")) >> pDefault >>= withAttribute StringTok)) + +parseRules ("Elixir","RegEx 1") = + (((pRegExpr regex_'5c'5c'5c'2f >>= withAttribute OtherTok)) + <|> + ((pRegExpr regex_'23'40'7b1'2c2'7d >>= withAttribute OtherTok) >>~ pushContext ("Elixir","Short Subst")) + <|> + ((pDetect2Chars False '#' '{' >>= withAttribute OtherTok) >>~ pushContext ("Elixir","Subst")) + <|> + ((pRegExpr regex_'2f'5buiomxn'5d'2a >>= withAttribute OtherTok) >>~ (popContext)) + <|> + (currentContext >>= \x -> guard (x == ("Elixir","RegEx 1")) >> pDefault >>= withAttribute OtherTok)) + +parseRules ("Elixir","Subst") = + (((pDetectChar False '}' >>= withAttribute OtherTok) >>~ (popContext)) + <|> + ((parseRules ("Elixir","Normal"))) + <|> + (currentContext >>= \x -> guard (x == ("Elixir","Subst")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("Elixir","Short Subst") = + (((pRegExpr regex_'23'40'7b1'2c2'7d >>= withAttribute OtherTok)) + <|> + ((pRegExpr regex_'5cw'28'3f'21'5cw'29 >>= withAttribute OtherTok) >>~ (popContext)) + <|> + (currentContext >>= \x -> guard (x == ("Elixir","Short Subst")) >> pDefault >>= withAttribute OtherTok)) + +parseRules ("Elixir","Comment Line") = + (currentContext >>= \x -> guard (x == ("Elixir","Comment Line")) >> pDefault >>= withAttribute CommentTok) + +parseRules ("Elixir","General Comment") = + (currentContext >>= \x -> guard (x == ("Elixir","General Comment")) >> pDefault >>= withAttribute CommentTok) + +parseRules ("Elixir","regexpr_rules") = + (((pDetect2Chars False '\\' '\\' >>= withAttribute OtherTok)) + <|> + ((pRegExpr regex_'23'40'7b1'2c2'7d >>= withAttribute OtherTok) >>~ pushContext ("Elixir","Short Subst")) + <|> + ((pDetect2Chars False '#' '{' >>= withAttribute OtherTok) >>~ pushContext ("Elixir","Subst")) + <|> + (currentContext >>= \x -> guard (x == ("Elixir","regexpr_rules")) >> pDefault >>= withAttribute OtherTok)) + +parseRules ("Elixir","Markdown Code") = + (((pColumn 0 >> pRegExpr regex_'5cs'2a'5c'60'5c'60'5c'60'5cs'2a'24 >>= withAttribute FunctionTok) >>~ (popContext)) + <|> + (currentContext >>= \x -> guard (x == ("Elixir","Markdown Code")) >> pDefault >>= withAttribute FunctionTok)) + +parseRules ("Markdown", _) = Text.Highlighting.Kate.Syntax.Markdown.parseExpression Nothing + +parseRules x = parseRules ("Elixir","Normal") <|> fail ("Unknown context" ++ show x) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/highlighting-kate-0.6.1/Text/Highlighting/Kate/Syntax/Hamlet.hs new/highlighting-kate-0.6.2/Text/Highlighting/Kate/Syntax/Hamlet.hs --- old/highlighting-kate-0.6.1/Text/Highlighting/Kate/Syntax/Hamlet.hs 1970-01-01 01:00:00.000000000 +0100 +++ new/highlighting-kate-0.6.2/Text/Highlighting/Kate/Syntax/Hamlet.hs 2016-03-18 02:40:36.000000000 +0100 @@ -0,0 +1,187 @@ +{- This module was generated from data in the Kate syntax + highlighting file hamlet.xml, version 0.1, by Bastian Holst (bastianho...@gmx.de) -} + +module Text.Highlighting.Kate.Syntax.Hamlet + (highlight, parseExpression, syntaxName, syntaxExtensions) +where +import Text.Highlighting.Kate.Types +import Text.Highlighting.Kate.Common +import qualified Text.Highlighting.Kate.Syntax.Haskell +import Text.ParserCombinators.Parsec hiding (State) +import Control.Monad.State +import Data.Char (isSpace) + +-- | Full name of language. +syntaxName :: String +syntaxName = "Hamlet" + +-- | Filename extensions for this language. +syntaxExtensions :: String +syntaxExtensions = "*.hamlet" + +-- | 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 = [("Hamlet","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 } + ("Hamlet","Normal Text") -> (popContext) >> pEndLine + ("Hamlet","element") -> return () + ("Hamlet","Logic") -> (popContext) >> pEndLine + ("Hamlet","Code") -> return () + ("Hamlet","Codeline") -> (popContext) >> pEndLine + ("Hamlet","Assignment") -> (popContext) >> pEndLine + ("Hamlet","Attribute") -> return () + ("Hamlet","Value") -> return () + ("Hamlet","Value DQ") -> return () + ("Hamlet","Value SQ") -> return () + ("Hamlet","Value Code") -> return () + _ -> return () + else return () + +withAttribute attr txt = do + when (null txt) $ fail "Parser matched no text" + updateState $ \st -> st { synStPrevChar = last txt + , synStPrevNonspace = synStPrevNonspace st || not (all isSpace txt) } + return (attr, txt) + + +regex_'3c'28'3f'21'5b0'2d9'5d'29'5b'5cw'5f'3a'5d'5b'5cw'2e'3a'5f'2d'5d'2a'5cb = compileRegex True "<(?![0-9])[\\w_:][\\w.:_-]*\\b" +regex_'28'3f'21'5b0'2d9'5d'29'5b'5cw'5f'3a'5d'5b'5cw'2e'3a'5f'2d'5d'2a = compileRegex True "(?![0-9])[\\w_:][\\w.:_-]*" +regex_'5cs'2b'28'3f'21'5b0'2d9'5d'29'5b'5cw'5f'3a'5d'5b'5cw'2e'3a'5f'2d'5d'2a = compileRegex True "\\s+(?![0-9])[\\w_:][\\w.:_-]*" +regex_'5c'2e'28'3f'21'5b0'2d9'5d'29'5b'5cw'5f'3a'5d'5b'5cw'2e'3a'5f'2d'5d'2a = compileRegex True "\\.(?![0-9])[\\w_:][\\w.:_-]*" +regex_'5cS = compileRegex True "\\S" +regex_'5b'5e'22'27'3e'5cs'5d'2b = compileRegex True "[^\"'>\\s]+" + +parseRules ("Hamlet","Normal Text") = + (((pRegExpr regex_'3c'28'3f'21'5b0'2d9'5d'29'5b'5cw'5f'3a'5d'5b'5cw'2e'3a'5f'2d'5d'2a'5cb >>= withAttribute KeywordTok) >>~ pushContext ("Hamlet","element")) + <|> + ((pString False "^{" >>= withAttribute KeywordTok) >>~ pushContext ("Hamlet","Code")) + <|> + ((pString False "#{" >>= withAttribute KeywordTok) >>~ pushContext ("Hamlet","Code")) + <|> + ((pString False "@{" >>= withAttribute KeywordTok) >>~ pushContext ("Hamlet","Code")) + <|> + ((pString False "_{" >>= withAttribute KeywordTok) >>~ pushContext ("Hamlet","Code")) + <|> + ((pFirstNonSpace >> pDetectChar False '$' >>= withAttribute KeywordTok) >>~ pushContext ("Hamlet","Logic")) + <|> + (currentContext >>= \x -> guard (x == ("Hamlet","Normal Text")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("Hamlet","element") = + (((pDetect2Chars False '/' '>' >>= withAttribute KeywordTok) >>~ (popContext)) + <|> + ((pDetectChar False '>' >>= withAttribute KeywordTok) >>~ (popContext)) + <|> + ((pColumn 0 >> pRegExpr regex_'28'3f'21'5b0'2d9'5d'29'5b'5cw'5f'3a'5d'5b'5cw'2e'3a'5f'2d'5d'2a >>= withAttribute OtherTok) >>~ pushContext ("Hamlet","Attribute")) + <|> + ((pRegExpr regex_'5cs'2b'28'3f'21'5b0'2d9'5d'29'5b'5cw'5f'3a'5d'5b'5cw'2e'3a'5f'2d'5d'2a >>= withAttribute OtherTok) >>~ pushContext ("Hamlet","Attribute")) + <|> + ((pRegExpr regex_'5c'2e'28'3f'21'5b0'2d9'5d'29'5b'5cw'5f'3a'5d'5b'5cw'2e'3a'5f'2d'5d'2a >>= withAttribute StringTok)) + <|> + ((pRegExpr regex_'5cS >>= withAttribute ErrorTok)) + <|> + (currentContext >>= \x -> guard (x == ("Hamlet","element")) >> pDefault >>= withAttribute KeywordTok)) + +parseRules ("Hamlet","Logic") = + (((pRegExpr (compileRegex True "\\bif\\b") >>= withAttribute KeywordTok) >>~ pushContext ("Hamlet","Codeline")) + <|> + ((pRegExpr (compileRegex True "\\belseif\\b") >>= withAttribute KeywordTok) >>~ pushContext ("Hamlet","Codeline")) + <|> + ((pRegExpr (compileRegex True "\\bforall\\b") >>= withAttribute KeywordTok) >>~ pushContext ("Hamlet","Assignment")) + <|> + ((pRegExpr (compileRegex True "\\bmaybe\\b") >>= withAttribute KeywordTok) >>~ pushContext ("Hamlet","Assignment")) + <|> + ((pRegExpr (compileRegex True "\\belse\\b") >>= withAttribute KeywordTok)) + <|> + ((pRegExpr (compileRegex True "\\bnothing\\b") >>= withAttribute KeywordTok)) + <|> + ((pRegExpr regex_'5cS >>= withAttribute ErrorTok)) + <|> + (currentContext >>= \x -> guard (x == ("Hamlet","Logic")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("Hamlet","Code") = + (((pDetectChar False '}' >>= withAttribute KeywordTok) >>~ (popContext)) + <|> + ((Text.Highlighting.Kate.Syntax.Haskell.parseExpression (Just ("Haskell","")))) + <|> + (currentContext >>= \x -> guard (x == ("Hamlet","Code")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("Hamlet","Codeline") = + (((Text.Highlighting.Kate.Syntax.Haskell.parseExpression (Just ("Haskell","")))) + <|> + (currentContext >>= \x -> guard (x == ("Hamlet","Codeline")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("Hamlet","Assignment") = + (((pString False "<-" >>= withAttribute OtherTok) >>~ pushContext ("Hamlet","Codeline")) + <|> + ((Text.Highlighting.Kate.Syntax.Haskell.parseExpression (Just ("Haskell","")))) + <|> + (currentContext >>= \x -> guard (x == ("Hamlet","Assignment")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("Hamlet","Attribute") = + (((pDetectChar False '=' >>= withAttribute OtherTok) >>~ pushContext ("Hamlet","Value")) + <|> + ((pDetectChar False '>' >>= withAttribute KeywordTok) >>~ (popContext >> popContext)) + <|> + ((pRegExpr regex_'5cS >>= withAttribute ErrorTok)) + <|> + (currentContext >>= \x -> guard (x == ("Hamlet","Attribute")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("Hamlet","Value") = + (((pDetectChar False '"' >>= withAttribute StringTok) >>~ pushContext ("Hamlet","Value DQ")) + <|> + ((pDetectChar False '\'' >>= withAttribute StringTok) >>~ pushContext ("Hamlet","Value SQ")) + <|> + ((pString False "@{" >>= withAttribute KeywordTok) >>~ pushContext ("Hamlet","Value Code")) + <|> + ((pString False "#{" >>= withAttribute KeywordTok) >>~ pushContext ("Hamlet","Value Code")) + <|> + ((pRegExpr regex_'5b'5e'22'27'3e'5cs'5d'2b >>= withAttribute StringTok) >>~ (popContext >> popContext)) + <|> + ((pRegExpr regex_'5cS >>= withAttribute ErrorTok)) + <|> + (currentContext >>= \x -> guard (x == ("Hamlet","Value")) >> pDefault >>= withAttribute StringTok)) + +parseRules ("Hamlet","Value DQ") = + (((pDetectChar False '"' >>= withAttribute StringTok) >>~ (popContext >> popContext >> popContext)) + <|> + (currentContext >>= \x -> guard (x == ("Hamlet","Value DQ")) >> pDefault >>= withAttribute StringTok)) + +parseRules ("Hamlet","Value SQ") = + (((pDetectChar False '\'' >>= withAttribute StringTok) >>~ (popContext >> popContext >> popContext)) + <|> + (currentContext >>= \x -> guard (x == ("Hamlet","Value SQ")) >> pDefault >>= withAttribute StringTok)) + +parseRules ("Hamlet","Value Code") = + (((pDetectChar False '}' >>= withAttribute KeywordTok) >>~ (popContext >> popContext >> popContext)) + <|> + ((Text.Highlighting.Kate.Syntax.Haskell.parseExpression (Just ("Haskell","")))) + <|> + (currentContext >>= \x -> guard (x == ("Hamlet","Value Code")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("Haskell", _) = Text.Highlighting.Kate.Syntax.Haskell.parseExpression Nothing + +parseRules x = parseRules ("Hamlet","Normal Text") <|> fail ("Unknown context" ++ show x) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/highlighting-kate-0.6.1/Text/Highlighting/Kate/Syntax.hs new/highlighting-kate-0.6.2/Text/Highlighting/Kate/Syntax.hs --- old/highlighting-kate-0.6.1/Text/Highlighting/Kate/Syntax.hs 2015-12-12 21:42:37.000000000 +0100 +++ new/highlighting-kate-0.6.2/Text/Highlighting/Kate/Syntax.hs 2016-03-18 02:40:36.000000000 +0100 @@ -51,6 +51,7 @@ import qualified Text.Highlighting.Kate.Syntax.Doxygenlua as Doxygenlua import qualified Text.Highlighting.Kate.Syntax.Dtd as Dtd import qualified Text.Highlighting.Kate.Syntax.Eiffel as Eiffel +import qualified Text.Highlighting.Kate.Syntax.Elixir as Elixir import qualified Text.Highlighting.Kate.Syntax.Email as Email import qualified Text.Highlighting.Kate.Syntax.Erlang as Erlang import qualified Text.Highlighting.Kate.Syntax.Fasm as Fasm @@ -60,6 +61,7 @@ import qualified Text.Highlighting.Kate.Syntax.Glsl as Glsl import qualified Text.Highlighting.Kate.Syntax.Gnuassembler as Gnuassembler import qualified Text.Highlighting.Kate.Syntax.Go as Go +import qualified Text.Highlighting.Kate.Syntax.Hamlet as Hamlet import qualified Text.Highlighting.Kate.Syntax.Haskell as Haskell import qualified Text.Highlighting.Kate.Syntax.Haxe as Haxe import qualified Text.Highlighting.Kate.Syntax.Html as Html @@ -140,15 +142,15 @@ -- | 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","Dockerfile","Dot","Doxygen","Doxygenlua","Dtd","Eiffel","Email","Erlang","Fasm","Fortran","Fsharp","Gcc","Glsl","Gnuassembler","Go","Haskell","Haxe","Html","Idris","Ini","Isocpp","Java","Javadoc","Javascript","Json","Jsp","Julia","Kotlin","Latex","Lex","Lilypond","LiterateCurry","LiterateHaskell","Llvm","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","Elixir","Email","Erlang","Fasm","Fortran","Fsharp","Gcc","Glsl","Gnuassembler","Go","Hamlet","Haskell","Haxe","Html","Idris","Ini","Isocpp","Java","Javadoc","Javascript","Json","Jsp","Julia","Kotlin","Latex","Lex","Lilypond","LiterateCurry","LiterateHaskell","Llvm","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), ("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), ("Idris", Idris.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), ("Kotlin", Kotlin.syntaxExtensions), ("Latex", Latex.syntaxExtensions), ("Lex", Lex.syntaxExtensions), ("Lilypond", Lilypond.syntaxExtensions), ("LiterateCurry", LiterateCurry.syntaxExtensions), ("LiterateHaskell", LiterateHaskell.syntaxExtensions), ("Llvm", Llvm.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), ("Elixir", Elixir.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), ("Hamlet", Hamlet.syntaxExtensions), ("Haskell", Haskell.syntaxExtensions), ("Haxe", Haxe.syntaxExtensions), ("Html", Html.syntaxExtensions), ("Idris", Idris.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), ("Kotlin", Kotlin.syntaxExtensions), ("Latex", Latex.syntaxExtensions), ("Lex", Lex.syntaxExtensions), ("Lilypond", Lilypond.syntaxExtensions), ("LiterateCurry", LiterateCurry.syntaxExtensions), ("LiterateHaskell", LiterateHaskell.syntaxExtensions), ("Llvm", Llvm.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)] -- | List of full names of languages. languageFullNames :: [(String, String)] -languageFullNames = [("Abc", Abc.syntaxName), ("Actionscript", Actionscript.syntaxName), ("Ada", Ada.syntaxName), ("Agda", Agda.syntaxName), ("Alert", Alert.syntaxName), ("Alert_indent", Alert_indent.syntaxName), ("Apache", Apache.syntaxName), ("Asn1", Asn1.syntaxName), ("Asp", Asp.syntaxName), ("Awk", Awk.syntaxName), ("Bash", Bash.syntaxName), ("Bibtex", Bibtex.syntaxName), ("Boo", Boo.syntaxName), ("C", C.syntaxName), ("Changelog", Changelog.syntaxName), ("Clojure", Clojure.syntaxName), ("Cmake", Cmake.syntaxName), ("Coffee", Coffee.syntaxName), ("Coldfusion", Coldfusion.syntaxName), ("Commonlisp", Commonlisp.syntaxName), ("Cpp", Cpp.syntaxName), ("Cs", Cs.syntaxName), ("Css", Css.syntaxName), ("Curry", Curry.syntaxName), ("D", D.syntaxName), ("Diff", Diff.syntaxName), ("Djangotemplate", Djangotemplate.syntaxName), ("Dockerfile", Dockerfile.syntaxName), ("Dot", Dot.syntaxName), ("Doxygen", Doxygen.syntaxName), ("Doxygenlua", Doxygenlua.syntaxName), ("Dtd", Dtd.syntaxName), ("Eiffel", Eiffel.syntaxName), ("Email", Email.syntaxName), ("Erlang", Erlang.syntaxName), ("Fasm", Fasm.syntaxName), ("Fortran", Fortran.syntaxName), ("Fsharp", Fsharp.syntaxName), ("Gcc", Gcc.syntaxName), ("Glsl", Glsl.syntaxName), ("Gnuassembler", Gnuassembler.syntaxName), ("Go", Go.syntaxName), ("Haskell", Haskell.syntaxName), ("Haxe", Haxe.syntaxName), ("Html", Html.syntaxName), ("Idris", Idris.syntaxName), ("Ini", Ini.syntaxName), ("Isocpp", Isocpp.syntaxName), ("Java", Java.syntaxName), ("Javadoc", Javadoc.syntaxName), ("Javascript", Javascript.syntaxName), ("Json", Json.syntaxName), ("Jsp", Jsp.syntaxName), ("Julia", Julia.syntaxName), ("Kotlin", Kotlin.syntaxName), ("Latex", Latex.syntaxName), ("Lex", Lex.syntaxName), ("Lilypond", Lilypond.syntaxName), ("LiterateCurry", LiterateCurry.syntaxName), ("LiterateHaskell", LiterateHaskell.syntaxName), ("Llvm", Llvm.syntaxName), ("Lua", Lua.syntaxName), ("M4", M4.syntaxName), ("Makefile", Makefile.syntaxName), ("Mandoc", Mandoc.syntaxName), ("Markdown", Markdown.syntaxName), ("Mathematica", Mathematica.syntaxName), ("Matlab", Matlab.syntaxName), ("Maxima", Maxima.syntaxName), ("Mediawiki", Mediawiki.syntaxName), ("Metafont", Metafont.syntaxName), ("Mips", Mips.syntaxName), ("Modelines", Modelines.syntaxName), ("Modula2", Modula2.syntaxName), ("Modula3", Modula3.syntaxName), ("Monobasic", Monobasic.syntaxName), ("Nasm", Nasm.syntaxName), ("Noweb", Noweb.syntaxName), ("Objectivec", Objectivec.syntaxName), ("Objectivecpp", Objectivecpp.syntaxName), ("Ocaml", Ocaml.syntaxName), ("Octave", Octave.syntaxName), ("Opencl", Opencl.syntaxName), ("Pascal", Pascal.syntaxName), ("Perl", Perl.syntaxName), ("Php", Php.syntaxName), ("Pike", Pike.syntaxName), ("Postscript", Postscript.syntaxName), ("Prolog", Prolog.syntaxName), ("Pure", Pure.syntaxName), ("Python", Python.syntaxName), ("R", R.syntaxName), ("Relaxng", Relaxng.syntaxName), ("Relaxngcompact", Relaxngcompact.syntaxName), ("Rest", Rest.syntaxName), ("Rhtml", Rhtml.syntaxName), ("Roff", Roff.syntaxName), ("Ruby", Ruby.syntaxName), ("Rust", Rust.syntaxName), ("Scala", Scala.syntaxName), ("Scheme", Scheme.syntaxName), ("Sci", Sci.syntaxName), ("Sed", Sed.syntaxName), ("Sgml", Sgml.syntaxName), ("Sql", Sql.syntaxName), ("SqlMysql", SqlMysql.syntaxName), ("SqlPostgresql", SqlPostgresql.syntaxName), ("Tcl", Tcl.syntaxName), ("Tcsh", Tcsh.syntaxName), ("Texinfo", Texinfo.syntaxName), ("Verilog", Verilog.syntaxName), ("Vhdl", Vhdl.syntaxName), ("Xml", Xml.syntaxName), ("Xorg", Xorg.syntaxName), ("Xslt", Xslt.syntaxName), ("Xul", Xul.syntaxName), ("Yacc", Yacc.syntaxName), ("Yaml", Yaml.syntaxName), ("Zsh", Zsh.syntaxName)] +languageFullNames = [("Abc", Abc.syntaxName), ("Actionscript", Actionscript.syntaxName), ("Ada", Ada.syntaxName), ("Agda", Agda.syntaxName), ("Alert", Alert.syntaxName), ("Alert_indent", Alert_indent.syntaxName), ("Apache", Apache.syntaxName), ("Asn1", Asn1.syntaxName), ("Asp", Asp.syntaxName), ("Awk", Awk.syntaxName), ("Bash", Bash.syntaxName), ("Bibtex", Bibtex.syntaxName), ("Boo", Boo.syntaxName), ("C", C.syntaxName), ("Changelog", Changelog.syntaxName), ("Clojure", Clojure.syntaxName), ("Cmake", Cmake.syntaxName), ("Coffee", Coffee.syntaxName), ("Coldfusion", Coldfusion.syntaxName), ("Commonlisp", Commonlisp.syntaxName), ("Cpp", Cpp.syntaxName), ("Cs", Cs.syntaxName), ("Css", Css.syntaxName), ("Curry", Curry.syntaxName), ("D", D.syntaxName), ("Diff", Diff.syntaxName), ("Djangotemplate", Djangotemplate.syntaxName), ("Dockerfile", Dockerfile.syntaxName), ("Dot", Dot.syntaxName), ("Doxygen", Doxygen.syntaxName), ("Doxygenlua", Doxygenlua.syntaxName), ("Dtd", Dtd.syntaxName), ("Eiffel", Eiffel.syntaxName), ("Elixir", Elixir.syntaxName), ("Email", Email.syntaxName), ("Erlang", Erlang.syntaxName), ("Fasm", Fasm.syntaxName), ("Fortran", Fortran.syntaxName), ("Fsharp", Fsharp.syntaxName), ("Gcc", Gcc.syntaxName), ("Glsl", Glsl.syntaxName), ("Gnuassembler", Gnuassembler.syntaxName), ("Go", Go.syntaxName), ("Hamlet", Hamlet.syntaxName), ("Haskell", Haskell.syntaxName), ("Haxe", Haxe.syntaxName), ("Html", Html.syntaxName), ("Idris", Idris.syntaxName), ("Ini", Ini.syntaxName), ("Isocpp", Isocpp.syntaxName), ("Java", Java.syntaxName), ("Javadoc", Javadoc.syntaxName), ("Javascript", Javascript.syntaxName), ("Json", Json.syntaxName), ("Jsp", Jsp.syntaxName), ("Julia", Julia.syntaxName), ("Kotlin", Kotlin.syntaxName), ("Latex", Latex.syntaxName), ("Lex", Lex.syntaxName), ("Lilypond", Lilypond.syntaxName), ("LiterateCurry", LiterateCurry.syntaxName), ("LiterateHaskell", LiterateHaskell.syntaxName), ("Llvm", Llvm.syntaxName), ("Lua", Lua.syntaxName), ("M4", M4.syntaxName), ("Makefile", Makefile.syntaxName), ("Mandoc", Mandoc.syntaxName), ("Markdown", Markdown.syntaxName), ("Mathematica", Mathematica.syntaxName), ("Matlab", Matlab.syntaxName), ("Maxima", Maxima.syntaxName), ("Mediawiki", Mediawiki.syntaxName), ("Metafont", Metafont.syntaxName), ("Mips", Mips.syntaxName), ("Modelines", Modelines.syntaxName), ("Modula2", Modula2.syntaxName), ("Modula3", Modula3.syntaxName), ("Monobasic", Monobasic.syntaxName), ("Nasm", Nasm.syntaxName), ("Noweb", Noweb.syntaxName), ("Objectivec", Objectivec.syntaxName), ("Objectivecpp", Objectivecpp.syntaxName), ("Ocaml", Ocaml.syntaxName), ("Octave", Octave.syntaxName), ("Opencl", Opencl.syntaxName), ("Pascal", Pascal.syntaxName), ("Perl", Perl.syntaxName), ("Php", Php.syntaxName), ("Pike", Pike.syntaxName), ("Postscript", Postscript.syntaxName), ("Prolog", Prolog.syntaxName), ("Pure", Pure.syntaxName), ("Python", Python.syntaxName), ("R", R.syntaxName), ("Relaxng", Relaxng.syntaxName), ("Relaxngcompact", Relaxngcompact.syntaxName), ("Rest", Rest.syntaxName), ("Rhtml", Rhtml.syntaxName), ("Roff", Roff.syntaxName), ("Ruby", Ruby.syntaxName), ("Rust", Rust.syntaxName), ("Scala", Scala.syntaxName), ("Scheme", Scheme.syntaxName), ("Sci", Sci.syntaxName), ("Sed", Sed.syntaxName), ("Sgml", Sgml.syntaxName), ("Sql", Sql.syntaxName), ("SqlMysql", SqlMysql.syntaxName), ("SqlPostgresql", SqlPostgresql.syntaxName), ("Tcl", Tcl.syntaxName), ("Tcsh", Tcsh.syntaxName), ("Texinfo", Texinfo.syntaxName), ("Verilog", Verilog.syntaxName), ("Vhdl", Vhdl.syntaxName), ("Xml", Xml.syntaxName), ("Xorg", Xorg.syntaxName), ("Xslt", Xslt.syntaxName), ("Xul", Xul.syntaxName), ("Yacc", Yacc.syntaxName), ("Yaml", Yaml.syntaxName), ("Zsh", Zsh.syntaxName)] languageShortNames :: [(String, String)] languageShortNames = @@ -172,7 +174,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@, @dockerfile@, @dot@, @doxygen@, @doxygenlua@, @dtd@, @eiffel@, @email@, @erlang@, @fasm@, @fortran@, @fsharp@, @gcc@, @glsl@, @gnuassembler@, @go@, @haskell@, @haxe@, @html@, @idris@, @ini@, @isocpp@, @java@, @javadoc@, @javascript@, @json@, @jsp@, @julia@, @kotlin@, @latex@, @lex@, @lilypond@, @literatecurry@, @literatehaskell@, @llvm@, @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@, @elixir@, @email@, @erlang@, @fasm@, @fortran@, @fsharp@, @gcc@, @glsl@, @gnuassembler@, @go@, @hamlet@, @haskell@, @haxe@, @html@, @idris@, @ini@, @isocpp@, @java@, @javadoc@, @javascript@, @json@, @jsp@, @julia@, @kotlin@, @latex@, @lex@, @lilypond@, @literatecurry@, @literatehaskell@, @llvm@, @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 @@ -221,6 +223,7 @@ "doxygenlua" -> Doxygenlua.highlight "dtd" -> Dtd.highlight "eiffel" -> Eiffel.highlight + "elixir" -> Elixir.highlight "email" -> Email.highlight "erlang" -> Erlang.highlight "fasm" -> Fasm.highlight @@ -230,6 +233,7 @@ "glsl" -> Glsl.highlight "gnuassembler" -> Gnuassembler.highlight "go" -> Go.highlight + "hamlet" -> Hamlet.highlight "haskell" -> Haskell.highlight "haxe" -> Haxe.highlight "html" -> Html.highlight diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/highlighting-kate-0.6.1/changelog new/highlighting-kate-0.6.2/changelog --- old/highlighting-kate-0.6.1/changelog 2015-12-12 21:42:37.000000000 +0100 +++ new/highlighting-kate-0.6.2/changelog 2016-03-18 02:40:36.000000000 +0100 @@ -1,3 +1,10 @@ +highlighting-kate 0.6.2 (17 Mar 2016) + + * Added support for WordDetect (#86). + * Added hamlet. + * Added elixir (supernullset). + * Fix typo in changelog (Matthias C. M. Troffaes). + highlighting-kate 0.6.1 (12 Dec 2015) * Fixed build on GHC 7.0 (Adam Bergmark). @@ -5,7 +12,7 @@ * Removed splitBase flag and ability to compile on base < 4.4. * Add agda tests with unicode input (Matthias C. M. Troffaes). * Fix 'Text.Regex.PCRE.Light: Error in regex: invalid UTF-8 string' - error message (Matthias C. M. Traffaes). + error message (Matthias C. M. Troffaes). * Reapplied isocpp.xml.patch (#57). * Added `languageByFullName` (API change). Changed behavior of `highlightAs` so that languages can match on "full official name" diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/highlighting-kate-0.6.1/highlighting-kate.cabal new/highlighting-kate-0.6.2/highlighting-kate.cabal --- old/highlighting-kate-0.6.1/highlighting-kate.cabal 2015-12-12 21:42:37.000000000 +0100 +++ new/highlighting-kate-0.6.2/highlighting-kate.cabal 2016-03-18 02:40:36.000000000 +0100 @@ -1,5 +1,5 @@ Name: highlighting-kate -Version: 0.6.1 +Version: 0.6.2 Cabal-Version: >= 1.10 Build-Type: Simple Category: Text @@ -146,6 +146,7 @@ Text.Highlighting.Kate.Syntax.Doxygenlua Text.Highlighting.Kate.Syntax.Dtd Text.Highlighting.Kate.Syntax.Eiffel + Text.Highlighting.Kate.Syntax.Elixir Text.Highlighting.Kate.Syntax.Email Text.Highlighting.Kate.Syntax.Erlang Text.Highlighting.Kate.Syntax.Fasm @@ -155,6 +156,7 @@ Text.Highlighting.Kate.Syntax.Glsl Text.Highlighting.Kate.Syntax.Gnuassembler Text.Highlighting.Kate.Syntax.Go + Text.Highlighting.Kate.Syntax.Hamlet Text.Highlighting.Kate.Syntax.Haskell Text.Highlighting.Kate.Syntax.Haxe Text.Highlighting.Kate.Syntax.Html diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/highlighting-kate-0.6.1/xml/elixir.xml new/highlighting-kate-0.6.2/xml/elixir.xml --- old/highlighting-kate-0.6.1/xml/elixir.xml 1970-01-01 01:00:00.000000000 +0100 +++ new/highlighting-kate-0.6.2/xml/elixir.xml 2016-03-18 02:40:36.000000000 +0100 @@ -0,0 +1,260 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE language + SYSTEM 'language.dtd'> +<!-- + Elixir syntax highlighting definition for Kate. + Copyright (C) 2014 by Rubén Caro (ruben.caro.este...@gmail.com) + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. +--> +<!-- Hold the "language" opening tag on a single line, as mentioned in "language.dtd". --> +<language author="Rubén Caro (ruben.caro.este...@gmail.com)" + extensions="*.ex;*.exs;*.eex;*.xml.eex;*.js.eex" + indenter="elixir" + kateversion="3.13" + license="GPL" + mimetype="text/x-elixir" + name="Elixir" + section="Sources" + style="elixir" + version="0.1"> + <highlighting> + <list name="keywords"> + <item>do</item> + <item>end</item> + <item>case</item> + <item>bc</item> + <item>lc</item> + <item>for</item> + <item>if</item> + <item>cond</item> + <item>unless</item> + <item>try</item> + <item>receive</item> + <item>exit</item> + <item>after</item> + <item>rescue</item> + <item>catch</item> + <item>else</item> + <item>raise</item> + <item>throw</item> + <item>quote</item> + <item>unquote</item> + <item>super</item> + <item>and</item> + <item>not</item> + <item>or</item> + <item>when</item> + <item>xor</item> + <item>in</item> + <item>inlist</item> + <item>inbits</item> + </list> + <list name="pseudo-variables"> + <item>nil</item> + <item>true</item> + <item>false</item> + </list> + <list name="definitions"> + <item>fn</item> + <item>defmodule</item> + <item>def</item> + <item>defp</item> + <item>defprotocol</item> + <item>defimpl</item> + <item>defrecord</item> + <item>defstruct</item> + <item>defmacro</item> + <item>defmacrop</item> + <item>defdelegate</item> + <item>defcallback</item> + <item>defmacrocallback</item> + <item>defexception</item> + <item>defoverridable</item> + </list> + <list name="mixin-macros"> + <item>import</item> + <item>require</item> + <item>alias</item> + <item>use</item> + </list> + <contexts> + <context attribute="Normal Text" lineEndContext="#stay" name="Normal"> + <!-- "shebang" line --> + <RegExpr String="#!\/.*" attribute="Keyword" column="0" context="#stay"/> + + <!-- Defined words --> + <keyword String="keywords" attribute="Keyword" context="#stay"/> + <keyword String="definitions" attribute="Definition" context="#stay"/> + <keyword String="pseudo-variables" attribute="Pseudo variable" context="#stay"/> + <keyword String="mixin-macros" attribute="Mixin macros" context="#stay"/> + + <!-- special-character globals --> + <RegExpr String="\b[_A-Z]+[A-Z_0-9]+\b" attribute="Global Constant" context="#stay"/> + + <!-- Generally a module or class name like "File", "MyModule_1", .. --> + <RegExpr String="\b[A-Z]+_*([0-9]|[a-z])[_a-zA-Z0-9]*\b" attribute="Constant" context="#stay"/> + + <!-- Numeric values. Note that we have to allow underscores between two digits (thus the creepy regular expressions). --> + <RegExpr String="\b\-?0[xX]([0-9a-fA-F]|_[0-9a-fA-F])+" attribute="Hex" context="#stay"/> + <RegExpr String="\b\-?0[bB]([01]|_[01])+" attribute="Bin" context="#stay"/> + <RegExpr String="\b\-?0[1-7]([0-7]|_[0-7])*" attribute="Octal" context="#stay"/> + <RegExpr String="\b\-?[0-9]([0-9]|_[0-9])*\.[0-9]([0-9]|_[0-9])*([eE]\-?[1-9]([0-9]|_[0-9])*(\.[0-9]*)?)?" attribute="Float" context="#stay"/> + <RegExpr String="\b\-?[1-9]([0-9]|_[0-9])*\b" attribute="Dec" context="#stay"/> + <Int attribute="Dec" context="#stay"/> + <HlCChar attribute="Char" context="#stay"/> + <DetectChar attribute="Operator" char="." context="#stay"/> + <Detect2Chars attribute="Operator" char="&" char1="&" context="#stay"/> + <Detect2Chars attribute="Operator" char="|" char1="|" context="#stay"/> + <RegExpr String="\s[\?\:\%]\s" attribute="Operator" context="#stay"/> + <RegExpr String="[|&<>\^\+*~\-=]+" attribute="Operator" context="#stay"/> + <!-- regexp hack --> + <RegExpr String="\s!" attribute="Operator" context="#stay"/> + <RegExpr String="/=\s" attribute="Operator" context="#stay" insensitive="0"/> + <StringDetect String="%=" attribute="Operator" context="#stay" insensitive="0"/> + <RegExpr String=":(@{1,2}|\$)?[a-zA-Z_][a-zA-Z0-9_]*[=?!]?" attribute="Symbol" context="#stay"/> + <RegExpr String="\b(@{1,2}|\$)?[a-zA-Z_][a-zA-Z0-9_]*[=?!]?:" attribute="Symbol" context="#stay"/> + <RegExpr String=":\[\]=?" attribute="Symbol" context="#stay"/> + <RegExpr String="@(module)?doc\s+"""" attribute="Attribute" context="Documentation"/> + <StringDetect String=""""" attribute="String" context="Triple Quoted String"/> + <DetectChar attribute="String" char=""" context="Quoted String"/> + <DetectChar attribute="Raw String" char="'" context="Apostrophed String"/> + <DetectChar attribute="Command" char="`" context="Command String"/> + <StringDetect String="?#" attribute="Normal Text" context="#stay"/> + <DetectChar attribute="Comment" char="#" context="General Comment"/> + <DetectChar attribute="Delimiter" char="[" context="#stay"/> + <DetectChar attribute="Delimiter" char="]" context="#stay"/> + <RegExpr String="@[a-zA-Z_0-9]+" attribute="Attribute" context="#stay"/> + <!-- handle the different regular expression formats --> + <DetectChar attribute="Regular Expression" char="/" context="RegEx 1"/> + <DetectChar attribute="Normal Text" char=")" context="#stay"/> + <DetectIdentifier attribute="Normal Text" context="#stay"/> + </context> + <context attribute="Normal Text" lineEndContext="#stay" name="Find closing block brace"> + <DetectChar attribute="Operator" char="}" context="#pop" endRegion="def bracketed block"/> + <IncludeRules context="Normal"/> + </context> + <context attribute="DocComment" lineEndContext="#stay" name="Documentation"> + <StringDetect String=""""" attribute="Attribute" context="#pop"/> + <RegExpr attribute="MarkdownHead" String="^\s*#+\s.*[#]?$"/> + <RegExpr attribute="MarkdownBullet" String="^\s*[\*\+\-]\s"/> + <RegExpr attribute="MarkdownNumlist" String="^\s*[\d]+\.\s"/> + <RegExpr attribute="MarkdownCode" context="Markdown Code" String="^\s*\`\`\`\s*$"/> + <DetectSpaces /> + <IncludeRules context="Normal Text##Markdown"/> + </context> + <context attribute="String" lineEndContext="#stay" name="Triple Quoted String"> + <StringDetect String=""""" attribute="String" context="#pop"/> + </context> + <context attribute="String" lineEndContext="#stay" name="Quoted String"> + <StringDetect String="\\" attribute="String" context="#stay"/> + <RegExpr String="\\\"" attribute="String" context="#stay"/> + <RegExpr String="#@{1,2}" attribute="Substitution" context="Short Subst"/> + <Detect2Chars attribute="Substitution" char="#" char1="{" context="Subst"/> + <DetectChar attribute="String" char=""" context="#pop"/> + </context> + <context attribute="Raw String" lineEndContext="#stay" name="Apostrophed String"> + <StringDetect String="\\" attribute="String" context="#stay"/> + <RegExpr String="\\\'" attribute="String" context="#stay"/> + <DetectChar attribute="Raw String" char="'" context="#pop"/> + </context> + <context attribute="Command" lineEndContext="#stay" name="Command String"> + <StringDetect String="\\" attribute="String" context="#stay"/> + <RegExpr String="\\\`" attribute="String" context="#stay"/> + <RegExpr String="#@{1,2}" attribute="Substitution" context="Short Subst"/> + <Detect2Chars attribute="Substitution" char="#" char1="{" context="Subst"/> + <DetectChar attribute="Command" char="`" context="#pop"/> + </context> + <context attribute="Regular Expression" lineEndContext="#stay" name="RegEx 1"> + <RegExpr String="\\\/" attribute="Regular Expression" context="#stay"/> + <RegExpr String="#@{1,2}" attribute="Substitution" context="Short Subst"/> + <Detect2Chars attribute="Substitution" char="#" char1="{" context="Subst"/> + <RegExpr String="/[uiomxn]*" attribute="Regular Expression" context="#pop"/> + </context> + <!-- Substitutions can be nested --> + <context attribute="Normal Text" lineEndContext="#stay" name="Subst"> + <DetectChar attribute="Substitution" char="}" context="#pop"/> + <!-- Highlight substitution as code. --> + <IncludeRules context="Normal"/> + </context> + <context attribute="Substitution" lineEndContext="#pop" name="Short Subst"> + <!-- Check for e.g.: "#@var#@@xy" --> + <RegExpr String="#@{1,2}" attribute="Substitution" context="#stay"/> + <RegExpr String="\w(?!\w)" attribute="Substitution" context="#pop"/> + </context> + <context attribute="Comment" lineEndContext="#pop" name="Comment Line"> + </context> + <context attribute="Comment" lineEndContext="#pop" name="General Comment"> + </context> + <!-- rules to be included in all regexpr contexts --> + <context attribute="Regular Expression" lineEndContext="#stay" name="regexpr_rules"> + <Detect2Chars attribute="Regular Expression" char="\" char1="\" context="#stay"/> + <RegExpr String="#@{1,2}" attribute="Substitution" context="Short Subst"/> + <Detect2Chars attribute="Substitution" char="#" char1="{" context="Subst"/> + </context> + <context attribute="MarkdownCode" lineEndContext="#stay" name="Markdown Code"> + <RegExpr String="^\s*\`\`\`\s*$" attribute="MarkdownCode" context="#pop"/> + </context> + </contexts> + <itemDatas> + <itemData name="Global Constant" defStyleNum="dsDataType" color="#bb1188" bold="1"/> + <itemData name="Constant" defStyleNum="dsDataType" color="#bb1188" bold="1"/> + <itemData defStyleNum="dsNormal" name="Normal Text"/> + <itemData defStyleNum="dsKeyword" name="Keyword"/> + <itemData defStyleNum="dsOthers" name="Attribute Definition"/> + <itemData color="#0000FF" defStyleNum="dsKeyword" name="Access Control"/> + <itemData defStyleNum="dsKeyword" name="Definition"/> + <itemData defStyleNum="dsKeyword" name="Mixin macros"/> + <itemData defStyleNum="dsDecVal" name="Pseudo variable"/> + <itemData defStyleNum="dsDecVal" name="Dec"/> + <itemData defStyleNum="dsFloat" name="Float"/> + <itemData defStyleNum="dsChar" name="Char"/> + <itemData defStyleNum="dsBaseN" name="Octal"/> + <itemData defStyleNum="dsBaseN" name="Hex"/> + <itemData defStyleNum="dsBaseN" name="Bin"/> + <itemData color="#D40000" defStyleNum="dsString" name="Symbol"/> + <itemData defStyleNum="dsString" name="String"/> + <itemData color="#DD4A4A" defStyleNum="dsString" name="Raw String" selColor="#DD4A4A"/> + <itemData color="#AA3000" defStyleNum="dsString" name="Command"/> + <itemData color="#4000A7" defStyleNum="dsNormal" name="Message"/> + <itemData color="#4A5704" defStyleNum="dsOthers" name="Regular Expression"/> + <itemData defStyleNum="dsOthers" name="Substitution"/> + <itemData defStyleNum="dsNormal" name="Data"/> + <itemData bold="1" defStyleNum="dsDataType" name="Default globals"/> + <itemData defStyleNum="dsDataType" name="Global Variable"/> + <itemData defStyleNum="dsDataType" name="Constant Value"/> + <itemData defStyleNum="dsNormal" name="Member"/> + <itemData defStyleNum="dsOthers" name="Attribute"/> + <itemData defStyleNum="dsOthers" name="Class Variable"/> + <itemData defStyleNum="dsComment" name="Comment"/> + <itemData defStyleNum="dsComment" name="Blockcomment"/> + <itemData defStyleNum="dsComment" name="DocComment"/> + <itemData color="#0000ff" defStyleNum="dsNormal" name="Region Marker"/> + <!-- use these to mark errors and alerts things --> + <itemData defStyleNum="dsError" name="Error"/> + <itemData color="#FF9FEC" defStyleNum="dsNormal" name="Delimiter"/> + <itemData defStyleNum="dsOthers" name="Expression"/> + <itemData color="#FF9FEC" defStyleNum="dsNormal" name="Operator"/> + <itemData name="MarkdownHead" defStyleNum="dsFunction" bold="true"/> + <itemData name="MarkdownBullet" defStyleNum="dsFunction"/> + <itemData name="MarkdownNumlist" defStyleNum="dsFunction"/> + <itemData name="MarkdownCode" defStyleNum="dsFunction"/> + </itemDatas> + </highlighting> + <general> + <comments> + <comment name="singleLine" start="#"/> + </comments> + <keywords casesensitive="1" weakDeliminator="!?"/> + </general> +</language> diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/highlighting-kate-0.6.1/xml/hamlet.xml new/highlighting-kate-0.6.2/xml/hamlet.xml --- old/highlighting-kate-0.6.1/xml/hamlet.xml 1970-01-01 01:00:00.000000000 +0100 +++ new/highlighting-kate-0.6.2/xml/hamlet.xml 2016-03-18 02:40:36.000000000 +0100 @@ -0,0 +1,104 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE language SYSTEM "language.dtd" +[ + <!-- names must start with a letter, ideogram or underscore. \w matches any + word character *or* a number, hence the lookahead --> + <!ENTITY name "(?![0-9])[\w_:][\w.:_-]*"> +]> +<language name="Hamlet" version="0.1" kateversion="2.4" section="Markup" extensions="*.hamlet" author="Bastian Holst (bastianho...@gmx.de)" license="LGPL" indenter="haskell"> +<highlighting> +<contexts> + <context attribute="Normal Text" lineEndContext="#pop" name="Normal Text" > + <RegExpr attribute="Element" context="element" String="<&name;\b" /> + <!-- A widget --> + <StringDetect attribute="Code" context="Code" String="^{"/> + <!-- Something implementing ToHtml --> + <StringDetect attribute="Code" context="Code" String="#{"/> + <!-- An URL --> + <StringDetect attribute="Code" context="Code" String="@{"/> + <!-- A Message --> + <StringDetect attribute="Code" context="Code" String="_{"/> + <DetectChar attribute="Logic" context="Logic" firstNonSpace="true" char="$"/> + </context> + + <context attribute="Element" lineEndContext="#stay" name="element" > + <Detect2Chars attribute="Element" context="#pop" char="/" char1=">" /> + <DetectChar attribute="Element" context="#pop" char=">" /> + <RegExpr attribute="Attribute" context="Attribute" String="&name;" column="0"/> + <RegExpr attribute="Attribute" context="Attribute" String="\s+&name;" /> + <RegExpr attribute="Class" context="#stay" String="\.&name;"/> + <RegExpr attribute="Error" context="#stay" String="\S" /> + </context> + + <context name="Logic" lineEndContext="#pop" attribute="Normal Text"> + <WordDetect attribute="Logic" context="Codeline" String="if"/> + <WordDetect attribute="Logic" context="Codeline" String="elseif"/> + <WordDetect attribute="Logic" context="Assignment" String="forall"/> + <WordDetect attribute="Logic" context="Assignment" String="maybe"/> + <WordDetect attribute="Logic" context="#stay" String="else"/> + <WordDetect attribute="Logic" context="#stay" String="nothing"/> + <RegExpr attribute="Error" context="#stay" String="\S" /> + </context> + + <context name="Code" attribute="Normal Text" lineEndContext="#stay"> + <DetectChar attribute="Code" context="#pop" char="}"/> + <IncludeRules context="##Haskell" /> + </context> + + <context name="Codeline" attribute="Normal Text" lineEndContext="#pop"> + <IncludeRules context="##Haskell" /> + </context> + + <context name="Assignment" attribute="Normal Text" lineEndContext="#pop"> + <StringDetect attribute="Assignment" context="Codeline" String="<-"/> + <IncludeRules context="##Haskell" /> + </context> + + <context name="Attribute" attribute="Other Text" lineEndContext="#stay"> + <DetectChar attribute="Attribute" context="Value" char="=" /> + <DetectChar attribute="Element" context="#pop#pop" char=">"/> + <RegExpr attribute="Error" context="#stay" String="\S" /> + </context> + + <context attribute="Value" lineEndContext="#stay" name="Value"> + <DetectChar attribute="Value" context="Value DQ" char=""" /> + <DetectChar attribute="Value" context="Value SQ" char="'" /> + <StringDetect attribute="Code" context="Value Code" String="@{"/> + <StringDetect attribute="Code" context="Value Code" String="#{"/> + <RegExpr attribute="Value" context="#pop#pop" String="[^"'>\s]+"/> + <RegExpr attribute="Error" context="#stay" String="\S" /> + </context> + + <context name="Value DQ" attribute="Value" lineEndContext="#stay"> + <DetectChar attribute="Value" context="#pop#pop#pop" char=""" /> + </context> + + <context name="Value SQ" attribute="Value" lineEndContext="#stay"> + <DetectChar attribute="Value" context="#pop#pop#pop" char="'" /> + </context> + + <context name="Value Code" attribute="Normal Text" lineEndContext="#stay"> + <DetectChar attribute="Code" context="#pop#pop#pop" char="}"/> + <IncludeRules context="##Haskell" /> + </context> + +</contexts> +<itemDatas> + <itemData name="Normal Text" defStyleNum="dsNormal" /> + <itemData name="Element" defStyleNum="dsKeyword" /> + <itemData name="Attribute" defStyleNum="dsOthers" spellChecking="false" /> + <itemData name="Class" defStyleNum="dsString" color="#a00" spellChecking="false" /> + <itemData name="Value" defStyleNum="dsString" color="#a00" spellChecking="false" /> + <itemData name="Logic" defStyleNum="dsKeyword" spellChecking="false" /> + <itemData name="Code" defStyleNum="dsKeyword" spellChecking="false" /> + <itemData name="Error" defStyleNum="dsError" spellChecking="false" /> + <itemData name="Assignment" defStyleNum="dsOthers" spellChecking="false" /> +</itemDatas> +</highlighting> +<general> + <comments> + <comment name="singleLine" start="#"/> + </comments> + <keywords casesensitive="1"/> +</general> +</language>
