haskell.st - enscript - GNU Enscript
 (HTM) git clone git://thinkerwim.org/enscript.git
 (DIR) Log
 (DIR) Files
 (DIR) Refs
 (DIR) README
 (DIR) LICENSE
       ---
       haskell.st (3358B)
       ---
            1 /**
            2  * Name: haskell
            3  * Description: Haskell programming language.
            4  *
            5  * Simple highlighting treating keywords, comments, strings and type
            6  * expressions specially.
            7  *
            8  * Author: Hans-Wolfgang Loidl <hwloidl@dcs.gla.ac.uk>
            9  * Date: 27/2/97
           10  */
           11 
           12 state haskell extends HighlightEntry
           13 {
           14   /* Comments. */
           15   /\{\-/ {
           16     comment_face (true);
           17     language_print ($0);
           18     call (haskell_comment);
           19     comment_face (false);
           20   }
           21 
           22   /* One line comments. */
           23   /\-\-/ {
           24     comment_face (true);
           25     language_print ($0);
           26     call (eat_one_line);
           27     comment_face (false);
           28   }
           29 
           30   /* Built-in beasts (GHC specific). */
           31   /\b\_/ {
           32     keyword_face (true);
           33     language_print ($0);
           34     call (haskell_builtin);
           35     keyword_face (false);
           36   }
           37 
           38   /* Type declarations. */
           39   /::/ {
           40     type_face (true);
           41     language_print ($0);
           42     call (eat_one_line);
           43     /* call (haskell_type); */
           44     type_face (false);
           45   }
           46 
           47   /* String constants. */
           48   /\"/ {
           49     string_face (true);
           50     language_print ($0);
           51     call (haskell_string);
           52     string_face (false);
           53   }
           54 
           55   /* Pre-processor lines. */
           56   /^#/ {
           57     reference_face (true);
           58     language_print ($0);
           59     call (eat_one_line);
           60     /* call (haskell_ppline); */
           61     reference_face (false);
           62   }
           63 
           64   /* Character constants. */
           65   /'.'|'\\.'/ {
           66     string_face (true);
           67     language_print ($0);
           68     string_face (false);
           69   }
           70 
           71   /* Keywords.
           72      I took that from haskell.el. The True Way to do it would be to grab it
           73      out of the on-line haskell report (actually, The Real True Way would
           74      be to write a Haskell program that extracts different kinds of
           75      keywords and to partially evaluate it wrt the Haskell report; but that
           76      might be a wee overkill).
           77      (let ((strings
           78         '("case" "class" "data" "default" "deriving" "else" "hiding" "if" "import" "in" "\
           79           infix" "infixl" "infixr" "instance" "interface" "let" "module" "of" "renaming" "\
           80           then" "to" "type" "where" )))
           81       (make-regexp strings)
           82      )
           83      ==>
           84      \(infix\|then\)\|c\(ase\|lass\)\|d\(ata\|e\(fault\|riving\)\)\|else\|hiding\|i\([fn]\|mport\|n\(fix[lr]\|stance\|terface\)\)\|let\|module\|of\|renaming\|t\(o\|ype\)\|where
           85    */
           86   /\b((infix|then)|c(ase|lass)|d(ata|e(fault|riving))|else|hiding|i([fn]|mport|n(fix[lr]|stance|terface))|let|module|of|renaming|t(o|ype)|where)\b/ {
           87     keyword_face (true);
           88     language_print ($0);
           89     keyword_face (false);
           90   }
           91 }
           92 
           93 state haskell_comment extends Highlight
           94 {
           95   /\-\}/ {
           96     language_print ($0);
           97     return;
           98   }
           99 }
          100 
          101 /* HWL: for GHC builtin objects like _parGlobal_ i.e. not std Haskell */
          102 state haskell_builtin extends Highlight
          103 {
          104   /(\_\b)| / {
          105     language_print ($0);
          106     return;
          107   }
          108 }
          109 
          110 state haskell_type extends Highlight
          111 {
          112   /* ToDo: Implement type continuation lines:
          113            If the line ends in a -> or the next starts with a -> then we
          114            are still in a type expression
          115   */
          116   /\n/ {
          117     language_print ($0);
          118     return;
          119   }
          120 }
          121 
          122 state haskell_string extends Highlight
          123 {
          124   /\\\\./ {
          125     language_print ($0);
          126   }
          127   /\"/ {
          128     language_print ($0);
          129     return;
          130   }
          131 }
          132 
          133 state haskell_ppline extends Highlight
          134 {
          135   /\/\*/ {
          136     /* Comment within a pre-processor line. */
          137     reference_face (false);
          138     comment_face (true);
          139     language_print ($0);
          140     call (c_comment);
          141     comment_face (false);
          142     reference_face (true);
          143   }
          144   /\n/ {
          145     language_print ($0);
          146     return;
          147   }
          148 }
          149 
          150 
          151 /*
          152 Local variables:
          153 mode: c
          154 End:
          155 */