path: root/test/racc/assets/huia.y

# Copyright (c) 2014 James Harton
#
# MIT License
#
# Permission is hereby granted, free of charge, to any person obtaining
# a copy of this software and associated documentation files (the
# "Software"), to deal in the Software without restriction, including
# without limitation the rights to use, copy, modify, merge, publish,
# distribute, sublicense, and/or sell copies of the Software, and to
# permit persons to whom the Software is furnished to do so, subject to
# the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

class Huia::Parser

  token
    IDENTIFIER EQUAL PLUS MINUS ASTERISK FWD_SLASH COLON FLOAT INTEGER STRING
    EXPO INDENT OUTDENT OPAREN CPAREN DOT SIGNATURE NL EOF PIPE COMMA NIL TRUE
    FALSE EQUALITY CALL SELF CONSTANT CHAR DOUBLE_TICK_STRING
    DOUBLE_TICK_STRING_END INTERPOLATE_START INTERPOLATE_END BOX LSQUARE
    RSQUARE FACES LFACE RFACE BANG TILDE RETURN NOT_EQUALITY OR AND GT LT
    GTE LTE AT

  prechigh
    left EXPO
    left BANG TILDE
    left ASTERISK FWD_SLASH PERCENT
    left PLUS MINUS

    right EQUAL
  preclow

  rule
    statements:   statement
                | statements statement             { return scope }

    statement:  expr eol                           { return scope.append val[0] }
              | expr                               { return scope.append val[0] }
              | eol                                { return scope }

    eol:        NL | EOF
    nlq:        NL |

    expr:        literal
               | grouped_expr
               | binary_op
               | unary_op
               | method_call
               | constant
               | variable
               | array
               | hash
               | return

    return:            return_expr
                     | return_nil
    return_expr:       RETURN expr                      { return n(:Return, val[1]) }
    return_nil:        RETURN                           { return n(:Return, n(:Nil)) }

    array:             empty_array
                     | array_list

    empty_array:       BOX                              { return n :Array }

    array_list:        LSQUARE array_items RSQUARE      { return val[1] }
    array_items:       expr                             { return n :Array, [val[0]] }
                     | array_items COMMA expr           { val[0].append(val[2]); return val[0] }

    hash:              empty_hash
                     | hash_list
    empty_hash:        FACES                            { return n :Hash }
    hash_list:         LFACE hash_items RFACE           { return val[1] }
    hash_items:        hash_item                        { return n :Hash, val[0] }
                     | hash_items COMMA hash_item       { val[0].append(val[2]); return val[0] }
    hash_item:         expr COLON expr                  { return n :HashItem, val[0], val[2] }

    constant:          CONSTANT                         { return constant val[0] }

    indented:          indented_w_stmts
                     | indented_w_expr
                     | indented_wo_stmts
    indented_w_stmts:  indent statements outdent        { return val[0] }
    indented_w_expr:   indent expr outdent              { return val[0].append(val[1]) }
    indented_wo_stmts: indent outdent                   { return val[0] }
    outdent:           OUTDENT { return pop_scope }


    indent_w_args:     indent_pipe indent_args PIPE nlq INDENT { return val[0] }
    indent_pipe:       PIPE   { return push_scope }
    indent_wo_args:    INDENT { return push_scope }
    indent:            indent_w_args
                     | indent_wo_args

    indent_args:       indent_arg
                     | indent_args COMMA indent_arg
    indent_arg:        arg_var                             { return scope.add_argument val[0] }
                     | arg_var EQUAL expr                  { return n :Assignment, val[0], val[2] }
    arg_var:           IDENTIFIER                          { return n :Variable, val[0] }

    method_call:            method_call_on_object
                          | method_call_on_self
                          | method_call_on_closure
    method_call_on_object:  expr DOT call_signature        { return n :MethodCall, val[0], val[2] }
                          | expr DOT IDENTIFIER            { return n :MethodCall, val[0], n(:CallSignature, val[2]) }
    method_call_on_self:    call_signature                 { return n :MethodCall, scope_instance, val[0] }

    method_call_on_closure: AT call_signature              { return n :MethodCall, this_closure, val[1] }
                          | AT IDENTIFIER                  { return n :MethodCall, this_closure, n(:CallSignature, val[1]) }

    call_signature:         call_arguments
                          | call_simple_name
    call_simple_name:       CALL                           { return n :CallSignature, val[0] }
    call_argument:          SIGNATURE call_passed_arg      { return n :CallSignature, val[0], [val[1]] }
    call_passed_arg:        call_passed_simple
                          | call_passed_indented
    call_passed_simple:     expr
                          | expr NL
    call_passed_indented:   indented
                          | indented NL
    call_arguments:         call_argument                  { return val[0] }
                          | call_arguments call_argument   { return val[0].concat_signature val[1] }

    grouped_expr: OPAREN expr CPAREN            { return n :Expression, val[1] }

    variable:  IDENTIFIER                       { return allocate_local val[0] }

    binary_op: assignment
             | addition
             | subtraction
             | multiplication
             | division
             | exponentiation
             | modulo
             | equality
             | not_equality
             | logical_or
             | logical_and
             | greater_than
             | less_than
             | greater_or_eq
             | less_or_eq

    assignment:     IDENTIFIER EQUAL expr  { return allocate_local_assignment val[0], val[2] }
    addition:       expr PLUS expr         { return binary val[0], val[2], 'plus:' }
    subtraction:    expr MINUS expr        { return binary val[0], val[2], 'minus:' }
    multiplication: expr ASTERISK expr     { return binary val[0], val[2], 'multiplyBy:' }
    division:       expr FWD_SLASH expr    { return binary val[0], val[2], 'divideBy:' }
    exponentiation: expr EXPO expr         { return binary val[0], val[2], 'toThePowerOf:' }
    modulo:         expr PERCENT expr      { return binary val[0], val[2], 'moduloOf:' }
    equality:       expr EQUALITY expr     { return binary val[0], val[2], 'isEqualTo:' }
    not_equality:   expr NOT_EQUALITY expr { return binary val[0], val[2], 'isNotEqualTo:' }
    logical_or:     expr OR expr           { return binary val[0], val[2], 'logicalOr:' }
    logical_and:    expr AND expr          { return binary val[0], val[2], 'logicalAnd:' }
    greater_than:   expr GT expr           { return binary val[0], val[2], 'isGreaterThan:' }
    less_than:      expr LT expr           { return binary val[0], val[2], 'isLessThan:' }
    greater_or_eq:  expr GTE expr          { return binary val[0], val[2], 'isGreaterOrEqualTo:' }
    less_or_eq:     expr LTE expr          { return binary val[0], val[2], 'isLessOrEqualTo:' }

    unary_op:  unary_not
             | unary_plus
             | unary_minus
             | unary_complement

    unary_not:        BANG  expr { return unary val[1], 'unaryNot' }
    unary_plus:       PLUS  expr { return unary val[1], 'unaryPlus' }
    unary_minus:      MINUS expr { return unary val[1], 'unaryMinus' }
    unary_complement: TILDE expr { return unary val[1], 'unaryComplement' }

    literal:   integer
             | float
             | string
             | nil
             | true
             | false
             | self

    float:          FLOAT                       { return n :Float,   val[0] }
    integer:        INTEGER                     { return n :Integer, val[0] }
    nil:            NIL                         { return n :Nil }
    true:           TRUE                        { return n :True }
    false:          FALSE                       { return n :False }
    self:           SELF                        { return n :Self }

    string:         STRING                      { return n :String,  val[0] }
                  | interpolated_string
                  | empty_string

    interpolated_string: DOUBLE_TICK_STRING interpolated_string_contents DOUBLE_TICK_STRING_END { return val[1] }
    interpolation:       INTERPOLATE_START expr INTERPOLATE_END { return val[1] }
    interpolated_string_contents:   interpolated_string_chunk   { return n :InterpolatedString, val[0] }
                                  | interpolated_string_contents interpolated_string_chunk { val[0].append(val[1]); return val[0] }
    interpolated_string_chunk:   chars         { return val[0] }
                               | interpolation { return to_string(val[0]) }
    empty_string: DOUBLE_TICK_STRING DOUBLE_TICK_STRING_END { return n :String, '' }

    chars:   CHAR       { return n :String, val[0] }
           | chars CHAR { val[0].append(val[1]); return val[0] }
end

---- inner

attr_accessor :lexer, :scopes, :state

def initialize lexer
  @lexer  = lexer
  @state  = []
  @scopes = []
  push_scope
end

def ast
  @ast ||= do_parse
  @scopes.first
end

def on_error t, val, vstack
  line = lexer.line
  col  = lexer.column
  message = "Unexpected #{token_to_str t} at #{lexer.filename} line #{line}:#{col}:\n\n"

  start = line - 5 > 0 ? line - 5 : 0
  i_size = line.to_s.size
  (start..(start + 5)).each do |i|
    message << sprintf("\t%#{i_size}d: %s\n", i, lexer.get_line(i))
    message << "\t#{' ' * i_size}  #{'-' * (col - 1)}^\n" if i == line
  end

  raise SyntaxError, message
end

def next_token
  nt = lexer.next_computed_token
  # just use a state stack for now, we'll have to do something
  # more sophisticated soon.
  if nt && nt.first == :state
    if nt.last
      state.push << nt.last
    else
      state.pop
    end
    next_token
  else
    nt
  end
end

def push_scope
  new_scope = Huia::AST::Scope.new scope
  new_scope.file   = lexer.filename
  new_scope.line   = lexer.line
  new_scope.column = lexer.column
  scopes.push new_scope
  new_scope
end

def pop_scope
  scopes.pop
end

def scope
  scopes.last
end

def binary left, right, method
  node(:MethodCall, left, node(:CallSignature, method, [right]))
end

def unary left, method
  node(:MethodCall, left, node(:CallSignature, method))
end

def node type, *args
  Huia::AST.const_get(type).new(*args).tap do |n|
    n.file   = lexer.filename
    n.line   = lexer.line
    n.column = lexer.column
  end
end
alias n node

def allocate_local name
  node(:Variable, name).tap do |n|
    scope.allocate_local n
  end
end

def allocate_local_assignment name, value
  node(:Assignment, name, value).tap do |n|
    scope.allocate_local n
  end
end

def this_closure
  allocate_local('@')
end

def scope_instance
  node(:ScopeInstance, scope)
end

def constant name
  return scope_instance if name == 'self'
  node(:Constant, name)
end

def to_string expr
  node(:MethodCall, expr, node(:CallSignature, 'toString'))
end