################################################################################
# Copyright (c) 2011-2014, Tenable Network Security
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# 1. Redistributions of source code must retain the above copyright notice, this
#    list of conditions and the following disclaimer.
#
# 2. Redistributions in binary form must reproduce the above copyright notice,
#    this list of conditions and the following disclaimer in the documentation
#    and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
################################################################################

class Nasl::Grammar

preclow
  right ASS_EQ ADD_EQ SUB_EQ MUL_EQ DIV_EQ MOD_EQ SLL_EQ SRA_EQ SRL_EQ
  left OR
  left AND
  left CMP_LT CMP_GT CMP_EQ CMP_NE CMP_GE CMP_LE SUBSTR_EQ SUBSTR_NE REGEX_EQ REGEX_NE
  left BIT_OR
  left BIT_XOR
  left AMPERSAND
  left BIT_SRA BIT_SRL BIT_SLL
  left ADD SUB
  left MUL DIV MOD
  right NOT
  right UMINUS BIT_NOT
  right EXP
  right INCR DECR
prechigh

# Tell the parser generator that we don't wish to use the result variable in the
# action section of rules. Instead, the result of the rule will be the value of
# evaluating the action block.
options no_result_var

# Tell the parser generator that we expect one shift/reduce conflict due to the
# well-known dangling else problem. We could make the grammar solve this
# problem, but this is how the NASL YACC file solves it, so we'll follow suit.
expect 1

rule
  ##############################################################################
  # Aggregate Statements
  ##############################################################################

  start      : roots
             { val[0] }
             | /* Blank */
             { [] }
             ;

  roots      : root roots
             { [val[0]] + val[1] }
             | root
             { [val[0]] }
             ;

  root       : COMMENT export
             { c(*val) }
             | export
             { val[0] }
             | COMMENT function
             { c(*val) }
             | function
             { val[0] }
             | statement
             { val[0] }
             ;

  statement : simple
             { val[0] }
             | compound
             { val[0] }
             ;

  ##############################################################################
  # Root Statements
  ##############################################################################

  export     : EXPORT function
             { n(:Export, *val) }
             ;

  function   : FUNCTION ident LPAREN params RPAREN block
             { n(:Function, *val) }
             | FUNCTION ident LPAREN RPAREN block
             { n(:Function, *val) }
             ;

  simple     : assign
             { val[0] }
             | break
             { val[0] }
             | call
             { val[0] }
             | continue
             { val[0] }
             | decr
             { val[0] }
             | empty
             { val[0] }
             | COMMENT global
             { c(*val) }
             | global
             { val[0] }
             | import
             { val[0] }
             | include
             { val[0] }
             | incr
             { val[0] }
             | local
             { val[0] }
             | rep
             { val[0] }
             | return
             { val[0] }
             ;

  compound   : block
             { val[0] }
             | for
             { val[0] }
             | foreach
             { val[0] }
             | if
             { val[0] }
             | repeat
             { val[0] }
             | while
             { val[0] }
             ;

  ##############################################################################
  # Simple Statements
  ##############################################################################

  assign     : assign_exp SEMICOLON
             { val[0] }
             ;

  break      : BREAK SEMICOLON
             { n(:Break, *val) }
             ;

  call       : call_exp SEMICOLON
             { val[0] }
             ;

  continue   : CONTINUE SEMICOLON
             { n(:Continue, *val) }
             ;

  decr       : decr_exp SEMICOLON
             { val[0] }
             ;

  empty      : SEMICOLON
             { n(:Empty, *val) }
             ;

  global     : GLOBAL var_decls SEMICOLON
             { n(:Global, *val) }
             ;

  incr       : incr_exp SEMICOLON
             { val[0] }
             ;

  import     : IMPORT LPAREN string RPAREN SEMICOLON
             { n(:Import, *val) }
             ;

  include    : INCLUDE LPAREN string RPAREN SEMICOLON
             { n(:Include, *val) }
             ;

  local      : LOCAL var_decls SEMICOLON
             { n(:Local, *val) }
             ;

  rep        : call_exp REP expr SEMICOLON
             { n(:Repetition, *val[0..-1]) }
             ;

  return     : RETURN expr SEMICOLON
             { n(:Return, *val) }
             | RETURN ref SEMICOLON
             { n(:Return, *val) }
             | RETURN SEMICOLON
             { n(:Return, *val) }
             ;

  ##############################################################################
  # Compound Statements
  ##############################################################################

  block      : LBRACE statements RBRACE
             { n(:Block, *val) }
             | LBRACE RBRACE
             { n(:Block, *val) }
             ;

  for        : FOR LPAREN field SEMICOLON expr SEMICOLON field RPAREN statement
             { n(:For, *val) }
             ;

  foreach    : FOREACH ident LPAREN expr RPAREN statement
             { n(:Foreach, val[0], val[1], val[3], val[5]) }
             | FOREACH LPAREN ident IN expr RPAREN statement
             { n(:Foreach, val[0], val[2], val[4], val[6]) }
             ;

  if         : IF LPAREN expr RPAREN statement
             { n(:If, *val) }
             | IF LPAREN expr RPAREN statement ELSE statement
             { n(:If, *val) }
             ;

  repeat     : REPEAT statement UNTIL expr SEMICOLON
             { n(:Repeat, *val) }
             ;

  while      : WHILE LPAREN expr RPAREN statement
             { n(:While, *val) }
             ;

  ##############################################################################
  # Expressions
  ##############################################################################

  assign_exp : lval ASS_EQ expr
             { n(:Assignment, *val) }
             | lval ASS_EQ ref
             { n(:Assignment, *val) }
             | lval ADD_EQ expr
             { n(:Assignment, *val) }
             | lval SUB_EQ expr
             { n(:Assignment, *val) }
             | lval MUL_EQ expr
             { n(:Assignment, *val) }
             | lval DIV_EQ expr
             { n(:Assignment, *val) }
             | lval MOD_EQ expr
             { n(:Assignment, *val) }
             | lval SRL_EQ expr
             { n(:Assignment, *val) }
             | lval SRA_EQ expr
             { n(:Assignment, *val) }
             | lval SLL_EQ expr
             { n(:Assignment, *val) }
             ;

  call_exp   : lval LPAREN args RPAREN
             { n(:Call, *val) }
             | lval LPAREN RPAREN
             { n(:Call, *val) }
             ;

  decr_exp   : DECR lval
             { n(:Decrement, val[0]) }
             | lval DECR
             { n(:Decrement, val[0]) }
             ;

  incr_exp   : INCR lval
             { n(:Increment, val[0]) }
             | lval INCR
             { n(:Increment, val[0]) }
             ;

  expr       : LPAREN expr RPAREN
             { n(:Expression, *val) }
             | expr AND expr
             { n(:Expression, *val) }
             | NOT expr
             { n(:Expression, *val) }
             | expr OR expr
             { n(:Expression, *val) }
             | expr ADD expr
             { n(:Expression, *val) }
             | expr SUB expr
             { n(:Expression, *val) }
             | SUB expr =UMINUS
             { n(:Expression, *val) }
             | BIT_NOT expr
             { n(:Expression, *val) }
             | expr MUL expr
             { n(:Expression, *val) }
             | expr EXP expr
             { n(:Expression, *val) }
             | expr DIV expr
             { n(:Expression, *val) }
             | expr MOD expr
             { n(:Expression, *val) }
             | expr AMPERSAND expr
             { n(:Expression, *val) }
             | expr BIT_XOR expr
             { n(:Expression, *val) }
             | expr BIT_OR expr
             { n(:Expression, *val) }
             | expr BIT_SRA expr
             { n(:Expression, *val) }
             | expr BIT_SRL expr
             { n(:Expression, *val) }
             | expr BIT_SLL expr
             { n(:Expression, *val) }
             | incr_exp
             { val[0] }
             | decr_exp
             { val[0] }
             | expr SUBSTR_EQ expr
             { n(:Expression, *val) }
             | expr SUBSTR_NE expr
             { n(:Expression, *val) }
             | expr REGEX_EQ expr
             { n(:Expression, *val) }
             | expr REGEX_NE expr
             { n(:Expression, *val) }
             | expr CMP_LT expr
             { n(:Expression, *val) }
             | expr CMP_GT expr
             { n(:Expression, *val) }
             | expr CMP_EQ expr
             { n(:Expression, *val) }
             | expr CMP_NE expr
             { n(:Expression, *val) }
             | expr CMP_GE expr
             { n(:Expression, *val) }
             | expr CMP_LE expr
             { n(:Expression, *val) }
             | assign_exp
             { val[0] }
             | string
             { val[0] }
             | call_exp
             { val[0] }
             | lval
             { val[0] }
             | ip
             { val[0] }
             | int
             { val[0] }
             | undef
             { val[0] }
             | list_expr
             { val[0] }
             | array_expr
             { val[0] }
             ;

  ##############################################################################
  # Named Components
  ##############################################################################

  arg        : ident COLON expr
             { n(:Argument, *val) }
             | ident COLON ref
             { n(:Argument, *val) }
             | expr
             { n(:Argument, *val) }
             | ref
             { n(:Argument, *val) }
             ;

  kv_pair    : string COLON expr
             { n(:KeyValuePair, *val) }
             | int COLON expr
             { n(:KeyValuePair, *val) }
             | ident COLON expr
             { n(:KeyValuePair, *val) }
             | string COLON ref
             { n(:KeyValuePair, *val) }
             | int COLON ref
             { n(:KeyValuePair, *val) }
             | ident COLON ref
             { n(:KeyValuePair, *val) }
             ;

  kv_pairs   : kv_pair COMMA kv_pairs
             { [val[0]] + val[2] }
             | kv_pair COMMA
             { [val[0]] }
             | kv_pair
             { [val[0]] }
             ;

  lval       : ident indexes
             { n(:Lvalue, *val) }
             | ident
             { n(:Lvalue, *val) }
             ;

  ref        : AT_SIGN ident
             { n(:Reference, val[1]) }
             ;

  ##############################################################################
  # Anonymous Components
  ##############################################################################

  args       : arg COMMA args
             { [val[0]] + val[2] }
             | arg
             { [val[0]] }
             ;

  array_expr : LBRACE kv_pairs RBRACE
             { n(:Array, *val) }
             | LBRACE RBRACE
             { n(:Array, *val) }
             ;

  field      : assign_exp
             { val[0] }
             | call_exp
             { val[0] }
             | decr_exp
             { val[0] }
             | incr_exp
             { val[0] }
             | /* Blank */
             { nil }
             ;

  index      : LBRACK expr RBRACK
             { val[1] }
             | PERIOD ident
             { val[1] }
             ;

  indexes    : index indexes
             { [val[0]] + val[1] }
             | index
             { [val[0]] }
             ;

  list_elem  : expr
             { val[0] }
             | ref
             { val[0] }
             ;

  list_elems : list_elem COMMA list_elems
             { [val[0]] + val[2] }
             | list_elem
             { [val[0]] }
             ;

  list_expr  : LBRACK list_elems RBRACK
             { n(:List, *val) }
             | LBRACK RBRACK
             { n(:List, *val) }
             ;

  param      : AMPERSAND ident
             { n(:Parameter, val[1], 'reference') }
             | ident
             { n(:Parameter, val[0], 'value') }
             ;

  params     : param COMMA params
             { [val[0]] + val[2] }
             | param
             { [val[0]] }
             ;

  statements : statement statements
             { [val[0]] + val[1] }
             | statement
             { [val[0]] }
             ;

  var_decl   : ident ASS_EQ expr
             { n(:Assignment, *val) }
             | ident ASS_EQ ref
             { n(:Assignment, *val) }
             | ident
             { val[0] }
             ;

  var_decls  : var_decl COMMA var_decls
             { [val[0]] + val[2] }
             | var_decl
             { [val[0]] }
             ;

  ##############################################################################
  # Literals
  ##############################################################################

  ident      : IDENT
             { n(:Identifier, *val) }
             | REP
             { n(:Identifier, *val) }
             | IN
             { n(:Identifier, *val) }
             ;

  int        : INT_DEC
             { n(:Integer, *val) }
             | INT_HEX
             { n(:Integer, *val) }
             | INT_OCT
             { n(:Integer, *val) }
             | FALSE
             { n(:Integer, *val) }
             | TRUE
             { n(:Integer, *val) }
             ;

  ip         : int PERIOD int PERIOD int PERIOD int
             { n(:Ip, *val) }

  string     : DATA
             { n(:String, *val) }
             | STRING
             { n(:String, *val) }
             ;

  undef      : UNDEF
             { n(:Undefined, *val) }
             ;
end

---- header ----

require 'nasl/parser/tree'

require 'nasl/parser/argument'
require 'nasl/parser/array'
require 'nasl/parser/assigment'
require 'nasl/parser/block'
require 'nasl/parser/break'
require 'nasl/parser/call'
require 'nasl/parser/comment'
require 'nasl/parser/continue'
require 'nasl/parser/decrement'
require 'nasl/parser/empty'
require 'nasl/parser/export'
require 'nasl/parser/expression'
require 'nasl/parser/for'
require 'nasl/parser/foreach'
require 'nasl/parser/function'
require 'nasl/parser/global'
require 'nasl/parser/identifier'
require 'nasl/parser/if'
require 'nasl/parser/import'
require 'nasl/parser/include'
require 'nasl/parser/increment'
require 'nasl/parser/integer'
require 'nasl/parser/ip'
require 'nasl/parser/key_value_pair'
require 'nasl/parser/list'
require 'nasl/parser/local'
require 'nasl/parser/lvalue'
require 'nasl/parser/parameter'
require 'nasl/parser/reference'
require 'nasl/parser/repeat'
require 'nasl/parser/repetition'
require 'nasl/parser/return'
require 'nasl/parser/string'
require 'nasl/parser/undefined'
require 'nasl/parser/while'

---- inner ----

def n(cls, *args)
  begin
    Nasl.const_get(cls).new(@tree, *args)
  rescue
    puts "An exception occurred during the creation of a #{cls} instance."
    puts
    puts "The arguments passed to the constructor were:"
    puts args
    puts
    puts @tok.last.context
    puts
    raise
  end
end

def c(*args)
  n(:Comment, *args)
  args[1]
end

def on_error(type, value, stack)
  raise ParseException, "The language's grammar does not permit #{value.name} to appear here", value.context
end

def next_token
  @tok = @tkz.get_token

  if @first && @tok.first == :COMMENT
    n(:Comment, @tok.last)
    @tok = @tkz.get_token
  end
  @first = false

  return @tok
end

def parse(env, code, path)
  @first = true
  @tree = Tree.new(env)
  @tkz = Tokenizer.new(code, path)
  @tree.concat(do_parse)
end

---- footer ----