mix-language 1.0.0

data/lib/ruby/mix.grammar

@@ -0,0 +1,238 @@
+# encoding: UTF-8
+# 
+# Copyright © 2011 Jesse Sielaff
+# 
+
+class MixCompiler
+  options no_result_var
+  
+  prechigh
+    right '!'
+    right '-·' '-1'
+    left '*' '/' '%'
+    left '+' '-'
+    left '<<' '>>'
+    left '<' '<=' '>' '>='
+    nonassoc '==' '!='
+    left '&&'
+    left '||'
+    right '?' ':'
+    right '=' '&&=' '||=' '·='
+    nonassoc IF UNLESS WHILE UNTIL
+  preclow
+  
+  rule
+    statements
+      : statement
+      | statements statement { append_statement(val[0], val[1]) }
+    
+    statement
+      : indented_statement { newline node(:statement, val[0], nil) }
+      | inline_statements opt_semicolon newline { newline val[0] }
+    
+    opt_semicolon
+      : # nothing
+      | ';'
+    
+    newline
+      : NEWLINE { @location = val[0][1] }
+    
+    indented_statement
+      : mixin_statement
+      | control_statement
+      | function_statement
+    
+    mixin_statement
+      : MIXIN ':' newline INDENT mixin_body OUTDENT { node :mixin, val[0][0], val[4] }
+    
+    mixin_body
+      : statements { [val[0], []] }
+      | definitions { [newline(node(:null)), val[0]] }
+      | statements definitions { [val[0], val[1]] }
+    
+    definitions
+      : definition { [val[0]] }
+      | definitions definition { val[0] << val[1] }
+    
+    definition
+      : IDENTIFIER function_block { node :set, node(:access_hash, node(:self), val[0][0]), val[1] }
+      | IDENTIFIER inline_function newline { node :newline, @location, node(:set, node(:access_hash, node(:self), val[0][0]), val[1]) }
+    
+    function_block
+      : parameter_list indent_block { node :function, pop_variables, val[1] }
+    
+    parameter_list
+      : '#' { push_variables; nil }
+      | '|' { push_variables } parameters '|' { nil }
+    
+    parameters
+      : IDENTIFIER { parameter val[0][0]; nil }
+      | parameters ',' IDENTIFIER { parameter val[2][0]; nil }
+    
+    indent_block
+      : newline INDENT statements OUTDENT { val[2] }
+    
+    control_statement
+      : IF exp indent_block else_statement { node :if, val[1], val[2], val[3] }
+      | UNLESS exp indent_block opt_else { node :if, val[1], val[3], val[2] }
+      | WHILE exp indent_block { node :while, val[1], val[2] }
+      | UNTIL exp indent_block { node :while, node(:not, val[1]), val[2] }
+      | SWITCH exp newline INDENT cases opt_else OUTDENT { node :switch, val[1], val[4], val[5] }
+    
+    else_statement
+      : opt_else
+      | ELSIF exp indent_block else_statement { node :if, val[1], val[2], val[3] }
+    
+    opt_else
+      : { node :null }
+      | ELSE indent_block { val[1] }
+    
+    cases
+      : case { [val[0]] }
+      | cases case { val[0] << val[1] }
+    
+    case
+      : CASE exp indent_block { [node(:newline, @location, val[1]), val[2]] }
+      | CASE exp ':' inline_statements newline { [node(:newline, @location, val[1]), val[3]] }
+    
+    inline_statements
+      : inline_statement { node :statement, val[0], nil }
+      | inline_statements ';' inline_statement { append_statement(val[0], node(:statement, val[2], nil)) }
+    
+    inline_statement
+      : postfix_statement
+      | mix_statement
+      | keyword_statement
+      | exp
+    
+    postfix_statement
+      : inline_statement IF exp { node :if, val[2], val[0], node(:null) }
+      | inline_statement UNLESS exp { node :if, val[2], node(:null), val[0] }
+      | inline_statement WHILE exp { node :while, val[2], val[0] }
+      | inline_statement UNTIL exp { node :while, node(:not, val[2]), val[0] }
+    
+    mix_statement
+      : '+' MIXIN object { node :mix, val[2], val[1][0] }
+      | '+' MIXIN { node :mix, node(:self), val[1][0] }
+    
+    keyword_statement
+      : BREAK exp { node :break, val[1] }
+      | BREAK { node :break, node(:null) }
+      | RETURN exp { node :return, val[1] }
+      | RETURN { node :return, node(:null) }
+    
+    function_statement
+      : function_block
+      | dot_access function_block { node :call, val[0], [val[1]] }
+      | dot_access '(' arguments ')' function_block { node :call, val[0], val[2] << val[4] }
+      | functional_object '(' arguments ')' function_block { node :call, val[0], val[2] << val[4] }
+      | lhs '=' function_statement { node :set, val[0], val[2] }
+    
+    dot_access
+      : object '.' IDENTIFIER { node :access_hash, val[0], val[2][0] }
+      | '.' IDENTIFIER { node :access_hash, node(:self), val[1][0] }
+    
+    arguments
+      : exp { [val[0]] }
+      | arguments ',' exp { val[0] << val[2] }
+      | { [] }
+    
+    lhs
+      : object '·[' exp ']' { node :access_brackets, val[0], val[2] }
+      | object '·#' IDENTIFIER { node :access_hash, val[0], val[2][0] }
+      | object '·:' IDENTIFIER { node :access_colon, val[0], val[2][0] }
+      | '#' IDENTIFIER { node :access_hash, node(:self), val[1][0] }
+      | ':' IDENTIFIER { node :access_colon, node(:self), val[1][0] }
+      | IDENTIFIER { variable val[0][0] }
+    
+    exp
+      : lhs '=' exp { node :set, val[0], val[2] }
+      | lhs '&&=' exp { node :set, val[0], node(:and, val[0], val[2]) }
+      | lhs '||=' exp { node :set, val[0], node(:or, val[0], val[2]) }
+      | lhs '·=' exp { node :set, val[0], node(:op, val[1][0], val[0], val[2]) }
+      | '!' exp { node :not, val[1] }
+      | '-·' exp { node :op, "-", node(:number, "0"), val[1] }
+      | exp '*' exp { node :op, val[1][0], val[0], val[2] }
+      | exp '/' exp { node :op, val[1][0], val[0], val[2] }
+      | exp '%' exp { node :op, val[1][0], val[0], val[2] }
+      | exp '+' exp { node :op, val[1][0], val[0], val[2] }
+      | exp '-' exp { node :op, val[1][0], val[0], val[2] }
+      | exp '<<' exp { node :op, val[1][0], val[0], val[2] }
+      | exp '>>' exp { node :op, val[1][0], val[0], val[2] }
+      | exp '<' exp { node :op, val[1][0], val[0], val[2] }
+      | exp '<=' exp { node :op, val[1][0], val[0], val[2] }
+      | exp '>' exp { node :op, val[1][0], val[0], val[2] }
+      | exp '>=' exp { node :op, val[1][0], val[0], val[2] }
+      | exp '==' exp { node :op, val[1][0], val[0], val[2] }
+      | exp '!=' exp { node :op, val[1][0], val[0], val[2] }
+      | exp '&&' exp { node :and, val[0], val[2] }
+      | exp '||' exp { node :or, val[0], val[2] }
+      | exp '?' exp ':' exp { node :if, val[0], val[2], val[4] }
+      | object
+    
+    object
+      : literal
+      | functional_object
+      | dot_access { node :call, val[0], [] }
+    
+    literal
+      : literal_number
+      | literal_string
+      | literal_constant
+      | literal_array
+      | literal_object
+    
+    literal_number
+      : NUMBER { node :number, val[0][0] }
+      | '-1' NUMBER { node :number, -val[1][0] }
+    
+    literal_string
+      : '\'' STRING '\'' { node :string, val[1][0] }
+    
+    literal_constant
+      : APP { node :app }
+      | FALSE { node :false }
+      | NULL { node :null }
+      | SELF { node :self }
+      | TRUE { node :true }
+    
+    literal_array
+      : '[' arguments opt_comma ']' { node :array, val[1] }
+    
+    opt_comma
+      : # nothing
+      | ','
+    
+    literal_object
+      : '{' fields opt_comma '}' { node :object, val[1], [] }
+      | MIXIN { node :object, [], [val[0][0]] }
+      | MIXIN literal_object { val[1][:values][1] << val[0][0]; val[1] }
+    
+    fields
+      : KEY exp { [[val[0][0], val[1]]]}
+      | fields ',' KEY exp { val[0] << [val[2][0], val[3]] }
+      | { [] }
+    
+    functional_object
+      : lhs
+      | parenthetical
+      | inline_function
+      | call
+    
+    parenthetical
+      : '(' inline_statements ')' { val[1] }
+    
+    inline_function
+      : parameter_list curly_brace_block { node :function, pop_variables, val[1] }
+    
+    curly_brace_block
+      : '{' inline_statements '}' { val[1] }
+      | '{' '}' { node :null }
+    
+    call
+      : functional_object '(' arguments ')' inline_function { node :call, val[0], val[2] << val[4] }
+      | functional_object '(' arguments ')' { node :call, val[0], val[2] }
+      | dot_access '(' arguments ')' inline_function { node :call, val[0], val[2] << val[4] }
+      | dot_access '(' arguments ')' { node :call, val[0], val[2] }
+      | dot_access inline_function { node :call, val[0], [val[1]] }
+end