racc 1.4.14 → 1.4.15-java

data/test/assets/namae.y

@@ -0,0 +1,302 @@
+# -*- ruby -*-
+# vi: set ft=ruby :
+
+# Copyright (C) 2012 President and Fellows of Harvard College
+# Copyright (C) 2013-2014 Sylvester Keil
+#
+# 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 HOLDER ``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.
+#
+# The views and conclusions contained in the software and documentation are
+# those of the authors and should not be interpreted as representing official
+# policies, either expressed or implied, of the copyright holder.
+
+class Namae::Parser
+
+token COMMA UWORD LWORD PWORD NICK AND APPELLATION TITLE SUFFIX
+
+expect 0
+
+rule
+
+  names :                { result = [] }
+        | name           { result = [val[0]] }
+        | names AND name { result = val[0] << val[2] }
+
+  name : word            { result = Name.new(:given => val[0]) }
+       | display_order
+       | honorific word          { result = val[0].merge(:family => val[1]) }
+       | honorific display_order { result = val[1].merge(val[0]) }
+       | sort_order
+
+  honorific : APPELLATION { result = Name.new(:appellation => val[0]) }
+            | TITLE       { result = Name.new(:title => val[0]) }
+
+  display_order : u_words word opt_suffices opt_titles
+       {
+         result = Name.new(:given => val[0], :family => val[1],
+           :suffix => val[2], :title => val[3])
+       }
+       | u_words NICK last opt_suffices opt_titles
+       {
+         result = Name.new(:given => val[0], :nick => val[1],
+           :family => val[2], :suffix => val[3], :title => val[4])
+       }
+       | u_words NICK von last opt_suffices opt_titles
+       {
+         result = Name.new(:given => val[0], :nick => val[1],
+           :particle => val[2], :family => val[3],
+           :suffix => val[4], :title => val[5])
+       }
+       | u_words von last
+       {
+         result = Name.new(:given => val[0], :particle => val[1],
+          :family => val[2])
+       }
+       | von last
+       {
+         result = Name.new(:particle => val[0], :family => val[1])
+       }
+
+  sort_order : last COMMA first
+       {
+         result = Name.new({ :family => val[0], :suffix => val[2][0],
+           :given => val[2][1] }, !!val[2][0])
+       }
+       | von last COMMA first
+       {
+         result = Name.new({ :particle => val[0], :family => val[1],
+           :suffix => val[3][0], :given => val[3][1] }, !!val[3][0])
+       }
+       | u_words von last COMMA first
+       {
+         result = Name.new({ :particle => val[0,2].join(' '), :family => val[2],
+           :suffix => val[4][0], :given => val[4][1] }, !!val[4][0])
+       }
+       ;
+
+  von : LWORD
+      | von LWORD         { result = val.join(' ') }
+      | von u_words LWORD { result = val.join(' ') }
+
+  last : LWORD | u_words
+
+  first : opt_words                 { result = [nil,val[0]] }
+        | words opt_comma suffices  { result = [val[2],val[0]] }
+        | suffices                  { result = [val[0],nil] }
+        | suffices COMMA words      { result = [val[0],val[2]] }
+
+  u_words : u_word
+          | u_words u_word { result = val.join(' ') }
+
+  u_word : UWORD | PWORD
+
+  words : word
+        | words word { result = val.join(' ') }
+
+  opt_comma : /* empty */ | COMMA
+  opt_words : /* empty */ | words
+
+  word : LWORD | UWORD | PWORD
+
+  opt_suffices : /* empty */ | suffices
+
+  suffices : SUFFIX
+           | suffices SUFFIX { result = val.join(' ') }
+
+  opt_titles : /* empty */ | titles
+
+  titles : TITLE
+         | titles TITLE { result = val.join(' ') }
+
+---- header
+require 'singleton'
+require 'strscan'
+
+---- inner
+
+  include Singleton
+
+  attr_reader :options, :input
+
+  def initialize
+    @input, @options = StringScanner.new(''), {
+      :debug => false,
+      :prefer_comma_as_separator => false,
+      :comma => ',',
+      :stops => ',;',
+      :separator => /\s*(\band\b|\&|;)\s*/i,
+      :title => /\s*\b(sir|lord|count(ess)?|(gen|adm|col|maj|capt|cmdr|lt|sgt|cpl|pvt|prof|dr|md|ph\.?d)\.?)(\s+|$)/i,
+      :suffix => /\s*\b(JR|Jr|jr|SR|Sr|sr|[IVX]{2,})(\.|\b)/,
+      :appellation => /\s*\b((mrs?|ms|fr|hr)\.?|miss|herr|frau)(\s+|$)/i
+    }
+  end
+
+  def debug?
+    options[:debug] || ENV['DEBUG']
+  end
+
+  def separator
+    options[:separator]
+  end
+
+  def comma
+    options[:comma]
+  end
+
+  def stops
+    options[:stops]
+  end
+
+  def title
+    options[:title]
+  end
+
+  def suffix
+    options[:suffix]
+  end
+
+  def appellation
+    options[:appellation]
+  end
+
+  def prefer_comma_as_separator?
+    options[:prefer_comma_as_separator]
+  end
+
+  def parse(input)
+    parse!(input)
+  rescue => e
+    warn e.message if debug?
+    []
+  end
+
+  def parse!(string)
+    input.string = normalize(string)
+    reset
+    do_parse
+  end
+
+  def normalize(string)
+    string = string.strip
+    string
+  end
+
+  def reset
+    @commas, @words, @initials, @suffices, @yydebug = 0, 0, 0, 0, debug?
+    self
+  end
+
+  private
+
+  def stack
+    @vstack || @racc_vstack || []
+  end
+
+  def last_token
+    stack[-1]
+  end
+
+  def consume_separator
+    return next_token if seen_separator?
+    @commas, @words, @initials, @suffices = 0, 0, 0, 0
+    [:AND, :AND]
+  end
+
+  def consume_comma
+    @commas += 1
+    [:COMMA, :COMMA]
+  end
+
+  def consume_word(type, word)
+    @words += 1
+
+    case type
+    when :UWORD
+      @initials += 1 if word =~ /^[[:upper:]]+\b/
+    when :SUFFIX
+      @suffices += 1
+    end
+
+    [type, word]
+  end
+
+  def seen_separator?
+    !stack.empty? && last_token == :AND
+  end
+
+  def suffix?
+    !@suffices.zero? || will_see_suffix?
+  end
+
+  def will_see_suffix?
+    input.peek(8).to_s.strip.split(/\s+/)[0] =~ suffix
+  end
+
+  def will_see_initial?
+    input.peek(6).to_s.strip.split(/\s+/)[0] =~ /^[[:upper:]]+\b/
+  end
+
+  def seen_full_name?
+    prefer_comma_as_separator? && @words > 1 &&
+      (@initials > 0 || !will_see_initial?) && !will_see_suffix?
+  end
+
+  def next_token
+    case
+    when input.nil?, input.eos?
+      nil
+    when input.scan(separator)
+      consume_separator
+    when input.scan(/\s*#{comma}\s*/)
+      if @commas.zero? && !seen_full_name? || @commas == 1 && suffix?
+        consume_comma
+      else
+        consume_separator
+      end
+    when input.scan(/\s+/)
+      next_token
+    when input.scan(title)
+      consume_word(:TITLE, input.matched.strip)
+    when input.scan(suffix)
+      consume_word(:SUFFIX, input.matched.strip)
+    when input.scan(appellation)
+      [:APPELLATION, input.matched.strip]
+    when input.scan(/((\\\w+)?\{[^\}]*\})*[[:upper:]][^\s#{stops}]*/)
+      consume_word(:UWORD, input.matched)
+    when input.scan(/((\\\w+)?\{[^\}]*\})*[[:lower:]][^\s#{stops}]*/)
+      consume_word(:LWORD, input.matched)
+    when input.scan(/(\\\w+)?\{[^\}]*\}[^\s#{stops}]*/)
+      consume_word(:PWORD, input.matched)
+    when input.scan(/('[^'\n]+')|("[^"\n]+")/)
+      consume_word(:NICK, input.matched[1...-1])
+    else
+      raise ArgumentError,
+        "Failed to parse name #{input.string.inspect}: unmatched data at offset #{input.pos}"
+    end
+  end
+
+  def on_error(tid, value, stack)
+    raise ArgumentError,
+      "Failed to parse name: unexpected '#{value}' at #{stack.inspect}"
+  end
+
+# -*- racc -*-

data/test/assets/nasl.y

@@ -0,0 +1,626 @@
+################################################################################
+# 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 constructer 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 ----