Hello community, here is the log from the commit of package highlighting-kate for openSUSE:Factory checked in at 2017-02-21 13:46:21 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 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 2016-10-19 13:05:04.000000000 +0200 +++ /work/SRC/openSUSE:Factory/.highlighting-kate.new/highlighting-kate.changes 2017-02-21 13:46:22.597916596 +0100 @@ -1,0 +2,5 @@ +Sun Feb 5 19:32:18 UTC 2017 - psimons@suse.com + +- Update to version 0.6.4 with cabal2obs. + +------------------------------------------------------------------- Old: ---- highlighting-kate-0.6.3.tar.gz New: ---- highlighting-kate-0.6.4.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ highlighting-kate.spec ++++++ --- /var/tmp/diff_new_pack.VreY6q/_old 2017-02-21 13:46:23.237826320 +0100 +++ /var/tmp/diff_new_pack.VreY6q/_new 2017-02-21 13:46:23.237826320 +0100 @@ -1,7 +1,7 @@ # # spec file for package highlighting-kate # -# Copyright (c) 2016 SUSE LINUX GmbH, Nuernberg, Germany. +# Copyright (c) 2017 SUSE LINUX GmbH, Nuernberg, Germany. # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -19,7 +19,7 @@ %global pkg_name highlighting-kate %bcond_with tests Name: %{pkg_name} -Version: 0.6.3 +Version: 0.6.4 Release: 0 Summary: Syntax highlighting License: GPL-2.0 @@ -50,6 +50,7 @@ syntax descriptions (http://kate-editor.org/), so any syntax supported by Kate can be added. An (optional) command-line program is provided, along with a utility for generating new parsers from Kate XML syntax descriptions. +__This library has been deprecated. Please use skylighting instead.__. %package -n ghc-%{name} Summary: Haskell %{name} library @@ -78,7 +79,7 @@ %install %ghc_lib_install -%ghc_fix_dynamic_rpath %{pkg_name} +%ghc_fix_rpath %{pkg_name}-%{version} %check %cabal_test ++++++ highlighting-kate-0.6.3.tar.gz -> highlighting-kate-0.6.4.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/highlighting-kate-0.6.3/README.md new/highlighting-kate-0.6.4/README.md --- old/highlighting-kate-0.6.3/README.md 2016-07-22 06:56:57.000000000 +0200 +++ new/highlighting-kate-0.6.4/README.md 2017-01-31 11:31:49.000000000 +0100 @@ -1,25 +1,19 @@ highlighting-kate ------------------ +================= + +**This library has been deprecated. Please use skylighting +instead +([Hackage](https://hackage.haskell.org/package/skylighting) +| +[GitHub](https://github.com/jgm/skylighting)).** A Haskell source code highlighting library, based on Kate's syntax description files (http://kate-editor.org/), now [part of the KDE Framework's "KTextEditor" component](http://kate-editor.org/2013/11/11/kate-on-5-the-future-of-ktexteditor-and-ka...). It can produce both HTML and LaTeX output. -Currently, the following languages/formats are supported: -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 +Building +-------- To install, use the [stack] tool: @@ -51,7 +45,15 @@ executable, use `--flag highlighting-kate:-executable` with the `stack` commands above. -To run `highlighting-kate`, specify the language name using -s: +Using +----- + +If you want to use highlighting-kate as a library in a Haskell +program, see the API documentation at +https://hackage.haskell.org/package/highlighting-kate. + +To run the `highlighting-kate` program, specify the language +name using `-s`: highlighting-kate -s haskell highlighting-kate.hs > example.html @@ -69,6 +71,9 @@ Alert, Error). For more fine-grained highlighting, users may wish to create their own CSS files that use language-specific classes. +Adding syntax definitions +------------------------- + The parsers in Text/Highlighting/Kate/Syntax were automatically generated from the Kate syntax definitions in the xml directory. You may modify the xml files in this directory, or add new ones, and then regenerate @@ -89,7 +94,7 @@ src/syntax/data There is information on the syntax highlighting definitions at -http://docs.kde.org/stable/en/applications/kate/highlight.html. See also +https://docs.kde.org/stable5/en/applications/katepart/highlight.html. See also http://kate-editor.org/2005/03/24/writing-a-syntax-highlighting-file/. Thanks are due to all the authors of these syntax definitions. @@ -103,6 +108,3 @@ - php.xml: Added fallthrough so `<?php` prefix not needed. - tcsh.xml: Replace invalid character assignment(?) of regex '\s' with ' '. -- base report bugs on the GitHub issue tracker: -<https://github.com/jgm/highlighting-kate/issues>. - diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/highlighting-kate-0.6.3/Text/Highlighting/Kate/Syntax/Ats.hs new/highlighting-kate-0.6.4/Text/Highlighting/Kate/Syntax/Ats.hs --- old/highlighting-kate-0.6.3/Text/Highlighting/Kate/Syntax/Ats.hs 1970-01-01 01:00:00.000000000 +0100 +++ new/highlighting-kate-0.6.4/Text/Highlighting/Kate/Syntax/Ats.hs 2017-01-19 14:25:26.000000000 +0100 @@ -0,0 +1,164 @@ +{- This module was generated from data in the Kate syntax + highlighting file ats.xml, version 0.01, by Kiwamu Okabe (kiwamu@debian.or.jp) -} + +module Text.Highlighting.Kate.Syntax.Ats + (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 = "ATS" + +-- | Filename extensions for this language. +syntaxExtensions :: String +syntaxExtensions = "*.dats;*.sats;*.hats" + +-- | 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 = [("ATS","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 } + ("ATS","Normal") -> return () + ("ATS","Rest-of-file Comment") -> return () + ("ATS","Multiline Comment") -> return () + ("ATS","Multiline C-style Comment") -> return () + ("ATS","Singleline C++ style Comment") -> (popContext) >> pEndLine + ("ATS","String Context") -> return () + ("ATS","Termination Metrics Context") -> return () + ("ATS","Function Keyword Context") -> return () + ("ATS","Universal Context") -> return () + ("ATS","Existential Context") -> 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 $ "abstype abst0ype absprop absview absvtype absviewtype absvt0ype absviewt0ype and as assume begin break continue classdec datasort datatype dataprop dataview datavtype dataviewtype do dynload else end exception extern extype extval if in infix infixl infixr prefix postfix let local macdef macrodef nonfix overload of op rec scase sif sortdef sta stacst stadef stavar staload symelim symintr then try tkindef type typedef propdef viewdef vtypedef viewtypedef val prval var prvar when where for while with withtype withprop withview withvtype withviewtype" +list_special_keywords = Set.fromList $ words $ "$arrpsz $arrptrsize $delay $ldelay $effmask $effmask_ntm $effmask_exn $effmask_ref $effmask_wrt $effmask_all $extern $extkind $extype $extype_struct $extval $lst $lst_t $lst_vt $list $list_t $list_vt $rec $rec_t $rec_vt $record $record_t $record_vt $tup $tup_t $tup_vt $tuple $tuple_t $tuple_vt $raise $showtype $myfilename $mylocation $myfunction #assert #define #elif #elifdef #elifndef #else #endif #error #if #ifdef #ifndef #include #print #then #undef" +list_function_keywords = Set.fromList $ words $ "fn fnx fun prfn prfun praxi castfn implmnt implement primplmnt primplement lam llam fix" + +regex_'60'5cs'2a'5bA'2dZa'2dz'5c0300'2d'5c0326'5c0330'2d'5c0366'5c0370'2d'5c0377'5f'5d'5bA'2dZa'2dz'5c0300'2d'5c0326'5c0330'2d'5c0366'5c0370'2d'5c03770'2d9'5f'27'5d'2a = compileRegex True "`\\s*[A-Za-z\\0300-\\0326\\0330-\\0366\\0370-\\0377_][A-Za-z\\0300-\\0326\\0330-\\0366\\0370-\\03770-9_']*" +regex_'5bA'2dZa'2dz'5c0300'2d'5c0326'5c0330'2d'5c0366'5c0370'2d'5c0377'5f'5d'5bA'2dZa'2dz'5c0300'2d'5c0326'5c0330'2d'5c0366'5c0370'2d'5c03770'2d9'5f'27'5d'2a = compileRegex True "[A-Za-z\\0300-\\0326\\0330-\\0366\\0370-\\0377_][A-Za-z\\0300-\\0326\\0330-\\0366\\0370-\\03770-9_']*" +regex_'7e'3f0'5bxX'5d'5b0'2d9A'2dFa'2df'5f'5d'2b = compileRegex True "~?0[xX][0-9A-Fa-f_]+" +regex_'7e'3f'5b0'2d9'5d'5b0'2d9'5f'5d'2a'28'28'5c'2e'28'5b0'2d9'5d'5b0'2d9'5f'5d'2a'29'3f'28'5beE'5d'5b'2d'2b'5d'3f'5b0'2d9'5d'5b0'2d9'5f'5d'2a'29'3f'29'7c'28'5beE'5d'5b'2d'2b'5d'3f'5b0'2d9'5d'5b0'2d9'5f'5d'2a'29'29 = compileRegex True "~?[0-9][0-9_]*((\\.([0-9][0-9_]*)?([eE][-+]?[0-9][0-9_]*)?)|([eE][-+]?[0-9][0-9_]*))" +regex_'7e'3f'5b0'2d9'5d'5b0'2d9'5f'5d'2a = compileRegex True "~?[0-9][0-9_]*" +regex_'28'5c'5c'5bntbr'27'22'5c'5c'5d'7c'5c'5c'5b0'2d9'5d'7b3'7d'7c'5c'5cx'5b0'2d9A'2dFa'2df'5d'7b2'7d'29 = compileRegex True "(\\\\[ntbr'\"\\\\]|\\\\[0-9]{3}|\\\\x[0-9A-Fa-f]{2})" +regex_'5c'5c'24 = compileRegex True "\\\\$" + +parseRules ("ATS","Normal") = + (((pString False "////" >>= withAttribute CommentTok) >>~ pushContext ("ATS","Rest-of-file Comment")) + <|> + ((pDetect2Chars False '(' '*' >>= withAttribute CommentTok) >>~ pushContext ("ATS","Multiline Comment")) + <|> + ((pDetect2Chars False '/' '*' >>= withAttribute CommentTok) >>~ pushContext ("ATS","Multiline C-style Comment")) + <|> + ((pDetect2Chars False '/' '/' >>= withAttribute CommentTok) >>~ pushContext ("ATS","Singleline C++ style Comment")) + <|> + ((pDetect2Chars False '.' '<' >>= withAttribute DataTypeTok) >>~ pushContext ("ATS","Termination Metrics Context")) + <|> + ((pRegExpr regex_'60'5cs'2a'5bA'2dZa'2dz'5c0300'2d'5c0326'5c0330'2d'5c0366'5c0370'2d'5c0377'5f'5d'5bA'2dZa'2dz'5c0300'2d'5c0326'5c0330'2d'5c0366'5c0370'2d'5c03770'2d9'5f'27'5d'2a >>= withAttribute DataTypeTok)) + <|> + ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_keywords >>= withAttribute KeywordTok)) + <|> + ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_function_keywords >>= withAttribute KeywordTok) >>~ pushContext ("ATS","Function Keyword Context")) + <|> + ((pKeyword " \n\t.():!+,-<=>%&*/;?[]^{|}~\\" list_special_keywords >>= withAttribute DataTypeTok)) + <|> + ((pRegExpr regex_'5bA'2dZa'2dz'5c0300'2d'5c0326'5c0330'2d'5c0366'5c0370'2d'5c0377'5f'5d'5bA'2dZa'2dz'5c0300'2d'5c0326'5c0330'2d'5c0366'5c0370'2d'5c03770'2d9'5f'27'5d'2a >>= withAttribute NormalTok)) + <|> + ((pRegExpr regex_'7e'3f0'5bxX'5d'5b0'2d9A'2dFa'2df'5f'5d'2b >>= withAttribute BaseNTok)) + <|> + ((pRegExpr regex_'7e'3f'5b0'2d9'5d'5b0'2d9'5f'5d'2a'28'28'5c'2e'28'5b0'2d9'5d'5b0'2d9'5f'5d'2a'29'3f'28'5beE'5d'5b'2d'2b'5d'3f'5b0'2d9'5d'5b0'2d9'5f'5d'2a'29'3f'29'7c'28'5beE'5d'5b'2d'2b'5d'3f'5b0'2d9'5d'5b0'2d9'5f'5d'2a'29'29 >>= withAttribute FloatTok)) + <|> + ((pRegExpr regex_'7e'3f'5b0'2d9'5d'5b0'2d9'5f'5d'2a >>= withAttribute DecValTok)) + <|> + (currentContext >>= \x -> guard (x == ("ATS","Normal")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("ATS","Rest-of-file Comment") = + (currentContext >>= \x -> guard (x == ("ATS","Rest-of-file Comment")) >> pDefault >>= withAttribute CommentTok) + +parseRules ("ATS","Multiline Comment") = + (((pDetect2Chars False '*' ')' >>= withAttribute CommentTok) >>~ (popContext)) + <|> + ((pDetect2Chars False '(' '*' >>= withAttribute CommentTok) >>~ pushContext ("ATS","Multiline Comment")) + <|> + (currentContext >>= \x -> guard (x == ("ATS","Multiline Comment")) >> pDefault >>= withAttribute CommentTok)) + +parseRules ("ATS","Multiline C-style Comment") = + (((pDetect2Chars False '*' '/' >>= withAttribute CommentTok) >>~ (popContext)) + <|> + (currentContext >>= \x -> guard (x == ("ATS","Multiline C-style Comment")) >> pDefault >>= withAttribute CommentTok)) + +parseRules ("ATS","Singleline C++ style Comment") = + (currentContext >>= \x -> guard (x == ("ATS","Singleline C++ style Comment")) >> pDefault >>= withAttribute CommentTok) + +parseRules ("ATS","String Context") = + (((pDetectChar False '"' >>= withAttribute StringTok) >>~ (popContext)) + <|> + ((pRegExpr regex_'28'5c'5c'5bntbr'27'22'5c'5c'5d'7c'5c'5c'5b0'2d9'5d'7b3'7d'7c'5c'5cx'5b0'2d9A'2dFa'2df'5d'7b2'7d'29 >>= withAttribute NormalTok)) + <|> + ((pRegExpr regex_'5c'5c'24 >>= withAttribute NormalTok)) + <|> + (currentContext >>= \x -> guard (x == ("ATS","String Context")) >> pDefault >>= withAttribute StringTok)) + +parseRules ("ATS","Termination Metrics Context") = + (((pDetect2Chars False '>' '.' >>= withAttribute DataTypeTok) >>~ (popContext)) + <|> + (currentContext >>= \x -> guard (x == ("ATS","Termination Metrics Context")) >> pDefault >>= withAttribute DataTypeTok)) + +parseRules ("ATS","Function Keyword Context") = + (((pDetectChar False '=' >>= withAttribute NormalTok) >>~ (popContext)) + <|> + ((pDetectChar False '{' >>= withAttribute DataTypeTok) >>~ pushContext ("ATS","Universal Context")) + <|> + ((pDetectChar False '[' >>= withAttribute DataTypeTok) >>~ pushContext ("ATS","Existential Context")) + <|> + ((parseRules ("ATS","Normal"))) + <|> + (currentContext >>= \x -> guard (x == ("ATS","Function Keyword Context")) >> pDefault >>= withAttribute NormalTok)) + +parseRules ("ATS","Universal Context") = + (((pDetectChar False '}' >>= withAttribute DataTypeTok) >>~ (popContext)) + <|> + (currentContext >>= \x -> guard (x == ("ATS","Universal Context")) >> pDefault >>= withAttribute DataTypeTok)) + +parseRules ("ATS","Existential Context") = + (((pDetectChar False ']' >>= withAttribute DataTypeTok) >>~ (popContext)) + <|> + (currentContext >>= \x -> guard (x == ("ATS","Existential Context")) >> pDefault >>= withAttribute DataTypeTok)) + + +parseRules x = parseRules ("ATS","Normal") <|> fail ("Unknown context" ++ show x) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/highlighting-kate-0.6.3/Text/Highlighting/Kate/Syntax.hs new/highlighting-kate-0.6.4/Text/Highlighting/Kate/Syntax.hs --- old/highlighting-kate-0.6.3/Text/Highlighting/Kate/Syntax.hs 2016-09-18 18:06:41.000000000 +0200 +++ new/highlighting-kate-0.6.4/Text/Highlighting/Kate/Syntax.hs 2017-01-19 14:25:30.000000000 +0100 @@ -27,6 +27,7 @@ import qualified Text.Highlighting.Kate.Syntax.Apache as Apache import qualified Text.Highlighting.Kate.Syntax.Asn1 as Asn1 import qualified Text.Highlighting.Kate.Syntax.Asp as Asp +import qualified Text.Highlighting.Kate.Syntax.Ats as Ats import qualified Text.Highlighting.Kate.Syntax.Awk as Awk import qualified Text.Highlighting.Kate.Syntax.Bash as Bash import qualified Text.Highlighting.Kate.Syntax.Bibtex as Bibtex @@ -142,15 +143,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","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"] +languages = ["Abc","Actionscript","Ada","Agda","Alert","Alert_indent","Apache","Asn1","Asp","Ats","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), ("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)] +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), ("Ats", Ats.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), ("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)] +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), ("Ats", Ats.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 = @@ -174,7 +175,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@, @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@. +-- Supported languages: @abc@, @actionscript@, @ada@, @agda@, @alert@, @alert_indent@, @apache@, @asn1@, @asp@, @ats@, @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 @@ -199,6 +200,7 @@ "apache" -> Apache.highlight "asn1" -> Asn1.highlight "asp" -> Asp.highlight + "ats" -> Ats.highlight "awk" -> Awk.highlight "bash" -> Bash.highlight "bibtex" -> Bibtex.highlight diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/highlighting-kate-0.6.3/changelog new/highlighting-kate-0.6.4/changelog --- old/highlighting-kate-0.6.3/changelog 2016-07-22 06:56:57.000000000 +0200 +++ new/highlighting-kate-0.6.4/changelog 2017-01-31 11:29:12.000000000 +0100 @@ -1,3 +1,15 @@ +highlighting-kate 0.6.4 (31 Jan 2017) + + * Add deprecation notice. + * Extend bounds for blaze-html (Simon Jacobi). + * Added syntax ats (Kiwamu Okabe). + * Added xml/language.dtd to cabal file. + * Update link to kate syntax highlighting documentation (Hadley Wickham). + +highlighting-kate 0.6.3 (18 Sep 2016) + + * Updated kate syntax definitions and rebuilt parsers. + highlighting-kate 0.6.2.1 (01 Jul 2016) * Use `#pop` instead of `#stay` if `fallthrough` is true but diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/highlighting-kate-0.6.3/highlighting-kate.cabal new/highlighting-kate-0.6.4/highlighting-kate.cabal --- old/highlighting-kate-0.6.3/highlighting-kate.cabal 2016-09-18 20:19:02.000000000 +0200 +++ new/highlighting-kate-0.6.4/highlighting-kate.cabal 2017-01-31 11:30:23.000000000 +0100 @@ -1,5 +1,5 @@ Name: highlighting-kate -Version: 0.6.3 +Version: 0.6.4 Cabal-Version: >= 1.10 Build-Type: Simple Category: Text @@ -13,6 +13,9 @@ with a utility for generating new parsers from Kate XML syntax descriptions. + __This library has been deprecated. + Please use skylighting instead.__ + License: GPL License-file: LICENSE Author: John MacFarlane @@ -27,6 +30,7 @@ css/hk-kate.css css/hk-pyg.css css/hk-tango.css + xml/language.dtd xml/*.xml xml/*.xml.patch tests/abc.ada @@ -98,7 +102,7 @@ Library Build-Depends: base >= 4.4 && < 5, containers, - parsec, mtl, blaze-html >= 0.4.2 && < 0.9, + parsec, mtl, blaze-html >= 0.4.2 && < 0.10, utf8-string if flag(pcre-light) Build-depends: pcre-light >= 0.4 && < 0.5, bytestring @@ -122,6 +126,7 @@ Text.Highlighting.Kate.Syntax.Apache Text.Highlighting.Kate.Syntax.Asn1 Text.Highlighting.Kate.Syntax.Asp + Text.Highlighting.Kate.Syntax.Ats Text.Highlighting.Kate.Syntax.Awk Text.Highlighting.Kate.Syntax.Bash Text.Highlighting.Kate.Syntax.Bibtex @@ -245,7 +250,7 @@ Executable highlighting-kate Main-Is: highlighting-kate.hs - Build-Depends: base, containers, blaze-html >= 0.4.2 && < 0.9, filepath, + Build-Depends: base, containers, blaze-html >= 0.4.2 && < 0.10, filepath, highlighting-kate Hs-Source-Dirs: extra Default-Language: Haskell98 @@ -267,5 +272,5 @@ Main-Is: test-highlighting-kate.hs Hs-Source-Dirs: tests build-depends: base >= 4, directory, highlighting-kate, filepath, - process, Diff, containers, blaze-html >= 0.4.2 && < 0.9 + process, Diff, containers, blaze-html >= 0.4.2 && < 0.10 default-language: Haskell98 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/highlighting-kate-0.6.3/xml/ats.xml new/highlighting-kate-0.6.4/xml/ats.xml --- old/highlighting-kate-0.6.3/xml/ats.xml 1970-01-01 01:00:00.000000000 +0100 +++ new/highlighting-kate-0.6.4/xml/ats.xml 2016-12-09 14:38:39.000000000 +0100 @@ -0,0 +1,255 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE language SYSTEM "language.dtd" +[ +<!-- Regular expresion constants: --> +<!ENTITY LETTER "A-Za-z\0300-\0326\0330-\0366\0370-\0377"> <!-- Latin-1 letters. --> +<!ENTITY IDENT "[&LETTER;_][&LETTER;0-9_']*"> <!-- ATS identifiers. --> +<!ENTITY ESC "(\\[ntbr'"\\]|\\[0-9]{3}|\\x[0-9A-Fa-f]{2})"> <!-- ATS character code escapes. --> +<!ENTITY DEC "[0-9][0-9_]*"> <!-- Decimal digits with underscores. --> +]> +<language name="ATS" version="0.01" kateversion="2.4" section="Sources" extensions="*.dats;*.sats;*.hats" mimetype="" author="Kiwamu Okabe (kiwamu@debian.or.jp)" license="LGPL"> + <highlighting> + <list name="keywords"> + <item> abstype </item> + <item> abst0ype </item> + <item> absprop </item> + <item> absview </item> + <item> absvtype </item> + <item> absviewtype </item> + <item> absvt0ype </item> + <item> absviewt0ype </item> + <item> and </item> + <item> as </item> + <item> assume </item> + <item> begin </item> + <item> break </item> + <item> continue </item> + <item> classdec </item> + <item> datasort </item> + <item> datatype </item> + <item> dataprop </item> + <item> dataview </item> + <item> datavtype </item> + <item> dataviewtype </item> + <item> do </item> + <item> dynload </item> + <item> else </item> + <item> end </item> + <item> exception </item> + <item> extern </item> + <item> extype </item> + <item> extval </item> + <item> if </item> + <item> in </item> + <item> infix </item> + <item> infixl </item> + <item> infixr </item> + <item> prefix </item> + <item> postfix </item> + <item> let </item> + <item> local </item> + <item> macdef </item> + <item> macrodef </item> + <item> nonfix </item> + <item> overload </item> + <item> of </item> + <item> op </item> + <item> rec </item> + <item> scase </item> + <item> sif </item> + <item> sortdef </item> + <item> sta </item> + <item> stacst </item> + <item> stadef </item> + <item> stavar </item> + <item> staload </item> + <item> symelim </item> + <item> symintr </item> + <item> then </item> + <item> try </item> + <item> tkindef </item> + <item> type </item> + <item> typedef </item> + <item> propdef </item> + <item> viewdef </item> + <item> vtypedef </item> + <item> viewtypedef </item> + <item> val </item> + <item> prval </item> + <item> var </item> + <item> prvar </item> + <item> when </item> + <item> where </item> + <item> for </item> + <item> while </item> + <item> with </item> + <item> withtype </item> + <item> withprop </item> + <item> withview </item> + <item> withvtype </item> + <item> withviewtype </item> + </list> + <list name="special keywords"> + <item> $arrpsz </item> + <item> $arrptrsize </item> + <item> $delay </item> + <item> $ldelay </item> + <item> $effmask </item> + <item> $effmask_ntm </item> + <item> $effmask_exn </item> + <item> $effmask_ref </item> + <item> $effmask_wrt </item> + <item> $effmask_all </item> + <item> $extern </item> + <item> $extkind </item> + <item> $extype </item> + <item> $extype_struct </item> + <item> $extval </item> + <item> $lst </item> + <item> $lst_t </item> + <item> $lst_vt </item> + <item> $list </item> + <item> $list_t </item> + <item> $list_vt </item> + <item> $rec </item> + <item> $rec_t </item> + <item> $rec_vt </item> + <item> $record </item> + <item> $record_t </item> + <item> $record_vt </item> + <item> $tup </item> + <item> $tup_t </item> + <item> $tup_vt </item> + <item> $tuple </item> + <item> $tuple_t </item> + <item> $tuple_vt </item> + <item> $raise </item> + <item> $showtype </item> + <item> $myfilename </item> + <item> $mylocation </item> + <item> $myfunction </item> + <item> #assert </item> + <item> #define </item> + <item> #elif </item> + <item> #elifdef </item> + <item> #elifndef </item> + <item> #else </item> + <item> #endif </item> + <item> #error </item> + <item> #if </item> + <item> #ifdef </item> + <item> #ifndef </item> + <item> #include </item> + <item> #print </item> + <item> #then </item> + <item> #undef </item> + </list> + <list name="function keywords"> + <item> fn </item> + <item> fnx </item> + <item> fun </item> + <item> prfn </item> + <item> prfun </item> + <item> praxi </item> + <item> castfn </item> + <item> implmnt </item> + <item> implement </item> + <item> primplmnt </item> + <item> primplement </item> + <item> lam </item> + <item> llam </item> + <item> fix </item> + </list> + <contexts> + <context attribute="Normal Text" lineEndContext="#stay" name="Normal"> + <StringDetect attribute="Comment" context="Rest-of-file Comment" String="////" beginRegion="comment" /> + <Detect2Chars attribute="Comment" context="Multiline Comment" char="(" char1="*" beginRegion="comment" /> + <Detect2Chars attribute="Comment" context="Multiline C-style Comment" char="/" char1="*" beginRegion="Comment"/> + <Detect2Chars attribute="Comment" context="Singleline C++ style Comment" char="/" char1="/"/> + + <Detect2Chars attribute="Termination Metrics" context="Termination Metrics Context" char="." char1="<" /> + + <RegExpr attribute="Constructor" context="#stay" String="`\s*&IDENT;"/> + + <!-- Identifiers and keywords. --> + <keyword attribute="Keyword" context="#stay" String="keywords" /> + <keyword attribute="Function Keyword" context="Function Keyword Context" String="function keywords" /> + <keyword attribute="Special Keyword" context="#stay" String="special keywords" /> + <RegExpr attribute="Identifier" context="#stay" String="&IDENT;" /> + + <!-- Numeric constants. --> + <!-- Note that they may contain underscores. --> + <RegExpr attribute="Hexadecimal" context="#stay" String="~?0[xX][0-9A-Fa-f_]+" /> + <RegExpr attribute="Float" context="#stay" String="~?&DEC;((\.(&DEC;)?([eE][-+]?&DEC;)?)|([eE][-+]?&DEC;))" /> + <RegExpr attribute="Decimal" context="#stay" String="~?&DEC;" /> + </context> + + <context attribute="Comment" lineEndContext="#stay" name="Rest-of-file Comment"/> + <context attribute="Comment" lineEndContext="#stay" name="Multiline Comment"> + <!-- Support for nested comments --> + <Detect2Chars attribute="Comment" context="#pop" char="*" char1=")" endRegion="comment" /> + <Detect2Chars attribute="Comment" context="Multiline Comment" char="(" char1="*" beginRegion="comment" /> + </context> + <context attribute="Comment" lineEndContext="#stay" name="Multiline C-style Comment"> + <Detect2Chars attribute="Comment" context="#pop" char="*" char1="/" endRegion="Comment"/> + </context> + <context attribute="Comment" lineEndContext="#pop" name="Singleline C++ style Comment"/> + + <context attribute="String" lineEndContext="#stay" name="String Context"> + <DetectChar attribute="String" context="#pop" char=""" /> + <RegExpr attribute="Escaped characters" context="#stay" String="&ESC;" /> + <!-- An underscore at the end of a line in a string indicates --> + <!-- that the string will continue on the next line. --> + <RegExpr attribute="Escaped characters" context="#stay" String="\\$" /> + </context> + + <context attribute="Termination Metrics" lineEndContext="#stay" name="Termination Metrics Context"> + <Detect2Chars attribute="Termination Metrics" context="#pop" char=">" char1="." /> + </context> + + <context attribute="Normal text" lineEndContext="#stay" name="Function Keyword Context"> + <DetectChar attribute="Normal text" context="#pop" char="=" /> + <DetectChar attribute="Universal" context="Universal Context" char="{" /> + <DetectChar attribute="Existential" context="Existential Context" char="[" /> + <IncludeRules context="Normal"/> + </context> + + <context attribute="Universal" lineEndContext="#stay" name="Universal Context"> + <DetectChar attribute="Universal" context="#pop" char="}" /> + </context> + + <context attribute="Existential" lineEndContext="#stay" name="Existential Context"> + <DetectChar attribute="Existential" context="#pop" char="]" /> + </context> +</contexts> + + <itemDatas> + <itemData name="Normal Text" defStyleNum="dsNormal"/> + <itemData name="Identifier" defStyleNum="dsNormal"/> + <itemData name="Keyword" defStyleNum="dsKeyword"/> + <itemData name="Function Keyword" defStyleNum="dsKeyword"/> + <itemData name="Special Keyword" defStyleNum="dsDataType"/> + <itemData name="Termination Metrics" defStyleNum="dsDataType"/> + <itemData name="Universal" defStyleNum="dsDataType"/> + <itemData name="Existential" defStyleNum="dsDataType"/> + <itemData name="Decimal" defStyleNum="dsDecVal"/> + <itemData name="Hexadecimal" defStyleNum="dsBaseN"/> + <itemData name="Float" defStyleNum="dsFloat"/> + <itemData name="Character" defStyleNum="dsChar"/> + <itemData name="String" defStyleNum="dsString"/> + <itemData name="Comment" defStyleNum="dsComment"/> + <itemData name="Constructor" defStyleNum="dsDataType"/> + </itemDatas> + </highlighting> + + <general> + <keywords casesensitive="1" /> + <comments> + <comment name="singleLine" start="//" /> + <comment name="multiLine" start="(*" end="*)" /> + <comment name="multiLine" start="/*" end="*/" /> + <comment name="multiLine" start="////" end="" /> + </comments> + </general> +</language> +<!-- kate: space-indent on; indent-width 2; replace-tabs on; --> diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/highlighting-kate-0.6.3/xml/language.dtd new/highlighting-kate-0.6.4/xml/language.dtd --- old/highlighting-kate-0.6.3/xml/language.dtd 1970-01-01 01:00:00.000000000 +0100 +++ new/highlighting-kate-0.6.4/xml/language.dtd 2016-09-02 12:02:18.000000000 +0200 @@ -0,0 +1,556 @@ +<!-- + Copyright (c) 2001 Joseph Wenninger <jowenn@kde.org> + modified (c) 2002 Anders Lund <anders@alweb.dk> + modified (c) 2003 Simon Huerlimann <simon.huerlimann@access.unizh.ch> + modified (c) 2005 Dominik Haumann <dhdev@gmx.de> + modified (c) 2008 Wilbert Berendsen <info@wilbertberendsen.nl> + + This file describes the XML format used for syntax highlight descriptions + for the Kate text editor (http://kate.kde.org), which is part of the KDE + desktop environment (http://www.kde.org). + You'll find the "Writing a Kate Highlighting XML File HOWTO" at + http://kate.kde.org/doc/hlhowto.php + + This format is identified using the SYSTEM identifier + SYSTEM "language.dtd" + + Files using this format should include a DOCTYPE declaration like this: + <!DOCTYPE language SYSTEM "language.dtd"> + + You can validate your syntax files using checkXML from the development + package of kdelibs: + checkXML yourSyntax.xml + If you see any 'validity error' lines, you should fix them. If you get + a lot of 'No template matches' lines, everything's just fine. You've + produced a valid syntax file! + + It's also possible to use the (much faster) xmllint which comes with the + GNOME (oops:-) XML Library libxml2: + + xmllint - -dtdvalid language.dtd yourSyntax.xml + (don't use a space between the two - That's just because XML + comments don't allow that:-( + + To use your syntax file, copy it to .kde/share/apps/katepart/syntax/ in + your home directory. You have to open a new instance of kwrite/kate to use + the new syntax file. + +TODO + - find a more readable way for the - -dtdvalid stuff, it's just annoying + xml comments don't allow it. +--> + +<!-- Entity declarations + You can use '&per;' instead of '.'. This seems to be useful in <item> elements. + +TODO + - Are there any more such pre-defined entities? +--> +<!ENTITY per "." > + +<!-- Boolean type + Attributes that are of type boolean allow the following values: + 'true', 'TRUE' and '1' all meaning true, + 'false', FALSE' and '0' all meaning false. + + It is encouraged to use 'true' and 'false' instead of the alternatives. +--> +<!ENTITY % boolean "true|false|TRUE|FALSE|0|1"> + +<!-- Default Styles + Allowed predefined default styles for itemData, available are: + - dsNormal, used for normal text + - dsKeyword, used for keywords + - dsDataType, used for data types + - dsDecVal, used for decimal values + - dsBaseN, used for values with a base other than 10 + - dsFloat, used for float values + - dsChar, used for a character + - dsString, used for strings + - dsComment, used for comments + - dsOthers, used for 'other' things + - dsAlert, used for warning messages + - dsFunction, used for function calls + - dsRegionMarker, used for region markers + - dsError, used for error highlighting. +--> +<!ENTITY % defStyles "dsNormal|dsKeyword|dsDataType|dsDecVal|dsBaseN|dsFloat|dsChar|dsString|dsComment|dsOthers|dsAlert|dsFunction|dsRegionMarker|dsError"> + +<!-- Language specification + name: The name of this syntax description. Used in the Highlightning Mode menu + section: The logical group to which this syntax description belongs. Used for sub menus + extensions: A file glob or pattern to decide for which documents to use this syntax description + style: Attribute style that this highlighter provides to kate scripts [optional] + mimetype: A list of mimetypes to decide for which documents to use this syntax description [optional] + version: Version number of this syntax description [optional] + kateversion: Kate version required for using this file [optional] + casesensitive: Whether text is matched case sensitive. [boolean, optional, default=true] FIXME: This is not implemented yet + priority: Priority of this language, if more than one are usable for the file [optional] + author: Name of author of this hl file [optional] + license: License for this hl file [optional] + indenter: Name of the Indenter to use for this highlighting mode per default, like "cstyle" [optional] + hidden: Should it be hidden in menu [boolean, optional, default=false] + +TODO + - Which matches are affected by casesensitive? keyword, RegExpr, StringDetect, WordDetect...? + +WARNING: due to helper scripts, the language opening tag must be on a +*single line* and *cannot* be split in multiple lines. + +--> +<!ELEMENT language (highlighting, general?, spellchecking?)> +<!ATTLIST language + name CDATA #REQUIRED + section NMTOKEN #REQUIRED + extensions CDATA #REQUIRED + version CDATA #REQUIRED + kateversion CDATA #REQUIRED + style CDATA #IMPLIED + mimetype CDATA #IMPLIED + casesensitive (%boolean;) #IMPLIED + priority CDATA #IMPLIED + author CDATA #IMPLIED + license CDATA #IMPLIED + indenter CDATA #IMPLIED + hidden (%boolean;) #IMPLIED +> + +<!-- General options --> +<!ELEMENT general (folding|comments|keywords|indentation|emptyLines)*> + +<!-- List of folding + indentationsensitive: If true, the code folding is indentation based. +--> +<!ELEMENT folding EMPTY> +<!ATTLIST folding + indentationsensitive (%boolean;) #IMPLIED +> + +<!-- List of comments --> +<!ELEMENT comments (comment)+> + +<!-- Comment specification + name: Type of this comment. Allowed are 'singleLine' and 'multiLine' + start: The comment starts with this string + end: The comment ends with this string [optional] + region: The region name of the foldable multiline comment. If you have + beginRegion="Comment" ... endRegion="Comment" you should use + region="Comment". This way uncomment works even if you do not + select all the text of the multiline comment. + position: only availalbe for type singleLine. Default is column0, to insert + the single line comment characters after the whitespaces + (= before the first non space) set position to "afterwhitespace" +--> +<!ELEMENT comment EMPTY> +<!ATTLIST comment + name (singleLine|multiLine) #REQUIRED + start CDATA #REQUIRED + end CDATA #IMPLIED + region CDATA #IMPLIED + position (afterwhitespace) #IMPLIED +> + +<!-- Keyword options + casesensitive: Whether keywords are matched case sensitive. [boolean, optional, default=true] + weakDeliminator: Add weak deliminators [optional, default: ""] + additionalDeliminator: Add deliminators [optional] + wordWrapDeliminator: characters that are used to wrap long lines [optional] + +--> +<!ELEMENT keywords EMPTY> +<!ATTLIST keywords + casesensitive (%boolean;) #IMPLIED + weakDeliminator CDATA #IMPLIED + additionalDeliminator CDATA #IMPLIED + wordWrapDeliminator CDATA #IMPLIED +> + +<!-- Indentation options + mode: indentation mode to use + +TODO + - Explain (weak) deliminators +--> +<!ELEMENT indentation EMPTY> +<!ATTLIST indentation + mode CDATA #IMPLIED +> + +<!-- Treat lines that match a given regular expression as empty line. This is + needed for example in Python for comments (#...), as then the indentation + based folding should ignore the line. + This is only implemented for indentation based folding. If the folding + is not indentation based, the emptyLines are not used. +--> +<!ELEMENT emptyLines (emptyLine*)> + +<!-- One empty line regular expression. + regexpr: The regular expression, example from python: ^\s*#.*$ + casesensitive: Sets, whether the regular expression match is performed case sesitive +--> +<!ELEMENT emptyLine EMPTY> +<!ATTLIST emptyLine + regexpr CDATA #REQUIRED + casesensitive (%boolean;) #IMPLIED +> + + +<!-- Highlighting specification --> +<!ELEMENT highlighting (list*, contexts, itemDatas)> +<!ATTLIST highlighting +> + +<!-- List of items + name: Name of this list +--> +<!ELEMENT list (item)*> +<!ATTLIST list + name CDATA #REQUIRED +> + +<!-- List item + contains string used in <keyword> +--> +<!ELEMENT item (#PCDATA)> + +<!-- List of contexts --> +<!ELEMENT contexts (context)+> + +<!-- context specification + name: The name of this context specification. Used in '*Context' attributes [optional] + attribute: The name of the ItemData to be used for matching text + lineEndContext: Next context if end of line is encountered + lineBeginContext: Next context if begin of line is encountered [optional] + fallthrough: Use a fallthrough context [optional] + fallthroughContext: Fall through to this context [optional] + dynamic: Dynamic context [boolean, optional] + noIndentationBasedFolding: Python uses indentation based folding. However, Python has parts where + it does not use indentation based folding (e.g. for """ strings). In this case + switch to an own context and set this attribute to true. Then the indentation + based folding will ignore this parts and not change folding markers. [optional] + +TODO: + - Explain fallthrough. + - Do we need fallthrough at all? It could be true, if fallthroughContext is set, false otherwise. + - Make lineEndContext optional, defaults to '#stay'. Reasonable? +--> +<!ELEMENT context (keyword | Float | HlCOct | HlCHex | HlCFloat | Int | DetectChar | Detect2Chars | AnyChar | StringDetect | WordDetect | RegExpr | LineContinue | HlCStringChar | RangeDetect | HlCChar | IncludeRules | DetectSpaces | DetectIdentifier)*> +<!ATTLIST context + name CDATA #IMPLIED + attribute CDATA #REQUIRED + lineEndContext CDATA #REQUIRED + lineBeginContext CDATA #IMPLIED + fallthrough (%boolean;) #IMPLIED + fallthroughContext CDATA #IMPLIED + dynamic (%boolean;) #IMPLIED + noIndentationBasedFolding (%boolean;) #IMPLIED +> + +<!-- Common attributes + attribute: The name of the ItemData to be used for matching text + context: The name of the context to go to when this rule matches + beginRegion: Begin a region of type beginRegion [optional] + endRegion: End a region of type endRegion [optional] + firstNonSpace: should this rule only match at first non-space char in line? + column: should this rule only match at given column in line (column == count of chars in front) +--> +<!ENTITY % commonAttributes + "attribute CDATA #IMPLIED + context CDATA #IMPLIED + beginRegion CDATA #IMPLIED + endRegion CDATA #IMPLIED + lookAhead (%boolean;) #IMPLIED + firstNonSpace (%boolean;) #IMPLIED + column CDATA #IMPLIED" +> + +<!-- Detect members of a keyword list + commonAttributes: Common attributes + insensitive: Is this list case-insensitive? [boolean, optional, see note] + String: Name of the list + weakDelimiter: Use weak deliminator + + By default, case sensitivity is determined from <keywords casesensitive> in + <general> (default=true), but can be overridden per-list with 'insensitive'. + +TODO: + - Should be weakDeliminator + - Explain deliminator + - Doesn't seem to be supported in highligh.cpp +--> +<!ELEMENT keyword EMPTY> +<!ATTLIST keyword + %commonAttributes; + insensitive CDATA #IMPLIED + String CDATA #REQUIRED + weakDelimiter CDATA #IMPLIED +> + +<!-- Detect a floating point number + commonAttributes: Common attributes + AnyChar is allowed as a child rule. TODO: The source code allows + *all* rules to be child rules, shall we change the DTD in some way? +--> +<!ELEMENT Float (AnyChar)*> +<!ATTLIST Float + %commonAttributes; +> + +<!-- Detect an octal number + commonAttributes: Common attributes +--> +<!ELEMENT HlCOct EMPTY> +<!ATTLIST HlCOct + %commonAttributes; +> + +<!-- Detect a hexadecimal number + commonAttributes: Common attributes +--> +<!ELEMENT HlCHex EMPTY> +<!ATTLIST HlCHex + %commonAttributes; +> + +<!-- Detect a C-style floating point number + commonAttributes: Common attributes +--> +<!ELEMENT HlCFloat EMPTY> +<!ATTLIST HlCFloat + %commonAttributes; +> + +<!-- Detect C-style character + commonAttributes: Common attributes + +TODO + - Did I get this right? +--> +<!ELEMENT HlCChar EMPTY> +<!ATTLIST HlCChar + %commonAttributes; +> + +<!-- Detect an integer number + commonAttributes: Common attributes + StringDetect is allowed as a child rule. TODO: The source code allows + *all* rules to be child rules, shall we change the DTD in some way? +--> +<!ELEMENT Int (StringDetect)*> +<!ATTLIST Int + %commonAttributes; +> + +<!-- Detect a single character + commonAttributes: Common attributes + char: The character to look for + dynamic: Uses 0 ... 9 as placeholders for dynamic arguments (in fact, first char of arg...) [boolean, optional, default=false] +--> +<!ELEMENT DetectChar EMPTY> +<!ATTLIST DetectChar + %commonAttributes; + char CDATA #REQUIRED + dynamic (%boolean;) #IMPLIED +> + +<!-- Detect two characters + commonAttributes: Common attributes + char: The first character + char1: The second character + dynamic: Uses 0 ... 9 as placeholders for dynamic arguments (in fact, first char of arg...) [boolean, optional, default=false] +--> +<!ELEMENT Detect2Chars EMPTY> +<!ATTLIST Detect2Chars + %commonAttributes; + char CDATA #REQUIRED + char1 CDATA #REQUIRED + dynamic (%boolean;) #IMPLIED +> + +<!-- Detect any group of characters + commonAttributes: Common attributes + String: A string representing the characters to look for + +TODO + - Description is not descriptive enough, I'm not sure what it exactly does:-( +--> +<!ELEMENT AnyChar EMPTY> +<!ATTLIST AnyChar + %commonAttributes; + String CDATA #REQUIRED +> + +<!-- Detect a string + commonAttributes: Common attributes + String: The string to look for + insensitive: Whether the string is matched case INsensitive. [boolean, optional, default=false] + dynamic: Uses %0 ... %9 as placeholders for dynamic arguments [boolean, optional, default=false] + +TODO + - What's default of insensitive? I'm not sure... +--> +<!ELEMENT StringDetect EMPTY> +<!ATTLIST StringDetect + %commonAttributes; + String CDATA #REQUIRED + insensitive (%boolean;) #IMPLIED + dynamic (%boolean;) #IMPLIED +> + +<!-- Detect a word, i.e. a string at word boundaries + commonAttributes: Common attributes + String: The string to look for + insensitive: Whether the string is matched case INsensitive. [boolean, optional, default=false] + dynamic: Uses %0 ... %9 as placeholders for dynamic arguments [boolean, optional, default=false] + +TODO + - What's default of insensitive? I'm not sure... +--> +<!ELEMENT WordDetect EMPTY> +<!ATTLIST WordDetect + %commonAttributes; + String CDATA #REQUIRED + insensitive (%boolean;) #IMPLIED + dynamic (%boolean;) #IMPLIED +> + +<!-- Detect a match of a regular expression + commonAttributes: Common attributes + String: The regular expression pattern + insensitive: Whether the text is matched case INsensitive. [boolean, optional, default=false] + minimal: Wheather to use minimal matching for wild cards in the pattern [boolean, optional, default='false'] + dynamic: Uses %0 ... %9 as placeholders for dynamic arguments [boolean, optional, default=false] +--> +<!ELEMENT RegExpr EMPTY> +<!ATTLIST RegExpr + %commonAttributes; + String CDATA #REQUIRED + insensitive (%boolean;) #IMPLIED + minimal (%boolean;) #IMPLIED + dynamic (%boolean;) #IMPLIED +> + +<!-- Detect a line continuation + commonAttributes: Common attributes +--> +<!ELEMENT LineContinue EMPTY> +<!ATTLIST LineContinue + %commonAttributes; +> + +<!-- Detect a C-style escaped character + commonAttributes: Common attributes + +TODO: + - Did I get this right? Only one character, or a string? +--> +<!ELEMENT HlCStringChar EMPTY> +<!ATTLIST HlCStringChar + %commonAttributes; +> + +<!-- Detect a range of characters + commonAttributes: Common attributes + char: The character starting the range + char1: The character terminating the range +--> +<!ELEMENT RangeDetect EMPTY> +<!ATTLIST RangeDetect + %commonAttributes; + char CDATA #REQUIRED + char1 CDATA #REQUIRED +> + +<!-- Include Rules of another context + context: The name of the context to include + includeAttrib: If this is true, the host context of the IncludeRules + will be given the attribute of the source context +--> +<!ELEMENT IncludeRules EMPTY> +<!ATTLIST IncludeRules + context CDATA #REQUIRED + includeAttrib (%boolean;) #IMPLIED +> + +<!-- Detect all following Spaces +--> +<!ELEMENT DetectSpaces EMPTY> +<!ATTLIST DetectSpaces + %commonAttributes; +> + +<!-- Detect an Identifier ( == LETTER(LETTER|NUMBER|_)*) + --> +<!ELEMENT DetectIdentifier EMPTY> +<!ATTLIST DetectIdentifier + %commonAttributes; +> + +<!-- List of attributes --> +<!ELEMENT itemDatas (itemData)+> +<!ATTLIST itemDatas +> + +<!-- Attribute specification + name CDATA #REQUIRED The name of this attribute + defStyleNum CDATA #REQUIRED The index of the default style to use + color CDATA #IMPLIED Color for this style, either a hex triplet, a name or some other format recognized by Qt [optional] + selColor CDATA #IMPLIED The color for this style when text is selected [optional] + italic CDATA #IMPLIED Whether this attribute should be rendered using an italic typeface [optional, boolean, default=false] + bold CDATA #IMPLIED Whether this attribute should be renederd using a bold typeface [optional, boolean, default=false] + underline CDATA #IMPLIED Whether this attribute should be underlined [optional, boolean, default=false] + strikeOut CDATA #IMPLIED Whether this attribute should be striked out [optional, boolean, default=false] + backgroundColor CDATA #IMPLIED The background color for this style [optional] + selBackgroundColor CDATA #IMPLIED The background color for this style when text is selected [optional] + spellChecking CDATA #IMPLIED Whether this attribute should be spell checked [optional, boolean, default=true] +--> +<!ELEMENT itemData EMPTY> +<!ATTLIST itemData + name CDATA #REQUIRED + defStyleNum (%defStyles;) #REQUIRED + color CDATA #IMPLIED + selColor CDATA #IMPLIED + italic (%boolean;) #IMPLIED + bold (%boolean;) #IMPLIED + underline (%boolean;) #IMPLIED + strikeOut (%boolean;) #IMPLIED + backgroundColor CDATA #IMPLIED + selBackgroundColor CDATA #IMPLIED + spellChecking (%boolean;) #IMPLIED +> + +<!-- encodingPolicy type + Attributes that are of type 'encodingPolicy' allow the following values: + 'EncodeAlways', 'EncodeWhenPresent' and 'EncodeNever' +--> +<!ENTITY % encodingPolicy "EncodeAlways|EncodeWhenPresent|EncodeNever"> + +<!-- Spellchecking specification --> +<!ELEMENT spellchecking (configuration?, encodings?)> +<!ATTLIST spellchecking +> + +<!-- List of character encodings --> +<!ELEMENT encodings (encoding)+> +<!ATTLIST encodings +> + +<!-- Encoding specification + sequence CDATA #REQUIRED Character sequence of the encoding; must not contain new-line characters, i.e. \n or \r + character CDATA #IMPLIED Encoded character; must be of length 1 + ignored (%boolean;) #IMPLIED If true, then the encoding sequence is ignored for spellchecking +--> +<!ELEMENT encoding EMPTY> +<!ATTLIST encoding + string CDATA #REQUIRED + char CDATA #IMPLIED + ignored (%boolean;) #IMPLIED +> + +<!-- Spellchecking configuration + encodingReplacementPolicy (%encodingPolicy;) #IMPLIED Policy for replacing encoded characters in replacements for misspelled words +--> +<!ELEMENT configuration EMPTY> +<!ATTLIST configuration + encodingReplacementPolicy (%encodingPolicy;) #IMPLIED +>