← Back
Editing: sml.jsf
# JOE syntax highlight file for SML # A (deterministic) state machine which performs lexical analysis of SML. # (This is the "assembly language" of syntax highlighting. A separate # program could be used to convert a regular expression NFA syntax into this # format). # Each state begins with ':<name> <color-name>' # <color-name> is the color used for characters eaten by the state # (really a symbol for a user definable color). # The first state defined is the initial state. # Within a state, define transitions (jumps) to other states. Each # jump has the form: <character-list> <target-state> [<option>s] # There are two ways to specify <character-list>s, either * for any # character not otherwise specified, or a literal list of characters within # quotes (ranges and escape sequences allows). When the next character # matches any in the list, a jump to the target-state is taken and the # character is eaten (we advance to the next character of the file to be # colored). # # The * transition should be the first transition specified in the state. # # There are several options: # noeat do not eat the character, instead feed it to the next state # (this tends to make the states smaller, but be careful: you # can make infinite loops). 'noeat' implies 'recolor=-1'. # # recolor=-N Recolor the past N characters with the color of the # target-state. For example once /* is recognized as the # start of C comment, you want to color the /* with the C # comment color. # # buffer start copying characters to a buffer, beginning with this # one (it's ok to not terminate buffering with a matching # 'strings' option- the buffer is limited to leading 19 # characters). # # strings A list of strings follows. If the buffer matches any of the # given strings, a jump to the target-state in the string list # is taken instead of the normal jump. # # istrings Same as strings, but case is ignored. # # hold Stop buffering string- a future 'strings' or 'istrings' will # look at contents of buffer at this point. Useful for distinguishing # commands and function calls in some languages 'write 7' is a command # 'write (' is a function call- hold lets us stop at the space and delay # the string lookup until the ( or 7. # # The format of the string list is: # # "string" <target-state> [<options>s] # "string" <target-state> [<options>s] # done # # (all of the options above are allowed except "strings", "istrings" and "noeat". noeat is # always implied after a matched string). # # Weirdness: only states have colors, not transitions. This means that you # sometimes have to make dummy states with '* next-state noeat' just to get # a color specification. =Idle =Ident =Bad =Comment =Constant =String +Constant =Number +Constant =Boolean +Constant =StringEscape +Escape +String =Type =Keyword =Operator +Keyword =Control =Conditional +Statement +Keyword =Loop +Statement +Keyword =StorageClass +Keyword =DefinedIdent +Ident =DefinedFunction +DefinedIdent =DefinedType +Type +DefinedIdent :expr Idle * expr ".,[{})];" control recolor=-1 # . or ... both control "(" bracket recolor=-1 "_" underline recolor=-1 "!%&$+/:<=>?@`^|*\-" operator buffer recolor=-1 "#" hash recolor=-1 "~" tilde recolor=-1 "0" zero recolor=-1 "1-9" decimal recolor=-1 "\"" string recolor=-1 "a-zA-Z" id buffer recolor=-1 :bad Bad * expr :control Control * expr noeat :bracket Control * expr noeat "*" comment1 recolor=-2 :underline Keyword * expr noeat "a-zA-Z" kw :operator Operator * expr noeat strings ":>" colon ":" colon "::" control # can be overloaded, but you would burn in hell ":=" control # ditto "=" control # only in some contexts is it _really_ control "->" control "=>" control "|" control done "!%&$+/:<=>?@~`^|#*\-" operator :colon Control * type1 noeat :hash Control * expr noeat "!%&$+/:<=>?@~`^|#*\-" operator recolor=-2 "\"" string recolor=-2 :tilde Operator * expr noeat "!%&$+/:<=>?@~`^|#*\-" operator "0" zero recolor=-2 "1-9" decimal recolor=-2 :zero Number * expr noeat "0-9" decimal "w" word buffer "x" hex1 buffer "e" epart buffer "E" epart buffer "." float1 :word Number * id noeat recolor=-2 "0-9" decimal "x" hexword :hexword Number * id noeat recolor=-3 "0-9a-fA-F" hex :hex1 Number * id noeat recolor=-2 "0-9a-fA-F" hex :hex Number * expr noeat "0-9a-fA-F" hex :decimal Number * expr noeat "0-9" decimal "." float1 "e" epart buffer "E" epart buffer # trailing digits required in SML (unlike OCaml) :float1 Number * bad noeat "0-9" float :float Number * expr noeat "0-9" float "e" epart buffer "E" epart buffer :epart Number * id noeat recolor=-2 "0-9" enum "~" epart # bug: 3e~~3 :enum Number * expr noeat "0-9" enum :string String string * string "\"" expr "\n" bad "\\" string_escape recolor=-1 :string_escape StringEscape string * bad noeat "abfnrtv\"\\" string "^" string_carret "u" string_hex1 "0-9" string_decimal2 "\n\r\f\t " string_eatws :string_carret StringEscape string * bad noeat "ABCDEFGHIJKLMNOPQRSTUVWXYZ\\^_" string :string_eatws StringEscape string * bad noeat "\n\r\f\t " string_eatws "\\" string :string_hex1 StringEscape string * bad noeat "0-9a-fA-F" string_hex2 :string_hex2 StringEscape string * bad noeat "0-9a-fA-F" string_hex3 :string_hex3 StringEscape string * bad noeat "0-9a-fA-F" string_hex4 :string_hex4 StringEscape string * bad noeat "0-9a-fA-F" string :string_decimal2 StringEscape string * bad noeat "0-9" string_decimal3 :string_decimal3 StringEscape string * bad noeat "0-9" string :id Ident * expr noeat strings "_" kw "ann" kw "and" kw "as" kw "case" cond "do" loop "else" cond "end" cond "exception" kw "false" bool "fn" kw "fun" kw "functor" kw "handle" kw "if" cond "in" kw "include" kw "infix" kw "infixr" kw "let" kw "local" kw "nil" const "nonfix" kw "of" kw "op" kw "open" kw "raise" kw "rec" kw "sharing" kw "sig" kw "signature" kw "struct" kw "structure" kw "then" kw "true" bool "val" val "where" kw "while" loop "with" kw "abstype" kwtype "datatype" kwtype "eqtype" kwtype "type" kwtype "withtype" kwtype "before" operatorkw "o" operatorkw "orelse" operatorkw "andalso" operatorkw "div" operatorkw "mod" operatorkw done "a-zA-Z0-9_'" id :kw Keyword * expr noeat :operatorkw Operator * expr noeat :kwtype StorageClass * kwtype1 noeat :const Constant * expr noeat :cond Conditional * expr noeat :loop Loop * expr noeat :bool Boolean * expr noeat :val Keyword * val_preident noeat :val_preident Idle * val_ident noeat " \t" val_preident :val_ident DefinedIdent * expr noeat "a-zA-Z0-9_'" val_ident :kwtype1 DefinedType * expr noeat "=" typeval recolor=-1 "a-zA-Z0-9_'., :|*>\t\-" kwtype1 "({" kwtype2 :kwtype2 Type * expr noeat ")}" kwtype1 "a-zA-Z0-9_'., :|*>\t\n\-" kwtype2 "({" kwtype3 :kwtype3 Type * expr noeat ")}" kwtype2 "a-zA-Z0-9_'., :|*>\t\n\-" kwtype3 "({" expr # too deep nesting :typeval Control * type1 noeat " \t\n" typeval :type1 Type * expr noeat "a-zA-Z0-9_'., :|*>\t\-" type1 "({" type2 :type2 Type * expr noeat ")}" type1 "a-zA-Z0-9_'., :|*>\t\n\-" type2 "({" type3 :type3 Type * expr noeat ")}" type2 "a-zA-Z0-9_'., :|*>\t\n\-" type3 "({" type4 :type4 Type * expr noeat ")}" type3 "a-zA-Z0-9_'., :|*>\t\n\-" type4 "({" expr # too deep nesting :comment1 Comment comment * comment1 "(" nestcomment1 "*" endcomment1 "BFHNTX" comment1 noeat call=comment_todo.comment_todo() :nestcomment1 Comment comment * comment1 noeat "*" comment2 :endcomment1 Comment comment * comment1 noeat ")" expr "*" endcomment1 :comment2 Comment comment * comment2 "(" nestcomment2 "*" endcomment2 "BFHNTX" comment2 noeat call=comment_todo.comment_todo() :nestcomment2 Comment comment * comment2 noeat "*" comment3 :endcomment2 Comment comment * comment2 noeat ")" comment1 "*" endcomment2 :comment3 Comment comment * comment3 "(" nestcomment3 "*" endcomment3 "BFHNTX" comment3 noeat call=comment_todo.comment_todo() :nestcomment3 Comment comment * comment3 noeat "*" expr # too deep nesting :endcomment3 Comment comment * comment3 noeat ")" comment2 "*" endcomment3
Save File
Cancel