nasl 0.0.1

data/lib/nasl/grammar.racc

@@ -0,0 +1,513 @@
+################################################################################
+# Copyright (c) 2011, Mak Kolybabi
+# 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 BIT_AND
+  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       : export
+             { val[0] }
+             | 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] }
+             | 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
+             { n(:Assignment, *val[0], val[1]) }
+             ;
+
+  break      : BREAK SEMICOLON
+             { n(:Break, *val) }
+             ;
+
+  call       : call_exp SEMICOLON
+             { n(:Call, *val[0], val[1]) }
+             ;
+
+  continue   : CONTINUE SEMICOLON
+             { n(:Continue, *val) }
+             ;
+
+  decr       : decr_exp SEMICOLON
+             { n(:Decrement, *val[0], val[1]) }
+             ;
+
+  empty      : SEMICOLON
+             { n(:Empty, *val) }
+             ;
+
+  global     : GLOBAL idents SEMICOLON
+             { n(:Global, *val) }
+             ;
+
+  incr       : incr_exp SEMICOLON
+             { n(:Increment, *val[0], val[1]) }
+             ;
+
+  import     : IMPORT LPAREN string RPAREN SEMICOLON
+             { n(:Import, *val) }
+             ;
+
+  include    : INCLUDE LPAREN string RPAREN SEMICOLON
+             { n(:Include, *val) }
+             ;
+
+  local      : LOCAL idents SEMICOLON
+             { n(:Local, *val) }
+             ;
+
+  rep        : call_exp REP expr SEMICOLON
+             { n(:Repetition, n(:Call, *val[0]), *val[1..-1]) }
+             ;
+
+  return     : RETURN expr 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) }
+             ;
+
+  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
+             { val }
+             | lval ADD_EQ expr
+             { val }
+             | lval SUB_EQ expr
+             { val }
+             | lval MUL_EQ expr
+             { val }
+             | lval DIV_EQ expr
+             { val }
+             | lval MOD_EQ expr
+             { val }
+             | lval SRL_EQ expr
+             { val }
+             | lval SRA_EQ expr
+             { val }
+             | lval SLL_EQ expr
+             { val }
+             ;
+
+  call_exp   : ident LPAREN args RPAREN
+             { val }
+             | ident LPAREN RPAREN
+             { val }
+
+  decr_exp   : DECR lval
+             { val }
+             | lval DECR
+             { val }
+             ;
+
+  incr_exp   : INCR lval
+             { val }
+             | lval INCR
+             { val }
+             ;
+
+  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 BIT_AND 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
+             { n(:Increment, *val[0]) }
+             | decr_exp
+             { n(:Decrement, *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
+             { n(:Assignment, *val[0]) }
+             | string
+             { val[0] }
+             | call_exp
+             { n(:Call, *val[0]) }
+             | lval
+             { val[0] }
+             | ip
+             { val[0] }
+             | int
+             { val[0] }
+             | undef
+             { val[0] }
+             ;
+
+  ##############################################################################
+  # Named Components
+  ##############################################################################
+
+  arg        : ident COLON expr
+             { n(:Argument, *val) }
+             | expr
+             { n(:Argument, *val) }
+             ;
+
+  lval       : ident indexes
+             { n(:Lvalue, *val) }
+             | ident
+             { n(:Lvalue, *val) }
+             ;
+
+  ##############################################################################
+  # Anonymous Components
+  ##############################################################################
+
+  args       : arg COMMA args
+             { [val[0]] + val[2] }
+             | arg
+             { [val[0]] }
+             ;
+
+  field      : assign_exp
+             { val[0] }
+             | call_exp
+             { val[0] }
+             | decr_exp
+             { val[0] }
+             | incr_exp
+             { val[0] }
+             | /* Blank */
+             { nil }
+             ;
+
+  idents     : ident COMMA idents
+             { [val[0]] + val[2] }
+             | ident
+             { [val[0]] }
+             ;
+
+  indexes    : LBRACK expr RBRACK indexes
+             { [val[1]] + val[3] }
+             | LBRACK expr RBRACK
+             { [val[1]] }
+             ;
+
+  params     : ident COMMA params
+             { [val[0]] + val[2] }
+             | ident
+             { [val[0]] }
+             ;
+
+  statements : statement statements
+             { [val[0]] + val[1] }
+             | statement
+             { [val[0]] }
+             ;
+
+  ##############################################################################
+  # Literals
+  ##############################################################################
+
+  ident      : IDENT
+             { n(:Identifier, *val) }
+             | REP
+             { 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/assigment'
+require 'nasl/parser/block'
+require 'nasl/parser/break'
+require 'nasl/parser/call'
+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/local'
+require 'nasl/parser/lvalue'
+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 constructer were:"
+    puts args
+    puts
+    puts @tok.last.context
+    puts
+    raise
+  end
+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
+end
+
+def parse(env, code, path)
+  @tree = Tree.new(env)
+  @tkz = Tokenizer.new(code, path)
+  @tree.concat(do_parse)
+end
+
+---- footer ----