;ELC
;;; Compiled by haakon@haakon-laptop on Thu Aug 22 10:20:06 2013
;;; from file /home/haakon/.emacs.d/elpa/haskell-mode-13.7/haskell-font-lock.el
;;; in Emacs version 24.2.1
;;; with all optimizations.

;;; This file contains utf-8 non-ASCII characters,
;;; and so cannot be loaded into Emacs 22 or earlier.
(and (boundp 'emacs-version)
     (< (aref emacs-version (1- (length emacs-version))) ?A)
     (string-lessp emacs-version "23")
     (error "`%s' was compiled for Emacs 23 or later" load-file-name))

;;;;;;;;;;;;;;;;;


(byte-code "\300\301!\210\300\302!\210\300\303!\207" [require haskell-mode font-lock cl] 2)
#@336 Display \ and -> and such using symbols in fonts.
This may sound like a neat trick, but be extra careful: it changes the
alignment and can thus lead to nasty surprises w.r.t layout.
If t, try to use whichever font is available.  Otherwise you can
set it to a particular font of your preference among `japanese-jisx0208'
and `unicode'.
(custom-declare-variable 'haskell-font-lock-symbols 'nil '(#$ . 635) :group 'haskell :type '(choice (const nil) (const t) (const unicode) (const japanese-jisx0208)))
#@367 Alist mapping Haskell symbols to chars.
Each element has the form (STRING . CHAR) or (STRING CHAR PREDICATE).
STRING is the Haskell symbol.
CHAR is the character with which to represent this symbol.
PREDICATE if present is a function of one argument (the start position
of the symbol) which should return non-nil if this mapping should be disabled
at that position.
(defconst haskell-font-lock-symbols-alist (byte-code "\301\302\303!\205\304>\205\305\303\306\307\"BC\302\310!\205X\302\311!\205X\311\312!\205X\313>\205X\314\310\312\315\316#B\305\310\312\317\320#B\321\310\312\315\322#B\323\310\312\315\324#B\325\310\312\315\326#B\327\310\312\315\330#B\257\302\303!\205\337\331>\205\337\314\303\306\332\"B\321\303\306\333\"B\323\303\306\334\"B\325\303\306\335\"B\336\303\306\337\"B\340\303\306\341\"B\342\303\306\343\"B\344\303\306\345\"B\346\303\306\347\"B\350\303\306\351\"B\352\303\306\353\"B\354\303\306\355\"B\356\303\306\357\"B\360\303\306\361\"B\362\303\306\363\"B\364\303\306\365\"B\366\303\306\367\"B\370\303\306\371\"B\372\303\306\373\"\374E\327\303\306\375\"B\257#\207" [haskell-font-lock-symbols append fboundp decode-char (t unicode) "\\" ucs 955 make-char charsetp japanese-jisx0208 (t japanese-jisx0208) "not" 34 76 38 75 "->" 42 "<-" 43 "=>" 77 "forall" 79 (t unicode) 172 8594 8592 8658 "()" 8709 "==" 8801 "/=" 8802 ">=" 8805 "<=" 8804 "!!" 8252 "&&" 8743 "||" 8744 "sqrt" 8730 "undefined" 8869 "pi" 960 "~>" 8669 "-<" 8610 "::" 8759 "." 8728 haskell-font-lock-dot-is-not-composition 8704] 26) (#$ . 1143))
#@134 Return non-nil if the "." at START is not a composition operator.
This is the case if the "." is part of a "forall <tvar> . <type>".
(defalias 'haskell-font-lock-dot-is-not-composition #[(start) "\212b\210\301\302\303 \304#)\207" [start re-search-backward "\\<forall\\>[^.\"]*\\=" line-beginning-position t] 4 (#$ . 2688)])
(defvar haskell-keyword-face 'font-lock-keyword-face)
(defvar haskell-constructor-face 'font-lock-type-face)
(defvar haskell-definition-face 'font-lock-function-name-face)
(defvar haskell-operator-face 'font-lock-variable-name-face)
(defvar haskell-default-face nil)
#@96 Face with which to fontify literate comments.
Set to `default' to avoid fontification of them.
(defvar haskell-literate-comment-face 'font-lock-doc-face (#$ . 3286))
#@104 Non-nil if we have regexp char classes.
Assume this means we have other useful features from Emacs 21.
(defconst haskell-emacs21-features (string-match "[[:alpha:]]" "x") (#$ . 3459))
#@91 Compose a sequence of ascii chars into a symbol.
Regexp match data 0 points to the chars.
(defalias 'haskell-font-lock-compose-symbol #[(alist) "\306\224\306\225fz\307=\203\310\202%f\311=\203$	TU\203$\312\202%\313\314Sf\206/\315z\n>\204j	f\206;\315z\n>\204j\316\317\"\320>\204j\321\322\306!\f\"A\211:\203s\211A@)@!)\203s\323	\324#\210\202y\325	#\210,\314\207" [start end syntaxes sym-data alist x 0 119 (119) 46 (95 92 119) (95 92) nil 32 get-text-property face (font-lock-doc-face font-lock-string-face font-lock-comment-face) assoc match-string remove-text-properties (composition) compose-region pred] 5 (#$ . 3649)])
(defalias 'haskell-font-lock-symbols-keywords #[nil "\304\305!\205z\306	\306\211\203b@\304\307!\203/\307\nA:\203)\n\211A@)\202+\nA!\202L\304\310!\203K\310\nA:\203E\n\211A@)\202G\nA!\202L\311\203[\312\n@\"\204[\nBA\211\204*\205y\313\314\315\"\311\"\316\317\320DD\321BBDC)\207" [alist haskell-font-lock-symbols-alist x #1=#:--cl-dolist-temp-- fboundp compose-region nil char-displayable-p latin1-char-displayable-p t assoc regexp-opt mapcar car 0 haskell-font-lock-compose-symbol quote (keep)] 6])
#@107 Create fontification definitions for Haskell scripts.
Returns keywords suitable for `font-lock-keywords'.
(defalias 'haskell-font-lock-keywords-create #[(literate) "\306=\203\n\307\202\310\311\312\313\314\315\260\211\316\nQ\f\316Q@\317A\320B\321C\322	\323QD	\324\n\325\n\326\327\260E	\324\n\326\330\n\331\260F	\324\n\326\332A\333\260G	\334A\335RH\336I\337\340\341\342\343J?\205rD\344BC\345 C\346BB\347B\350B\351B\352B\353B\354E\355BF\356BG\357BH\360B\361\362
\363B@\364B\365\n\365Q\366B\367BA\370B\257#BBBBI\371\372!\204\333\306=\203\316\373\343I\374\"BI\202\333\375\376\"\203\333\377IBII.\207" [literate line-prefix varid conid modid qvarid bird "^> ?" "^" "\\b[[:lower:]_][[:alnum:]'_]*\\b" "\\b'?[[:upper:]][[:alnum:]'_]*\\b" "\\b" "\\(\\." "\\)*\\b" "\\." "\\(\\s_\\|\\\\\\)+" "\\S_\\(->\\|\\.\\.\\|::\\|âˆ·\\|<-\\|=>\\|[=@\\|~]\\)\\S_" "\\<\\(_\\|c\\(ase\\|lass\\)\\|d\\(ata\\|e\\(fault\\|riving\\)\\|o\\)\\|else\\|i\\(mport\\|n\\(fix[lr]?\\|stance\\)\\|[fn]\\)\\|let\\|module\\|mdo\\|newtype\\|of\\|rec\\|proc\\|t\\(hen\\|ype\\)\\|where\\)\\>" "\\(\\(\"\\|" "[ 	]*\\\\\\)\\([^\"\\\\\n]\\|\\\\.\\)*\\(\"\\|\\\\[ 	]*$\\)\\|'\\([^'\\\\\n]\\|\\\\.[^'\n]*\\)'\\)" "\\(" "\\)\\s-*\\([\n]*\\s-+\\)*\\(" "\\|" "\\|::\\|âˆ·\\|=\\||\\|\\s(\\|[0-9\"']\\)" "\\)\\s-*`\\(" "\\)`" "\\)\\s-*\\(" "\\)" "(\\(" "\\))" nil ("^<<<<<<< .*$" 0 'font-lock-warning-face t) ("^=======" 0 'font-lock-warning-face t) ("^>>>>>>> .*$" 0 'font-lock-warning-face t) ("^#.*$" 0 'font-lock-preprocessor-face t) append (1 font-lock-string-face) haskell-font-lock-symbols-keywords (1 (symbol-value 'haskell-keyword-face)) (1 (symbol-value 'haskell-operator-face)) ("\\<import[ 	]+\\(?:\\(safe\\>\\)[ 	]*\\)?\\(?:\\(qualified\\>\\)[ 	]*\\)?[^ 	\n()]+[ 	]*\\(?:\\(\\<as\\>\\)[ 	]*[^ 	\n()]+[ 	]*\\)?\\(\\<hiding\\>\\)?" (1 (symbol-value 'haskell-keyword-face) nil lax) (2 (symbol-value 'haskell-keyword-face) nil lax) (3 (symbol-value 'haskell-keyword-face) nil lax) (4 (symbol-value 'haskell-keyword-face) nil lax)) (1 (symbol-value 'haskell-operator-face)) ("\\<\\(foreign\\)[ 	]+\\(import\\)[ 	]+\\(?:\\(ccall\\|stdcall\\|cplusplus\\|jvm\\|dotnet\\)[ 	]+\\)?\\(?:\\(safe\\|unsafe\\|interruptible\\)[ 	]+\\)?" (1 (symbol-value 'haskell-keyword-face) nil lax) (2 (symbol-value 'haskell-keyword-face) nil lax) (3 (symbol-value 'haskell-keyword-face) nil lax) (4 (symbol-value 'haskell-keyword-face) nil lax)) (1 (symbol-value 'haskell-operator-face)) ("\\<\\(foreign\\)[ 	]+\\(export\\)[ 	]+\\(?:\\(ccall\\|stdcall\\|cplusplus\\|jvm\\|dotnet\\)[ 	]+\\)?" (1 (symbol-value 'haskell-keyword-face) nil lax) (2 (symbol-value 'haskell-keyword-face) nil lax) (3 (symbol-value 'haskell-keyword-face) nil lax)) ((1 (symbol-value 'haskell-definition-face))) ((2 (symbol-value 'haskell-definition-face))) ((2 (symbol-value 'haskell-definition-face))) ((1 (symbol-value 'haskell-definition-face))) ("(\\(,*\\|->\\))" 0 (symbol-value 'haskell-constructor-face)) ("\\[\\]" 0 (symbol-value 'haskell-constructor-face)) (0 (symbol-value 'haskell-default-face)) (0 (symbol-value 'haskell-constructor-face)) "`" (0 (symbol-value 'haskell-operator-face)) (0 (symbol-value 'haskell-constructor-face)) (0 (if (eq (char-after (match-beginning 0)) 58) haskell-constructor-face haskell-operator-face)) boundp font-lock-syntactic-keywords ("^[^>\n].*$" 0 haskell-comment-face t) (("^>" 0 haskell-default-face t)) memql (latex tex) (haskell-fl-latex-comments 0 'font-lock-comment-face t) qconid sym reservedsym reservedid string-and-char topdecl-var topdecl-var2 topdecl-sym topdecl-sym2 keywords haskell-emacs21-features] 27 (#$ . 4839)])
#@104 Position of cache point used by `haskell-fl-latex-cache-in-comment'.
Should be at the start of a line.
(defvar haskell-fl-latex-cache-pos nil (#$ . 8489))
#@153 If `haskell-fl-latex-cache-pos' is outside a
\begin{code}..\end{code} block (and therefore inside a comment),
this variable is set to t, otherwise nil.
(defvar haskell-fl-latex-cache-in-comment nil (#$ . 8651))
#@129 Sets `match-data' according to the region of the buffer before end
that should be commented under LaTeX-style literate scripts.
(defalias 'haskell-fl-latex-comments #[(end) "`\211	U?\205A\n=\204$\304\305e\306#\205\307\225?\205 \306b\210\2038\310\311	\312#\210\313`D!\210`\202A\310\314	\306#\205A`)\207" [start end haskell-fl-latex-cache-pos haskell-fl-latex-cache-in-comment re-search-backward "^\\(\\(\\\\begin{code}\\)\\|\\(\\\\end{code}\\)\\)$" t 2 re-search-forward "^\\\\begin{code}$" move set-match-data "^\\\\end{code}$"] 5 (#$ . 8869)])
(defconst haskell-basic-syntactic-keywords '(("\\Sw\\('\\)\\([^\\'\n]\\|\\\\.[^\\'\n \"}]*\\)\\('\\)" (1 "|") (3 "|")) ("\\(\\\\\\)(" (1 ".")) ("\\s_\\{3,\\}" (0 (cond ((numberp (nth 4 (syntax-ppss))) nil) ((string-match "\\`-*\\'" (match-string 0)) nil) (t "_"))))))
(defconst haskell-bird-syntactic-keywords (cons '("^[^\n>]" (0 "<")) haskell-basic-syntactic-keywords))
(defconst haskell-latex-syntactic-keywords (append '(("^\\\\begin{code}\\(\n\\)" 1 "!") ("\\`\\(.\\|\n\\)" (1 "!")) ("^\\(\\\\\\)end{code}$" 1 "!")) haskell-basic-syntactic-keywords))
#@57 If non-nil try to highlight Haddock comments specially.
(custom-declare-variable 'haskell-font-lock-haddock '(boundp 'font-lock-doc-face) '(#$ . 9992) :type 'boolean :group 'haskell)
(defvar haskell-font-lock-seen-haddock nil)
(make-variable-buffer-local 'haskell-font-lock-seen-haddock)
#@50 `font-lock-syntactic-face-function' for Haskell.
(defalias 'haskell-syntactic-face-function #[(state) "\3068\203	\207\3078\310=\204 \n\311=\203\"\3128Sf\313>\203\"\207\f\203{\212\3128b\210\314\315!\206n
\205n\314\316!\205n\317\211\211\204k\320 \211\203k\321\322!\203k\320\323!=\203k\314\324!\203k\325\224\211\203F*)\203{\326\305!\210\327\207\207" [state font-lock-string-face haskell-literate haskell-literate-comment-face haskell-font-lock-haddock haskell-font-lock-seen-haddock 3 7 syntax-table bird 8 (nil 10) looking-at "\\(-- \\|{-\\)[ \\t]*[|^]" "-- " nil line-beginning-position forward-comment -1 2 "--\\( [|^]\\)?" 1 make-local-variable t pos doc font-lock-doc-face font-lock-comment-face] 3 (#$ . 10286)])
#@49 Font lock definitions for non-literate Haskell.
(defconst haskell-font-lock-keywords (haskell-font-lock-keywords-create nil) (#$ . 11046))
#@56 Font lock definitions for Bird-style literate Haskell.
(defconst haskell-font-lock-bird-literate-keywords (haskell-font-lock-keywords-create 'bird) (#$ . 11191))
#@57 Font lock definitions for LaTeX-style literate Haskell.
(defconst haskell-font-lock-latex-literate-keywords (haskell-font-lock-keywords-create 'latex) (#$ . 11359))
(defalias 'haskell-font-lock-choose-keywords #[nil "\305\300!\205\211\306=\203\n\202\307	\310\"\203\202\f)\207" [haskell-literate literate haskell-font-lock-bird-literate-keywords haskell-font-lock-latex-literate-keywords haskell-font-lock-keywords boundp bird memql (latex tex)] 4])
(defalias 'haskell-font-lock-choose-syntactic-keywords #[nil "\305\300!\205\211\306=\203\n\202\307	\310\"\203\202\f)\207" [haskell-literate literate haskell-bird-syntactic-keywords haskell-latex-syntactic-keywords haskell-basic-syntactic-keywords boundp bird memql (latex tex)] 4])
#@47 Locally set `font-lock-defaults' for Haskell.
(defalias 'haskell-font-lock-defaults-create #[nil "\301\300!\210\302\211\207" [font-lock-defaults make-local-variable (haskell-font-lock-choose-keywords nil nil ((39 . "w") (95 . "w")) nil (font-lock-syntactic-keywords . haskell-font-lock-choose-syntactic-keywords) (font-lock-syntactic-face-function . haskell-syntactic-face-function) (parse-sexp-lookup-properties . t))] 2 (#$ . 12122)])
#@2202 Turns on font locking in current buffer for Haskell 1.4 scripts.

Changes the current buffer's `font-lock-defaults', and adds the
following variables:

   `haskell-keyword-face'      for reserved keywords and syntax,
   `haskell-constructor-face'  for data- and type-constructors, class names,
                               and module names,
   `haskell-operator-face'     for symbolic and alphanumeric operators,
   `haskell-default-face'      for ordinary code.

The variables are initialised to the following font lock default faces:

   `haskell-keyword-face'      `font-lock-keyword-face'
   `haskell-constructor-face'  `font-lock-type-face'
   `haskell-operator-face'     `font-lock-function-name-face'
   `haskell-default-face'      <default face>

Two levels of fontification are defined: level one (the default)
and level two (more colour).  The former does not colour operators.
Use the variable `font-lock-maximum-decoration' to choose
non-default levels of fontification.  For example, adding this to
.emacs:

  (setq font-lock-maximum-decoration '((haskell-mode . 2) (t . 0)))

uses level two fontification for `haskell-mode' and default level for
all other modes.  See documentation on this variable for further
details.

To alter an attribute of a face, add a hook.  For example, to change
the foreground colour of comments to brown, add the following line to
.emacs:

  (add-hook 'haskell-font-lock-hook
      (lambda ()
          (set-face-foreground 'haskell-comment-face "brown")))

Note that the colours available vary from system to system.  To see
what colours are available on your system, call
`list-colors-display' from emacs.

To turn font locking on for all Haskell buffers, add this to .emacs:

  (add-hook 'haskell-mode-hook 'turn-on-haskell-font-lock)

To turn font locking on for the current buffer, call
`turn-on-haskell-font-lock'.  To turn font locking off in the current
buffer, call `turn-off-haskell-font-lock'.

Bird-style literate Haskell scripts are supported: If the value of
`haskell-literate-bird-style' (automatically set by the Haskell mode
of Moss&Thorn) is non-nil, a Bird-style literate script is assumed.

Invokes `haskell-font-lock-hook' if not nil.
(defalias 'turn-on-haskell-font-lock #[nil "\300 \210\301\302!\210\303 \207" [haskell-font-lock-defaults-create run-hooks haskell-font-lock-hook turn-on-font-lock] 2 (#$ . 12568)])
#@43 Turns off font locking in current buffer.
(defalias 'turn-off-haskell-font-lock #[nil "\300\301!\207" [font-lock-mode -1] 2 (#$ . 14956)])
(provide 'haskell-font-lock)
