# encoding: utf-8
module CodeRay
module Scanners
# Scanner for the Lua[http://lua.org] programming lanuage.
#
# The language’s complete syntax is defined in
# {the Lua manual}[http://www.lua.org/manual/5.2/manual.html],
# which is what this scanner tries to conform to.
class Lua < Scanner
register_for :lua
file_extension 'lua'
title 'Lua'
# Keywords used in Lua.
KEYWORDS = %w[and break do else elseif end
for function goto if in
local not or repeat return
then until while
]
# Constants set by the Lua core.
PREDEFINED_CONSTANTS = %w[false true nil]
# The expressions contained in this array are parts of Lua’s `basic'
# library. Although it’s not entirely necessary to load that library,
# it is highly recommended and one would have to provide own implementations
# of some of these expressions if one does not do so. They however aren’t
# keywords, neither are they constants, but nearly predefined, so they
# get tagged as `predefined' rather than anything else.
#
# This list excludes values of form `_UPPERCASE' because the Lua manual
# requires such identifiers to be reserved by Lua anyway and they are
# highlighted directly accordingly, without the need for specific
# identifiers to be listed here.
PREDEFINED_EXPRESSIONS = %w[
assert collectgarbage dofile error getmetatable
ipairs load loadfile next pairs pcall print
rawequal rawget rawlen rawset select setmetatable
tonumber tostring type xpcall
]
# Automatic token kind selection for normal words.
IDENT_KIND = CodeRay::WordList.new(:ident).
add(KEYWORDS, :keyword).
add(PREDEFINED_CONSTANTS, :predefined_constant).
add(PREDEFINED_EXPRESSIONS, :predefined)
protected
# Scanner initialization.
def setup
@state = :initial
@brace_depth = 0
end
# CodeRay entry hook. Starts parsing.
def scan_tokens(encoder, options)
state = options[:state] || @state
brace_depth = @brace_depth
num_equals = nil
until eos?
case state
when :initial
if match = scan(/\-\-\[\=*\[/) #--[[ long (possibly multiline) comment ]]
num_equals = match.count("=") # Number must match for comment end
encoder.begin_group(:comment)
encoder.text_token(match, :delimiter)
state = :long_comment
elsif match = scan(/--.*$/) # --Lua comment
encoder.text_token(match, :comment)
elsif match = scan(/\[=*\[/) # [[ long (possibly multiline) string ]]
num_equals = match.count("=") # Number must match for comment end
encoder.begin_group(:string)
encoder.text_token(match, :delimiter)
state = :long_string
elsif match = scan(/::\s*[a-zA-Z_][a-zA-Z0-9_]+\s*::/) # ::goto_label::
encoder.text_token(match, :label)
elsif match = scan(/_[A-Z]+/) # _UPPERCASE are names reserved for Lua
encoder.text_token(match, :predefined)
elsif match = scan(/[a-zA-Z_][a-zA-Z0-9_]*/) # Normal letters (or letters followed by digits)
kind = IDENT_KIND[match]
# Extra highlighting for entities following certain keywords
if kind == :keyword and match == "function"
state = :function_expected
elsif kind == :keyword and match == "goto"
state = :goto_label_expected
elsif kind == :keyword and match == "local"
state = :local_var_expected
end
encoder.text_token(match, kind)
elsif match = scan(/\{/) # Opening table brace {
encoder.begin_group(:map)
encoder.text_token(match, brace_depth >= 1 ? :inline_delimiter : :delimiter)
brace_depth += 1
state = :map
elsif match = scan(/\}/) # Closing table brace }
if brace_depth == 1
brace_depth = 0
encoder.text_token(match, :delimiter)
encoder.end_group(:map)
elsif brace_depth == 0 # Mismatched brace
encoder.text_token(match, :error)
else
brace_depth -= 1
encoder.text_token(match, :inline_delimiter)
encoder.end_group(:map)
state = :map
end
elsif match = scan(/["']/) # String delimiters " and '
encoder.begin_group(:string)
encoder.text_token(match, :delimiter)
start_delim = match
state = :string
# ↓Prefix hex number ←|→ decimal number
elsif match = scan(/-? (?:0x\h* \. \h+ (?:p[+\-]?\d+)? | \d*\.\d+ (?:e[+\-]?\d+)?)/ix) # hexadecimal constants have no E power, decimal ones no P power
encoder.text_token(match, :float)
# ↓Prefix hex number ←|→ decimal number
elsif match = scan(/-? (?:0x\h+ (?:p[+\-]?\d+)? | \d+ (?:e[+\-]?\d+)?)/ix) # hexadecimal constants have no E power, decimal ones no P power
encoder.text_token(match, :integer)
elsif match = scan(/[\+\-\*\/%^\#=~<>\(\)\[\]:;,] | \.(?!\d)/x) # Operators
encoder.text_token(match, :operator)
elsif match = scan(/\s+/) # Space
encoder.text_token(match, :space)
else # Invalid stuff. Note that Lua doesn’t accept multibyte chars outside of strings, hence these are also errors.
encoder.text_token(getch, :error)
end
# It may be that we’re scanning a full-blown subexpression of a table
# (tables can contain full expressions in parts).
# If this is the case, return to :map scanning state.
state = :map if state == :initial && brace_depth >= 1
when :function_expected
if match = scan(/\(.*?\)/m) # x = function() # "Anonymous" function without explicit name
encoder.text_token(match, :operator)
state = :initial
elsif match = scan(/[a-zA-Z_] (?:[a-zA-Z0-9_\.] (?!\.\d))* [\.\:]/x) # function tbl.subtbl.foo() | function tbl:foo() # Colon only allowed as last separator
encoder.text_token(match, :ident)
elsif match = scan(/[a-zA-Z_][a-zA-Z0-9_]*/) # function foo()
encoder.text_token(match, :function)
state = :initial
elsif match = scan(/\s+/) # Between the `function' keyword and the ident may be any amount of whitespace
encoder.text_token(match, :space)
else
encoder.text_token(getch, :error)
state = :initial
end
when :goto_label_expected
if match = scan(/[a-zA-Z_][a-zA-Z0-9_]*/)
encoder.text_token(match, :label)
state = :initial
elsif match = scan(/\s+/) # Between the `goto' keyword and the label may be any amount of whitespace
encoder.text_token(match, :space)
else
encoder.text_token(getch, :error)
end
when :local_var_expected
if match = scan(/function/) # local function ...
encoder.text_token(match, :keyword)
state = :function_expected
elsif match = scan(/[a-zA-Z_][a-zA-Z0-9_]*/)
encoder.text_token(match, :local_variable)
elsif match = scan(/,/)
encoder.text_token(match, :operator)
elsif match = scan(/\=/)
encoder.text_token(match, :operator)
# After encountering the equal sign, arbitrary expressions are
# allowed again, so just return to the main state for further
# parsing.
state = :initial
elsif match = scan(/\n/)
encoder.text_token(match, :space)
state = :initial
elsif match = scan(/\s+/)
encoder.text_token(match, :space)
else
encoder.text_token(getch, :error)
end
when :long_comment
if match = scan(/.*?(?=\]={#{num_equals}}\])/m)
encoder.text_token(match, :content)
delim = scan(/\]={#{num_equals}}\]/)
encoder.text_token(delim, :delimiter)
else # No terminator found till EOF
encoder.text_token(rest, :error)
terminate
end
encoder.end_group(:comment)
state = :initial
when :long_string
if match = scan(/.*?(?=\]={#{num_equals}}\])/m) # Long strings do not interpret any escape sequences
encoder.text_token(match, :content)
delim = scan(/\]={#{num_equals}}\]/)
encoder.text_token(delim, :delimiter)
else # No terminator found till EOF
encoder.text_token(rest, :error)
terminate
end
encoder.end_group(:string)
state = :initial
when :string
if match = scan(/[^\\#{start_delim}\n]+/) # Everything except \ and the start delimiter character is string content (newlines are only allowed if preceeded by \ or \z)
encoder.text_token(match, :content)
elsif match = scan(/\\(?:['"abfnrtv\\]|z\s*|x\h\h|\d{1,3}|\n)/m)
encoder.text_token(match, :char)
elsif match = scan(Regexp.compile(start_delim))
encoder.text_token(match, :delimiter)
encoder.end_group(:string)
state = :initial
elsif match = scan(/\n/) # Lua forbids unescaped newlines in normal non-long strings
encoder.text_token("\\n\n", :error) # Visually appealing error indicator--otherwise users may wonder whether the highlighter cannot highlight multine strings
encoder.end_group(:string)
state = :initial
else
encoder.text_token(getch, :error)
end
when :map
if match = scan(/[,;]/)
encoder.text_token(match, :operator)
elsif match = scan(/[a-zA-Z_][a-zA-Z0-9_]* (?=\s*=)/x)
encoder.text_token(match, :key)
encoder.text_token(scan(/\s+/), :space) if check(/\s+/)
encoder.text_token(scan(/\=/), :operator)
state = :initial
elsif match = scan(/\s+/m)
encoder.text_token(match, :space)
else
# Note this clause doesn’t advance the scan pointer, it’s a kind of
# "retry with other options" (the :initial state then of course
# advances the pointer).
state = :initial
end
else
raise
end
end
if options[:keep_state]
@state = state
end
encoder.end_group :string if [:string].include? state
brace_depth.times { encoder.end_group :map }
encoder
end
end
end
end