grammar BaseBrat
#Wrap up program
rule program
line+ {
def brat
Treetop::Runtime::SyntaxNode.clear_variables
"var @brat = $loader.loadmodule(\"core\", $loader);\n" <<
"@brat.base_object.@main_tantrum = function() {\n" <<
"var array = @brat.base_array;" <<
"var hash = @brat.base_hash;" <<
"var number = @brat.base_number;" <<
"var string = @brat.base_string;" <<
"var regex = @brat.base_regex;" <<
"var symbol = @brat.base_symbol;" <<
"var object = this;" <<
"this.export = function(object, name) {
if(@brat.has_field(name, \"@value\")) {
$objset($exports, $hash(@brat.to_identifier(name.@value)), object);
}
else
$throw(\"Import expects a string, not \" + $string(name));
}" <<
self.inner_brat << ";\n" <<
"}\n" <<
"@exit_value = @brat.base_object.@main_tantrum();\n"
end
def inner_brat
Treetop::Runtime::SyntaxNode.clear_variables
elements.map {|e| " " << e.brat if e.respond_to? :brat }.compact.join(";").gsub(";", ";\n")
end
def core_brat
<<-NEKO
var @brat = $loader.loadmodule("internal", $loader);
var array = @brat.base_array;
var hash = @brat.base_hash;
var number = @brat.base_number;
var string = @brat.base_string;
var regex = @brat.base_regex;
var symbol = @brat.base_symbol;
var object = @brat.base_object;
this = @brat.base_object;
export = function(object, name) {
if(@brat.has_field(name, "@value")) {
$objset($exports, $hash(@brat.nice_identifier(name.@value)), object);
}
else
$throw("Import expects a string, not " + $string(name));
}
#{inner_brat}
$exports.has_field = @brat.has_field;
$exports.hset = @brat.hset;
$exports.make_array = @brat.make_array;
$exports.make_hash = @brat.make_hash;
$exports.base_array = array;
$exports.base_hash = hash;
$exports.base_number = number;
$exports.base_string = string;
$exports.base_object = object;
$exports.base_regex = regex;
$exports.base_symbol = symbol;
$exports.num_args = @brat.num_args;
$exports.nice_identifier = @brat.nice_identifier;
$exports.to_identifier = @brat.to_identifier;
NEKO
end
}
/
eof
end
#Matches a single expression, comment, or an empty line
rule line
~comment
/
~(space?) e:expression ~(space?) ~(comment?) ~( eof / eol / eob) {
def brat
if e.respond_to? :no_result_brat
e.no_result_brat
elsif e.respond_to? :brat
e.brat
end
end
}
/
~empty_line
end
#Matches an empty line
rule empty_line
space? ~eol {
def brat
""
end
}
end
#Expressions! Which is basically everything
rule expression
regex / binary_operation / index_set / index_get /
assignment / paren_exp ~(!".") { def brat; output = paren_exp.brat; @result = paren_exp.result; output; end } /
method_access / method_invocation / number / unary_operation / string / symbol / function_definition / hash / array
end
#Expressions which can be followed by []
rule indexed_expression
hash / array / paren_exp / unary_operation / method_invocation / string
end
#Expressions which can be used as lhs of "." method calls
rule method_target_expression
hash / array / paren_exp / number / string / regex / symbol / unary_operation
end
#Expressions which can be used as the lhs of a binary expression
rule binary_lhs_expression
index_get / paren_exp / number / string / hash / bare_array / method_with_parens / regex / symbol / unary_operation
end
rule unary_rhs_expression
index_get / paren_exp / number / string / hash / bare_array / method_invocation / regex / symbol
end
#Matches regular expression literals
rule regex
"/" r:(!"/" . / "\\/")* "/" {
def brat
next_temp
"var #@result = regex.new(\"#{r.text_value}\");"
end
}
end
#Matches comments
rule comment
space? ("//" / "#") (!(eol/eof) .)+ {
def brat
""
end
}
/
space? "/*" (!"*/" .)+ "*/"
end
#Matches hash table literals
rule hash
"[" spaceorbreak hash_inner spaceorbreak "]" {
def brat
output = hash_inner.brat
@result = hash_inner.result
output
end
}
end
#Matches array literals
rule array
"[" spaceorbreak inner_arg_list spaceorbreak "]" {
def brat
output = inner_arg_list.brat
next_temp
output << "var #@result = @brat.make_array(#{inner_arg_list.array});"
end
}
/
"[" spaceorbreak "]" {
def brat
next_temp
"var #@result = @brat.make_array($amake(0));"
end
}
end
#Matches bare arrays
#(Note: is this necessary?)
rule bare_array
"[" spaceorbreak inner_arg_list spaceorbreak "]" ~(&(space / eol)) {
def brat
output = inner_arg_list.brat
next_temp
output << "var #@result = @brat.make_array(#{inner_arg_list.array});"
end
}
end
#Inside of a hash literal
rule hash_inner
first:hash_argument rest:(spaceorbreak "," spaceorbreak n:hash_argument spaceorbreak)* {
def brat
next_temp
hash_temp = @result
output = "var #{hash_temp} = $hnew(#{rest.elements.length + 1});"
output << first.brat
output << "@brat.hset(#{hash_temp}, #{first.index}, #{first.value});"
rest.elements.each do |e|
elem = e.n
output << elem.brat
output << "@brat.hset(#{hash_temp}, #{elem.index}, #{elem.value});"
end
next_temp
output << "var #@result = @brat.make_hash(#{hash_temp});"
end
}
end
#Single member of a hash table
rule hash_argument
i:expression spaceorbreak ":" spaceorbreak v:expression {
attr_reader :index, :value
def brat
output = i.brat
output << v.brat
@index = i.result
@value = v.result
output
end
}
end
#Setting value via index (e.g., "a[1] = b")
rule index_set
a:indexed_expression "[" i:expression "]" space? "=" spaceorbreak v:expression {
def brat
output = a.brat
output << i.brat
output << v.brat
next_temp
output << "var #@result = #{a.result}.__set(#{i.result}, #{v.result});"
@result = v.result
output << "#{@result};"
end
}
end
#Retrieving value via index (e.g., "a[1]")
rule index_get
e:indexed_expression a:("[" inner_arg_list "]")+ !"." args:arg_list {
def brat
output = e.brat
last = e.result
a.elements.each do |elem|
output << elem.inner_arg_list.brat
next_temp
output << "var #@result = #{last}.__get(#{elem.inner_arg_list.list});"
last = @result
end
unless args.respond_to? :nothing?
output << args.brat
next_temp
output << "var #@result = " << invoke(last, args.list, args.length) << ";"
end
output
end
}
end
#Matches assignment using "=" operator
rule assignment
lhs:field_access space? "=" spaceorbreak rhs:function_definition {
def brat
output = lhs.brat <<
rhs.brat <<
"$objset(#{lhs.result}, $hash(\"#{lhs.i.brat}\"), #{rhs.result});"
@result = rhs.result
output
end
}
/
lhs:field_access space? "=" spaceorbreak rhs:method_access {
def brat
output = lhs.brat <<
rhs.brat <<
"$objset(#{lhs.result}, $hash(\"#{lhs.i.brat}\"), #{rhs.result});"
@result = rhs.result
output
end
}
/
lhs:field_access space? "=" spaceorbreak rhs:expression {
def brat
output = lhs.brat <<
rhs.brat <<
"$objset(#{lhs.result}, $hash(\"#{lhs.i.brat}\"), function() {#{rhs.result}});"
@result = rhs.result
output
end
}
/
lhs:identifier space? "=" spaceorbreak rhs:expression {
def brat
var = lhs.brat
temp = var_exist? var
if temp
output = rhs.brat <<
"#{temp} = #{rhs.result};"
elsif $interactive
var_add var
output = rhs.brat <<
"#{var} = #{rhs.result};"
else
var_add var, next_temp
output = rhs.brat <<
"#@result = #{rhs.result};"
end
@result = rhs.result
output
end
}
end
#Matches a lhs that is a field access (e.g., "a.b")
rule field_access
m:method_chain i:(identifier / operator) {
def brat
output = m.brat
@result = m.result
output
end
}
end
#Matches a parenthesized expression
rule paren_exp
'(' ~(space?) expression ~(space?) ')' {
def brat
output = expression.brat
@result = expression.result
output
end
}
end
#Matches an identifier, which is any letterfollowed by letters, digits,
#and some symbols.
#Also mangles anything that is a Neko keyword.
rule identifier
[a-zA-Z] (!"->" !space [a-zA-Z0-9_!?\-*+^&@~/\\><$_%])* {
def brat
escape_identifier text_value
end
}
end
#Matches a number
rule number
float / integer
end
#Matches floats
rule float
'-' i:pos_integer "." d:pos_integer {
def brat
next_temp
"var #@result = number.@stof(\"-#{i.text_value}.#{d.text_value}\");"
end
}
/
i:pos_integer "." d:pos_integer {
def brat
next_temp
"var #@result = number.@stof(\"#{i.text_value}.#{d.text_value}\");"
end
}
end
#Matches integers
rule integer
pos_integer
/
'-' [0-9]+ {
def brat
next_temp
"var #@result = number.@stoi(\"#{text_value}\");"
end
}
end
rule pos_integer
[0-9]+ {
def brat
next_temp
"var #@result = number.@stoi(\"#{text_value}\");"
end
}
end
#Matches doubly-quoted strings
rule string
'"' (!'"' . / '\"')* '"' {
def brat
next_temp
"var #@result = string.new(#{text_value});"
end
}
end
#Like symbols in Scheme or Ruby
rule symbol
"'" id:(identifier / operator / number)+ {
def brat
next_temp
"var #@result = symbol.new(\"#{id.elements.map { |m| m.text_value }.join}\");"
end
}
end
rule symbol_convert
identifier
/
operator
/
number {
def brat
n.text_value
end
}
end
#Matches function definitions
rule function_definition
"{" space? fa:formal_args space? l:line* space? "}" {
def brat
new_scope
if fa.respond_to? :brat
args = fa.brat
else
args = ""
end
next_temp
output = "var #@result = function(#{args}) { \n#{l.elements.map {|e| e.brat}.join(";")} };"
pop_scope
output
end
}
end
#Matches formal arguments in a function definition
rule formal_args
space? i:identifier? rest_formal space? "|" {
def brat
if i.respond_to? :brat
var_add i.brat, next_temp
if $interactive
args = [i.brat] + rest_formal.brat
else
args = [@result] + rest_formal.brat
end
else
args = []
end.join(", ")
end
}
/
!"|"
end
#Matches list items in a formal argument list
rule rest_formal
(space? "," space? identifier)* {
def brat
if elements.length > 0
elements.map do |e|
var_add e.identifier.brat, next_temp
if $interactive
e.identifier.brat
else
@result
end
end
else
[]
end
end
}
end
#Matches a unary operation, which requires a symbol to be
#immediately followed by an expression.
rule unary_operation
op:operator !space rhs:unary_rhs_expression {
def brat
next_temp
args = @result
next_temp
"var #{args} = $amake(0);" <<
rhs.brat <<
"var #@result = " << call_method(rhs.result, op.brat, args, 0) << ";"
end
}
end
#Matches binary operations.
rule binary_operation
lhs:binary_operation_chain rhs:expression
{
def brat
output = lhs.brat
output << rhs.brat
in_stack = lhs.stack
in_stack << rhs.result
out_stack = []
op_stack = []
res_stack = []
val = true
in_stack.each do |e|
if val
out_stack.push e
val = false
else
prec = precedence(e)
while op_stack.length > 0 && prec <= precedence(op_stack.last) do
out_stack.push op_stack.pop
end
op_stack.push e
val = true
end
end
while not op_stack.empty?
out_stack.push op_stack.pop
end
out_stack.each do |e|
if e[0,5] == "@temp"
res_stack.push e
else
r = res_stack.pop
l = res_stack.pop
next_temp
output << "var #@result = " << call_method(l, e, "$array(#{r})", 1) << ";"
res_stack.push @result
end
end
next_temp
output << "var #@result = #{res_stack.pop};"
end
}
end
#Matches several binary operations
rule binary_operation_chain
(lhs:binary_lhs_expression ~space op:operator ~space)+ {
attr_reader :stack
def brat
@stack = []
output = ""
elements.each do |e|
output << e.lhs.brat
@stack << e.lhs.result
@stack << e.op.brat
end
output
end
}
end
#Matches method calls which must have parentheses or no arguments
rule method_with_parens
lhs:method_chain i:(identifier / operator) a:simple_arg_list {
def brat
output = lhs.brat
output << a.brat
next_temp
output << "var #@result = " << call_method(lhs.result, i.brat, a.array, a.length) << ";"
end
}
/
m:identifier a:simple_arg_list {
def brat
next_temp
name = m.brat
a.brat <<
"var #@result = " << get_value(name, a.array, a.length) << ";"
end
}/
m:paren_exp a:simple_arg_list {
def brat
output = m.brat
output << a.brat
next_temp
output << "var #@result = " << invoke(m.result, a.list, a.length) << ";"
end
}
end
#Matches method/function invocations
rule method_invocation
lhs:method_chain i:(identifier / operator) a:arg_list {
def brat
output = lhs.brat
output << a.brat
next_temp
output << "var #@result = " << call_method(lhs.result, i.brat, a.array, a.length) << ";"
end
#if lhs refers to 'this', we can just call it as though
#there were no lhs, possibly doing tail-recursion optimization
def no_result_brat
return self.brat
output = lhs.brat
output << a.brat
next_temp
output <<
"if(this == #{lhs.result}) {" <<
get_value_clean(i.brat, a.list, a.length) <<
"} else {" <<
call_method(lhs.result, i.brat, a.array, a.length) <<
"};"
end
}
/
m:identifier a:arg_list {
def brat
next_temp
name = m.brat
a.brat <<
"var #@result = " << get_value(name, a.array, a.length) << ";"
end
def no_result_brat
next_temp
name = m.brat
a.brat <<
get_value_clean(name, a.list, a.length) << ";"
end
}
/
m:paren_exp a:arg_list {
def brat
output = m.brat
output << a.brat
next_temp
output << "var #@result = " << invoke(m.result, a.list, a.length) << ";"
end
}
end
#Matches a method chain, up to the last "."
rule method_chain
(e:method_lhs ".")+ {
def brat
output = elements.first.e.brat
last = elements.first.e.result
@result = last
meth = args = nil
elements[1..-1].each do |elem|
meth = elem.e.identifier.brat
args = elem.e.arg_list
output << args.brat
next_temp
output << "var #@result = " << call_method(last, meth, args.array, args.length) << ";"
last = @result
if not elem.e.a.elements.empty?
elem.e.a.elements.each do |ele|
output << ele.inner_arg_list.brat
next_temp
output << "var #@result = #{last}.__get(#{ele.inner_arg_list.list});"
last = @result
end
end
end
output
end
}
end
#Matches expressions which can be the targets of method calls
rule method_lhs
identifier !space arg_list a:("[" inner_arg_list "]")* {
def brat
next_temp
output = arg_list.brat
name = identifier.brat
temp = var_exist?(name) || name
output <<
"var #@result;" <<
"if(@brat.has_field(this, \"#{name}\")) {" <<
" #@result = " << call_method("this", name, arg_list.array, arg_list.length) <<
"}" <<
"else " <<
" if($typeof(#{temp}) == $tfunction) {" <<
" #@result = " << invoke(temp, arg_list.list, arg_list.length) << ";" <<
" } else if($typeof(#{temp}) == $tobject) { " <<
" #@result = #{temp}}" <<
"else { $throw \"Tried to invoke method on #{name}\" };"
last = @result
if not a.elements.empty?
a.elements.each do |elem|
output << elem.inner_arg_list.brat
next_temp
output << "var #@result = #{last}.__get(#{elem.inner_arg_list.list});"
last = @result
end
end
output
end
}
/
a:array a_rest:(array+) {
def brat
output = a.brat
last = a.result
a_rest.elements.each do |elem|
output << elem.inner_arg_list.brat
next_temp
output << "var #@result = #{last}.__get(#{elem.inner_arg_list.list});"
last = @result
end
@result = last
output
end
}
/
method_target_expression {
def brat
super
end
}
end
#Matches the "don't execute this" operator ("->") which just returns the method
#instead of executing/calling it.
rule method_access
"->" m:identifier {
def brat
next_temp
name = m.brat
temp = var_exist? name
if temp
"var #@result = #{temp};"
else
"var #@result;" <<
"if (#{name} == null)" <<
"#@result = $objget(this, $hash(\"#{name}\"));" <<
"else #@result = #{name};"
end
end
}
/
o:method_invocation "->" m:(identifier / operator) {
def brat
next_temp
o.brat <<
"var #@result = $objget(#{o.result}, $hash(\"#{m.brat}\"));"
end
}
end
#Matches an argument list, including no arguments at all
rule arg_list
'(' ~(space?) inner_arg_list ~(space?) ')' {
def brat
inner_arg_list.brat
end
def array
inner_arg_list.array
end
def length
inner_arg_list.length
end
def list
inner_arg_list.list
end
}
/
'(' empty_list ')' {
def brat
""
end
def array
"$amake(0)"
end
def length
0
end
def list
""
end
}
/
space inner_arg_list {
def brat
inner_arg_list.brat
end
def array
inner_arg_list.array
end
def length
inner_arg_list.length
end
def list
inner_arg_list.list
end
}
/
![(] ~(&(space?)) {
def brat
""
end
def array
"$amake(0)"
end
def length
0
end
def list
""
end
def nothing?
true
end
}
end
#Matches an argument list which must be in parentheses, or no arguments at all
rule simple_arg_list
'(' ~(space?) inner_arg_list ~(space?) ')' {
def brat
inner_arg_list.brat
end
def array
inner_arg_list.array
end
def length
inner_arg_list.length
end
def list
inner_arg_list.list
end
}
/
'(' empty_list ')' {
def brat
""
end
def array
"$amake(0)"
end
def length
0
end
def list
""
end
}
/
![(] &(space) {
def brat
""
end
def array
"$amake(0)"
end
def length
0
end
def list
""
end
def nothing?
true
end
}
end
#Matches the inside of the argument list
rule inner_arg_list
e:arg_first o:arg_next* {
attr_reader :length, :list
def brat
output = ""
args = []
named_args = []
if e.respond_to? :named_argument?
output << e.brat
named_args << e
else
output << e.brat
args << e.result
end
o.elements.each do |elem|
if elem.respond_to? :brat
if elem.arg_first.respond_to? :named_argument?
output << elem.arg_first.brat
named_args << elem.arg_first
else
output << elem.brat
args << elem.result
end
end
end
unless named_args.empty?
next_temp
hash_temp = @result
output << "var #{hash_temp} = $hnew(#{named_args.length});"
named_args.map do |e|
output << e.i.brat
output << "@brat.hset(#{hash_temp}, #{e.i.result}, #{e.result});"
end
next_temp
output << "var #@result = @brat.make_hash(#{hash_temp});"
args << @result
end
@list = args.join(',')
@length = args.length
output
end
def array
if length > 0
"$array(#{self.list})"
else
"$amake(0)"
end
end
}
end
#Matches a single argument
rule arg_first
named_argument / expression
end
#Matches the rest of the arguments
rule arg_next
~((space / eol)*) "," ~((space / eol)*) arg_first {
def brat
output = arg_first.brat
@result = arg_first.result
output
end
}
end
#Matches a 'named' argument
rule named_argument
i:expression spaceorbreak ":" spaceorbreak e:expression {
def brat
output = e.brat
@result = e.result
output
end
def named_argument?
true
end
}
end
#Matches allowable operators and converts them to mangled method names
rule operator
~(!("->" !operator) !("=" !(operator / "="))) ("!=" / ">=" / "<=" / [!?\-*+^@~/\\><$_%\=] / "||" / "|" / "&&" / "&")+ {
def brat
escape_operator(elements.map {|e| e.text_value}.join)
end
}
end
#Matches nothing or spaces
rule empty_list
~(space?)
end
#Matches end-of-lines, which can be \n, ;, or \r\n
rule eol
("\n" / ";" / "\r\n")+ {
def brat
"\n"
end
}
end
#Matches spaces or tabs
rule space
(" " / "\t")+ {
def brat
text_value
end
}
end
#Matches the end of the file
rule eof
~((eol / space)? !.)
end
#Matches the end of a function
rule eob
~(space? &"}" space?)
end
#Matches spaces, eols, or nothing
rule spaceorbreak
space? eol? space?
end
end
) is private.
