416 lines
8.4 KiB
Plaintext
416 lines
8.4 KiB
Plaintext
# 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
|