Menu
▾
▴
[9a052e]: / syntax / jsf.jsf Maximize Restore History
628 lines (538 with data), 16.8 kB
# JOE Syntax-Highlighting Description
# for
# JOE Syntax-Highlighting Descriptions
#
# Author: Charles J. Tabony
# Date: 2007-2-13
#
# This is a highlighting description for files like this one.
#
# When CHECKING is defined, it is very aggressive about error checking. The
# idea is that anywhere the highlighted file contains a syntax error, at least
# one visible character should be highlighted as Bad. While that feature is
# useful for finding syntax errors, it is annoying when editing a file, since
# nearly everything is an error until you finish typing it.
#
# In order to not annoy people by default, but keep the option of strictly
# checking syntax, I predicated the stricter checking on the CHECKING parameter.
# By default, things that are incomplete are generally not marked as errors.
# Only things that appear to be actual mistakes are highlighted as Bad. To
# enable the stricter checking, one can highlight the file with the jsf_check
# syntax. jsf_check.jsf simply calls the entire jsf.jsf file with CHECKING
# defined.
#
# The idea is for authors of a jsf file to edit their file, highlight it with
# jsf_check, and then look for any red characters. That way they can check for
# syntax errors before testing the changes.
#####################
# Color Definitions #
#####################
=Idle
=Comment
=Conditional +Precond +Preproc
=Parameter +Ident
=Keyword
=Color +Type
=ColorRef
=State +Ident
=Subr +Ident
=Constant
=Number +Constant
=String +Constant
=StringEscape +Escape +String
=Bad
##################
# Initial States #
##################
# This is a dummy state that simply jumps to comment_or_bad. It is here so that
# when this file calls itself with the STRINGS parameter defined, comment_or_bad
# will effectively be the initial state. comment_or_bad should be the initial
# state because strings and istrings options can only be used as the last option
# of a transition.
.ifdef STRINGS
:strings_initial Idle
* comment_or_bad noeat
.endif
# Each new line (that is not considered bad from the beginning) begins in the
# idle state. The first non-whitespace character determines what the rest of
# the line should contain. Following a strings or istrings option, only strings
# and comments are allowed until the word "done" denotes the end of the list.
:idle Idle
* bad noeat
" \t\n" idle
.ifdef STRINGS
.else
"-" sync_lines_first
"." conditional_first mark recolor=-1
"=" color_definition_first
":" state_first
"*&%" special_character recolor=-1
.endif
"\"" string recolor=-1
.ifdef STRINGS
"\i" special_word mark recolor=-1 buffer
.endif
"#" comment recolor=-1
##############
# Sync Lines #
##############
# Following a '-' should be either the number of sync lines or nothing (meaning
# unlimited). Nothing else other than a comment should appear on the same line.
.ifdef STRINGS
# A sync lines directive should not appear between "[i]strings" and "done".
.else
# If we see a non-digit or a '0', then we have seen the entire sync lines
# directive. The only thing that may appear on the rest of the line is a
# comment. Otherwise there may be more digits in the number.
:sync_lines_first Number
* comment_or_bad noeat
"0" comment_or_bad
"1-9" sync_lines
# Highlight the remainder of the number.
:sync_lines Number
* comment_or_bad noeat
"0-9" sync_lines
.endif
##########################
# Conditional Directives #
##########################
# Following a '.' should be a conditional directive.
.ifdef STRINGS
# A conditional directive should not appear between "[i]strings" and "done".
.else
# Start buffering the conditional directive.
:conditional_first Conditional
* conditional noeat buffer
# Recognize the set of conditional directives.
:conditional Idle
* conditional_unknown noeat strings
"ifdef" ifdef_color
"else" conditional_color
"endif" conditional_color
"subr" subr_color
"end" conditional_color
done
"\c" conditional
# We encountered what looks like a conditional directive but is unrecognized as
# such.
:conditional_unknown Idle
.ifdef CHECKING
* bad_line recolormark noeat
.else
* comment_or_bad noeat
.endif
# We saw a conditional directive that does not take an argument. Nothing else
# other than a comment should appear on the same line.
:conditional_color Conditional
* comment_or_bad noeat
# We saw a ".ifdef" which must be followed by a parameter.
:ifdef_color Conditional
* need_parameter noeat
# We loop over whitespace until we see the first character of the parameter.
:need_parameter Idle
* bad noeat
" \t" need_parameter
"\i" parameter recolor=-1
# Now we highlight the remainder of the parameter.
:parameter Parameter
* comment_or_bad noeat
"\c" parameter
# The following three states are identical to the previous three except the
# color.
:subr_color Conditional
* need_subr noeat
:need_subr Idle
* bad noeat
" \t" need_subr
"\i" subr recolor=-1
:subr Subr
* comment_or_bad noeat
"\c" subr
.endif
####################
# Color Definition #
####################
# Following an '=' should be a color definition.
.ifdef STRINGS
# Color definitions should not appear between "[i]strings" and "done".
.else
# A color name must have at least one character.
:color_definition_first Color
* color_definition
" \t#\n" bad noeat
# Highlight any remaining characters until we see whitespace, a comment, or a
# newline.
:color_definition Color
* color_definition
" \t#\n" colors_ws noeat
# The color name may be followed by zero or more standard colors or attributes,
# ending in a comment or newline.
:colors_ws Idle
* color_bad recolor=-1
" \t" colors_ws
"+" color_ref recolor=-1
"#\n" comment noeat
:color_ref ColorRef
* colors_ws noeat
"\c" color_ref
# We have encountered something that is not recognized as a standard color or
# attribute. Continue to highlight characters as Bad until we see whitespace, a
# comment, or a newline.
:color_bad Bad
* color_bad
" \t#\n" colors_ws noeat
.endif
#########
# State #
#########
# Following a ':' should be a state definition.
.ifdef STRINGS
# New states should not appear between "[i]strings" and "done".
.else
# A state name must begin with an alpha character or an underscore.
:state_first State
* bad noeat
"\i" state
# Subsequent characters in a state name must be alpha-numeric or underscores.
:state State
* bad noeat
"\c" state
" \t" need_state_color recolor=-1
# A state must have a color.
:need_state_color Idle
* state_color recolor=-1
" \t" need_state_color
"#\n" bad noeat
# Highlight any remaining characters until we see whitespace, a comment, or a
# newline.
:state_color Color
* state_color
" \t" context_ws recolor=-1
"#\n" comment_or_bad noeat
# Following the state color, there might be one or more contexts. Loop over
# whitespace until we find something else.
:context_ws Idle
* comment_or_bad noeat
" \t" context_ws
"\i" context mark recolor=-1 buffer
# Here we recognize the possible contexts.
:context Idle
* context_unknown noeat strings
"comment" context_color
"string" context_color
done
"\c" context
# We encountered what looks like a context but is unrecognized as such.
:context_unknown Idle
.ifdef CHECKING
* context_bad recolormark noeat
.else
* context_ws noeat
.endif
# We encountered a valid context.
:context_color Keyword
* context_ws noeat
# We saw something that is not a valid context name with checking enabled.
# Continue to highlight it as Bad until we see whitespace or a comment.
:context_bad Bad
* context_bad
" \t#\n" context_ws noeat
.endif
##############
# Transition #
##############
# A state transition starts with a '*', an '&', or a string.
.ifdef STRINGS
# Transitions must start with a string between "[i]strings" and "done".
.else
# We saw either a '*' or an '&'. Now we need the next state.
:special_character Keyword
* need_next_state noeat
.endif
# We are in a string. Continue until we see the close quote or a newline.
# Highlight escaped characters within the string differently. They start with a
# '\'.
:string String string
* string
"\\" escape recolor=-1
"\"" need_next_state
.ifdef CHECKING
"\n" bad
.else
"\n" bad noeat
.endif
# Highlight an escaped character within a string.
:escape StringEscape string
* string
# Loop over whitespace until we see the first character of the next state.
:need_next_state Idle
* bad noeat
" \t" need_next_state
"\i" next_state recolor=-1
# Now we highlight the remainder of the next state.
:next_state State
* bad noeat
"\c" next_state
" \t" options_ws
"#\n" comment noeat
# Following the next state should be zero or more options. Loop over whitespace
# until we find an option, comment, or newline.
:options_ws Idle
* option_bad recolor=-1
" \t" options_ws
"\i" option mark recolor=-1 buffer
"#\n" comment noeat
# Here we recognize the possible options. The strings and istrings options
# cannot be used between "[i]strings" and "done". Since conditional directives
# cannot be used between "[i]strings" and "done" either, the list must be
# duplicated, once without and once with the strings and istrings options.
:option Idle
.ifdef STRINGS
* option_unknown recolormark noeat strings
"noeat" option_color
"recolor" recolor_color
"mark" option_color
"markend" option_color
"recolormark" option_color
"buffer" option_color
"save_c" option_color
"save_s" option_color
"hold" option_color
"call" call_color
"return" option_color
"reset" option_color
done
.else
* option_unknown recolormark noeat strings
"noeat" option_color
"recolor" recolor_color
"mark" option_color
"markend" option_color
"recolormark" option_color
"buffer" option_color
"save_c" option_color
"save_s" option_color
"strings" strings_color
"istrings" strings_color
"hold" option_color
"call" call_color
"return" option_color
"reset" option_color
done
.endif
"\c" option
# We encountered what looks like an option but is unrecognized as such.
:option_unknown Idle
.ifdef CHECKING
* option_bad recolormark noeat
.else
* options_ws noeat
.endif
# We have encountered an option that does not take an argument. Highlight it
# and continue to look for more options.
:option_color Keyword
* options_ws noeat
.ifdef STRINGS
# The strings and istrings options cannot be used between "[i]strings" and
# "done".
.else
# The strings and istrings options are followed by a list of transitions.
# Rather than duplicate all of the states that highlight transitions, we call
# this entire file as a subroutine and use the STRINGS parameter to disable
# everything else and enable the done keyword. We return to the comment_or_bad
# state since we will return after seeing the done keyword, and nothing but a
# comment should follow the done keyword.
:strings_color Keyword
* comment_or_bad noeat call=jsf(STRINGS)
.endif
# Highlight the recolor option.
:recolor_color Keyword
* recolor_equal noeat
# The recolor option must be followed by an '='. Loop over whitespace until we
# find one.
:recolor_equal Idle
.ifdef CHECKING
* option_bad recolormark noeat
.else
* options_ws noeat
.endif
" \t" recolor_equal
"=" recolor_minus mark
# The recolor option takes an integer argument, and that integer must be
# negative. Thus the '=' must be followed by a minus sign. Loop over
# whitespace until we find one.
:recolor_minus Idle
.ifdef CHECKING
* option_bad recolormark noeat
.else
* options_ws noeat
.endif
" \t" recolor_minus
"-" recolor_amount_first mark recolor=-1
# The first digit of the argument to recolor must be non-zero.
:recolor_amount_first Number
.ifdef CHECKING
* option_bad recolormark noeat
.else
* options_ws recolormark noeat
"0" option_bad recolormark noeat
.endif
"1-9" recolor_amount
# Keep highlighting digits until we see something else.
:recolor_amount Number
* option_bad recolormark recolor=-1
"0-9" recolor_amount
" \t#\n" options_ws noeat
# Highlight the call option.
:call_color Keyword
* call_equal noeat
# The call option must be followed by an '='. Loop over whitespace until we
# find one.
:call_equal Idle
.ifdef CHECKING
* option_bad recolormark noeat
.else
* options_ws noeat
.endif
" \t" call_equal
"=" call_file_or_dot mark
# The first part of the argument to the call option is the name of the file
# containing the subroutine or a '.', implying the current file. Loop over
# whitespace until we see one of those two things.
:call_file_or_dot Idle
.ifdef CHECKING
* option_bad recolormark noeat
.else
* options_ws noeat
.endif
" \t" call_file_or_dot
"\i" call_file mark recolor=-1
"." call_dot mark
# Highlight the remainder of the file name. The file name can be followed by a
# '.', which must then be followed by the name of a subroutine, or by a list of
# parameters in parentheses. The '.', if present, cannot have whitespace on
# either side.
:call_file Subr
.ifdef CHECKING
* option_bad recolormark noeat
.else
* options_ws noeat
.endif
"\c" call_file
"." call_dot mark recolor=-1
" \t(" call_open_paren noeat
# We saw a '.'. The next character must start the name of a subroutine.
:call_dot Idle
.ifdef CHECKING
* option_bad recolormark noeat
.else
* options_ws noeat
.endif
"(" call_dot_bad recolormark noeat
"\i" call_subr mark recolor=-1
# We have seen a dot followed by an open parenthesis. A dot must be followed by
# a subroutine name. Highlight the dot as Bad.
:call_dot_bad Bad
* call_open_paren noeat
# Highlight the remainder of the subroutine name. Following the subroutine name
# must be a list of parameters in parentheses, possibly preceded by whitespace.
:call_subr Subr
.ifdef CHECKING
* option_bad recolormark noeat
.else
* options_ws noeat
.endif
"\c" call_subr
" \t(" call_open_paren noeat
# Loop over whitespace until we find the open parenthesis.
:call_open_paren Idle
.ifdef CHECKING
* option_bad recolormark noeat
.else
* options_ws noeat
.endif
" \t" call_open_paren
"(" call_parameters_ws
# The list of parameters is delimited by whitespace. Loop over whitespace until
# we find either the beginning of a parameter or a close parenthesis. We should
# not see a comment or newline since the list should be terminated by a close
# parenthesis.
:call_parameters_ws Idle
* call_parameter_bad recolor=-1
" \t" call_parameters_ws
"-" call_parameter_undef
"\i" call_parameter recolor=-1
")" options_ws
"#\n" bad noeat
# We saw a "-". The next character should start the parameter being undefined.
:call_parameter_undef Parameter
* call_parameters_ws noeat
"\i" call_parameter recolor=-2
# Highlight the remainder of the parameter.
:call_parameter Parameter
* call_parameters_ws noeat
"\c" call_parameter
# We saw something that is not a valid parameter name. Continue to highlight it
# as Bad until we see whitespace.
:call_parameter_bad Bad
* call_parameter_bad
") \t#\n" call_parameters_ws noeat
# We saw something that is not a valid option name. Continue to highlight it as
# Bad until we see whitespace or a comment.
:option_bad Bad
* option_bad
" \t#\n" options_ws noeat
########
# Done #
########
.ifdef STRINGS
# The special word, "done", can only be used after a strings or istrings option.
# Recognize the done keyword.
:special_word Idle
* bad_line recolormark noeat strings
"done" done_color
done
"\c" special_word
# Highlight the done keyword and return to highlighting things normally, since
# the list of strings has been terminated.
:done_color Keyword
* comment_or_bad return noeat
.endif
##################
# Comment or Bad #
##################
# We have seen everything that should appear on the current line except an
# optional comment. Loop over whitespace until we find a comment or newline.
:comment_or_bad Idle
* bad noeat
" \t" comment_or_bad
"#\n" comment noeat
###########
# Comment #
###########
# Continue to highlight the comment until the end of the line.
:comment Comment comment
* comment
"BFHNTX" comment noeat call=comment_todo.comment_todo()
"\n" idle
#######
# Bad #
#######
.ifdef CHECKING
# We have encountered incorrect syntax. Loop over whitespace until we see the
# first visible character. Highlight that character and the rest of the line as
# Bad.
:bad Bad
* bad_line
" \t\n" bad
.else
# When not performing strict checking, don't go searching for the next visible
# character to highlight as Bad. Simply highlight the rest of the line as Bad,
# even if it is invisible.
:bad Bad
* bad_line noeat
.endif
# Continue to highlight everything as Bad until the end of the line.
:bad_line Bad
* bad_line
"\n" idle
