JOE - Joe's own editor Mercurial

416 lines (352 with data), 8.6 kB

# 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