gd-racc 1.4.11

data/lib/racc/statetransitiontable.rb

@@ -0,0 +1,316 @@
+#
+# $Id: 4c5f4311663b6d03050953d64d6a0e7905ff2216 $
+#
+# Copyright (c) 1999-2006 Minero Aoki
+#
+# This program is free software.
+# You can distribute/modify this program under the terms of
+# the GNU LGPL, Lesser General Public License version 2.1.
+# For details of LGPL, see the file "COPYING".
+#
+
+require 'racc/parser'
+
+unless Object.method_defined?(:funcall)
+  class Object
+    alias funcall __send__
+  end
+end
+
+module Racc
+
+  StateTransitionTable = Struct.new(:action_table,
+                                    :action_check,
+                                    :action_default,
+                                    :action_pointer,
+                                    :goto_table,
+                                    :goto_check,
+                                    :goto_default,
+                                    :goto_pointer,
+                                    :token_table,
+                                    :reduce_table,
+                                    :reduce_n,
+                                    :shift_n,
+                                    :nt_base,
+                                    :token_to_s_table,
+                                    :use_result_var,
+                                    :debug_parser)
+  class StateTransitionTable   # reopen
+    def StateTransitionTable.generate(states)
+      StateTransitionTableGenerator.new(states).generate
+    end
+
+    def initialize(states)
+      super()
+      @states = states
+      @grammar = states.grammar
+      self.use_result_var = true
+      self.debug_parser = true
+    end
+
+    attr_reader :states
+    attr_reader :grammar
+
+    def parser_class
+      ParserClassGenerator.new(@states).generate
+    end
+
+    def token_value_table
+      h = {}
+      token_table().each do |sym, i|
+        h[sym.value] = i
+      end
+      h
+    end
+  end
+
+
+  class StateTransitionTableGenerator
+
+    def initialize(states)
+      @states = states
+      @grammar = states.grammar
+    end
+
+    def generate
+      t = StateTransitionTable.new(@states)
+      gen_action_tables t, @states
+      gen_goto_tables t, @grammar
+      t.token_table = token_table(@grammar)
+      t.reduce_table = reduce_table(@grammar)
+      t.reduce_n = @states.reduce_n
+      t.shift_n = @states.shift_n
+      t.nt_base = @grammar.nonterminal_base
+      t.token_to_s_table = @grammar.symbols.map {|sym| sym.to_s }
+      t
+    end
+
+    def reduce_table(grammar)
+      t = [0, 0, :racc_error]
+      grammar.each_with_index do |rule, idx|
+        next if idx == 0
+        t.push rule.size
+        t.push rule.target.ident
+        t.push(if rule.action.empty?   # and @params.omit_action_call?
+               then :_reduce_none
+               else "_reduce_#{idx}".intern
+               end)
+      end
+      t
+    end
+
+    def token_table(grammar)
+      h = {}
+      grammar.symboltable.terminals.each do |t|
+        h[t] = t.ident
+      end
+      h
+    end
+
+    def gen_action_tables(t, states)
+      t.action_table = yytable  = []
+      t.action_check = yycheck  = []
+      t.action_default = yydefact = []
+      t.action_pointer = yypact   = []
+      e1 = []
+      e2 = []
+      states.each do |state|
+        yydefact.push act2actid(state.defact)
+        if state.action.empty?
+          yypact.push nil
+          next
+        end
+        vector = []
+        state.action.each do |tok, act|
+          vector[tok.ident] = act2actid(act)
+        end
+        addent e1, vector, state.ident, yypact
+      end
+      set_table e1, e2, yytable, yycheck, yypact
+    end
+
+    def gen_goto_tables(t, grammar)
+      t.goto_table   = yytable2  = []
+      t.goto_check   = yycheck2  = []
+      t.goto_pointer = yypgoto   = []
+      t.goto_default = yydefgoto = []
+      e1 = []
+      e2 = []
+      grammar.each_nonterminal do |tok|
+        tmp = []
+
+        # decide default
+        freq = Array.new(@states.size, 0)
+        @states.each do |state|
+          st = state.goto_table[tok]
+          if st
+            st = st.ident
+            freq[st] += 1
+          end
+          tmp[state.ident] = st
+        end
+        max = freq.max
+        if max > 1
+          default = freq.index(max)
+          tmp.map! {|i| default == i ? nil : i }
+        else
+          default = nil
+        end
+        yydefgoto.push default
+
+        # delete default value
+        tmp.pop until tmp.last or tmp.empty?
+        if tmp.compact.empty?
+          # only default
+          yypgoto.push nil
+          next
+        end
+
+        addent e1, tmp, (tok.ident - grammar.nonterminal_base), yypgoto
+      end
+      set_table e1, e2, yytable2, yycheck2, yypgoto
+    end
+
+    def addent(all, arr, chkval, ptr)
+      max = arr.size
+      min = nil
+      arr.each_with_index do |item, idx|
+        if item
+          min ||= idx
+        end
+      end
+      ptr.push(-7777)    # mark
+      arr = arr[min...max]
+      all.push [arr, chkval, mkmapexp(arr), min, ptr.size - 1]
+    end
+
+    n = 2 ** 16
+    begin
+      Regexp.compile("a{#{n}}")
+      RE_DUP_MAX = n
+    rescue RegexpError
+      n /= 2
+      retry
+    end
+
+    def mkmapexp(arr)
+      i = ii = 0
+      as = arr.size
+      map = ''
+      maxdup = RE_DUP_MAX
+      curr = nil
+      while i < as
+        ii = i + 1
+        if arr[i]
+          ii += 1 while ii < as and arr[ii]
+          curr = '-'
+        else
+          ii += 1 while ii < as and not arr[ii]
+          curr = '.'
+        end
+
+        offset = ii - i
+        if offset == 1
+          map << curr
+        else
+          while offset > maxdup
+            map << "#{curr}{#{maxdup}}"
+            offset -= maxdup
+          end
+          map << "#{curr}{#{offset}}" if offset > 1
+        end
+        i = ii
+      end
+      Regexp.compile(map, 'n')
+    end
+
+    def set_table(entries, dummy, tbl, chk, ptr)
+      upper = 0
+      map = '-' * 10240
+
+      # sort long to short
+      entries.sort! {|a,b| b[0].size <=> a[0].size }
+
+      entries.each do |arr, chkval, expr, min, ptri|
+        if upper + arr.size > map.size
+          map << '-' * (arr.size + 1024)
+        end
+        idx = map.index(expr)
+        ptr[ptri] = idx - min
+        arr.each_with_index do |item, i|
+          if item
+            i += idx
+            tbl[i] = item
+            chk[i] = chkval
+            map[i] = ?o
+          end
+        end
+        upper = idx + arr.size
+      end
+    end
+
+    def act2actid(act)
+      case act
+      when Shift  then act.goto_id
+      when Reduce then -act.ruleid
+      when Accept then @states.shift_n
+      when Error  then @states.reduce_n * -1
+      else
+        raise "racc: fatal: wrong act type #{act.class} in action table"
+      end
+    end
+
+  end
+
+
+  class ParserClassGenerator
+
+    def initialize(states)
+      @states = states
+      @grammar = states.grammar
+    end
+
+    def generate
+      table = @states.state_transition_table
+      c = Class.new(::Racc::Parser)
+      c.const_set :Racc_arg, [table.action_table,
+                              table.action_check,
+                              table.action_default,
+                              table.action_pointer,
+                              table.goto_table,
+                              table.goto_check,
+                              table.goto_default,
+                              table.goto_pointer,
+                              table.nt_base,
+                              table.reduce_table,
+                              table.token_value_table,
+                              table.shift_n,
+                              table.reduce_n,
+                              false]
+      c.const_set :Racc_token_to_s_table, table.token_to_s_table
+      c.const_set :Racc_debug_parser, true
+      define_actions c
+      c
+    end
+
+    private
+
+    def define_actions(c)
+      c.module_eval "def _reduce_none(vals, vstack) vals[0] end"
+      @grammar.each do |rule|
+        if rule.action.empty?
+          c.funcall(:alias_method, "_reduce_#{rule.ident}", :_reduce_none)
+        else
+          c.funcall(:define_method, "_racc_action_#{rule.ident}", &rule.action.proc)
+          c.module_eval(<<-End, __FILE__, __LINE__ + 1)
+            def _reduce_#{rule.ident}(vals, vstack)
+              _racc_action_#{rule.ident}(*vals)
+            end
+          End
+        end
+      end
+    end
+
+  end
+
+end   # module Racc

data/lib/racc/static.rb

@@ -0,0 +1,5 @@
+require 'racc'
+require 'racc/parser'
+require 'racc/grammarfileparser'
+require 'racc/parserfilegenerator'
+require 'racc/logfilegenerator'

data/misc/dist.sh

@@ -0,0 +1,31 @@
+#!/bin/sh
+
+rm -rf tmp
+mkdir tmp
+cd tmp
+
+# racc, raccrt
+cvs -Q export -r`echo V$version | tr . -` -d racc-$version racc
+cd racc-$version
+    make bootstrap lib/racc/parser-text.rb doc
+    rm -r doc web bits fastcache
+cd ..
+mkdir -p raccrt-$version/lib/racc
+mv racc-$version/lib/racc/parser.rb     raccrt-$version/lib/racc
+mv racc-$version/ext                    raccrt-$version
+cp racc-$version/setup.rb               raccrt-$version
+cp racc-$version/README.*               raccrt-$version
+cp racc-$version/COPYING                raccrt-$version
+tar czf $ardir/racc/racc-$version.tar.gz racc-$version
+tar czf $ardir/raccrt/raccrt-$version.tar.gz raccrt-$version
+
+# -all
+mkdir -p racc-$version-all/packages
+cp racc-$version/setup.rb racc-$version-all
+cp racc-$version/README.* racc-$version-all
+mv racc-$version          racc-$version-all/packages/racc
+mv raccrt-$version        racc-$version-all/packages/raccrt
+tar czf $ardir/racc/racc-$version-all.tar.gz racc-$version-all
+
+cd ..
+rm -rf tmp

data/rdoc/en/NEWS.en.rdoc

@@ -0,0 +1,282 @@
+= NEWS
+
+=== 1.4.6
+
+* Bugfixes
+
+  * bin/racc -g option renamed to -t
+  * racc/compiler.rb is removed
+  * '|' is allowed with meta rules
+  * Ruby 1.8.7 compatibility fixes
+  * Ruby 1.9 compatibility fixes
+
+=== 1.4.5 (2005-11-21)
+  * [FEATURE CHANGE] --no-extensions option was removed.
+  * [fix] racc command should not depend on `raccrt' package.
+  * [fix] --no-omit-actions did not work.
+  * setup.rb 3.4.1.
+
+=== 1.4.4 (2003-10-12)
+  * document changed.
+  * -all packages does not include amstd and strscan.
+  * setup.rb 3.2.1.
+
+=== 1.4.3 (2002-11-14)
+  * [fix] reduce ruby 1.8 warnings.
+
+=== 1.4.2 (2002-01-29)
+  * [new] new option --no-extentions
+
+=== 1.4.1 (2001-12-02)
+  * now Racc does not depend on amstd library.
+  * update y2racc and racc2y for racc 1.4.1
+
+=== 1.4.0 (2001-11-30)
+  * minor version up for checking in runtime library into ruby CVS repositry.
+  * RaccParser, RaccScanner -> GrammarFileParser, GrammarFileScanner
+  * modify typo (grammer -> grammar)
+
+=== 1.3.12 (2001-11-22)
+  * modify installer bug (thanks Tanaka Akira)
+  * enhance regexp/%-strings/gvar detection in action block
+
+=== 1.3.11 (2001-08-28)
+  * modify scan error on $' $` $/ etc.
+
+=== 1.3.10 (2001-08-12)
+  * modify prototype missmatch in cparse.c
+
+=== 1.3.9 (2001-04-07)
+  * support Ruby 1.4 again.
+
+=== 1.3.8 (2001-03-17)
+  * output symbol name when error
+  * Racc::Parser#token_to_str
+
+=== 1.3.7 (2001-02-04)
+  * allow nil for EndOfInput (experimental)
+  * more sample grammar files
+
+=== 1.3.6 (2001-01-22)
+  * modify cparse.so for static link
+
+=== 1.3.5 (2001-01-18)
+  * %-string scanning was wrong
+  * new directive "expect"
+
+=== 1.3.4 (2001-01-11)
+  * cparse: add type checks
+  * cparse: rm depend
+  * cparse: does not pass non-VALUE object to rb_iterate()
+
+=== 1.3.3 (2000-12-25)
+  * <em>critical bug</em> in generator (from 1.3.1)
+  * racc --runtime-version
+
+=== 1.3.2 (2000-12-21)
+  * bug with racc -E
+  * package strscan togather (again)
+
+=== 1.3.1 (2000-12-17)
+  * dynamically determine RE_DUP_MAX
+  * ruby version routine was used always
+
+=== 1.3.0 (2000-11-30)
+  * can yield(sym,val) from scanner (Parser#yyparse)
+
+=== 1.2.6 (2000-11-28)
+  * class M::C
+
+=== 1.2.5 (2000-11-20)
+  * big changes in option; -h -f -p -i -n -c -A are incompatible
+  * support long options
+  * y2racc, racc2y leaves actions as default
+
+=== 1.2.4 (2000-09-13)
+  * updates installer and documents
+
+=== 1.2.3 (2000-08-14)
+  * output useless rules and nonterminals (version 2)
+  * nonassoc makes error (never shift/reduce)
+
+=== 1.2.2 (2000-08-12)
+  * internal changes
+
+=== 1.2.1 (2000-08-05)
+  * racc2y, y2racc
+
+=== 1.2.0 (2000-08-02)
+  * uses bison's lookahead algorithm
+
+=== 1.1.6 (2000-07-25)
+  * new keyword "options" and its parameter "no_result_var"
+
+=== 1.1.5 (2000-07-21)
+  * [IMPORTANT] change keyword "token" to "convert"
+  * NEW keyword "token" for token declearation
+
+=== 1.1.4 (2000-07-13)
+  * update installer
+  * samples had bugs
+
+=== 1.1.3 (2000-06-30)
+  * new option -a; does not omit void action call
+
+=== 1.1.2 (2000-06-29)
+  * now racc does not use strscan.so
+  * ScanError -&gt; Racc::ScanError, ParseError -&gt; Racc::ParseError
+  * more friendly error messages
+
+=== 1.1.1 (2000-06-15)
+  * require miss
+  * conflicts were not reported with -v
+
+=== 1.1.0 (2000-06-12)
+  * use other algolithm for generating state table
+
+=== 1.0.4 (2000-06-04)
+  * S/R conflict & -v flag causes unexpected exception (reported by Tosh)
+  * output useless nonterminals/rules
+
+=== 1.0.3 (2000-06-03)
+  * use Array#collect! instead of #filter.
+
+=== 1.0.2 (2000-05-16)
+  * update installer (setup.rb)
+
+=== 1.0.1 (2000-05-12)
+  * state.rb:  faster lookahead & debug lalr code
+  * refine code
+  * update amstd package (1.7.0)
+
+=== 1.0.0 (2000-05-06)
+  * version 1.0
+
+=== 0.14.6 (2000-05-05)
+  * much more debug output
+
+=== 0.14.5 (2000-05-01)
+
+=== 0.14.4 (2000-04-09)
+  * Racc_* are included in Racc_arg
+  * faster state generation (a little)
+
+=== 0.14.3 (2000-04-04)
+  * check both of SYM2ID and ID2SYM (thanks Katsuyuki Komatsu)
+
+=== 0.14.2 (2000-04-03)
+  * "class" on first line causes parse error (thanks Yoshiki Wada)
+  * new option "racc -V"
+
+=== 0.14.1 (2000-03-31)
+
+=== 0.14.0 (2000-03-21)
+  * implement "fast" table (same to bison)
+  * stop line no. conversion temporaliry because of ruby bug
+
+=== 0.13.1 (2000-03-21)
+  * racc --version --copyright did not work (thanks Tadayoshi Funaba)
+
+=== 0.13.0 (2000-03-20)
+  * implement yyerror/yyerrok/yyaccept
+
+=== 0.12.2 (2000-03-19)
+  * -E flag had bug
+
+=== 0.12.1 (2000-03-16)
+  * modify the way to decide default action
+
+=== 0.12.0 (2000-03-15)
+  * implement real LALR
+  * use both SLR and LALR to resolve conflicts
+
+=== 0.11.3 (2000-03-09)
+  * modify lookahead routine again
+
+=== 0.11.2 (2000-03-09)
+  * bug in lookahead routine
+  * modify cparse.so for Symbol class of ruby 1.5
+
+=== 0.11.1 (2000-03-08)
+  * modify for Symbol
+  * update strscan
+
+=== 0.11.0 (2000-02-19)
+  * if error is occured in action, ruby print line number of grammar file
+
+=== 0.10.9 (2000-01-19)
+  * change package/setup
+
+=== 0.10.8 (2000-01-03)
+  * (1-17 re-packed) add/modify documents
+
+=== 0.10.7 (2000-01-03)
+  * modify setup.rb, compile.rb, amstd/inst. (thanks: Koji Arai)
+
+=== 0.10.6 (1999-12-24)
+  * racc -e ruby
+  * omit void action call
+
+=== 0.10.5 (1999-12-21)
+  * critical bug in embedded action implement
+  * bug in setup.rb
+  * modify calc[2].y for 0.10
+
+=== 0.10.4 (1999-12-19)
+  * support error recover ('error' token)
+  * can embed runtime by "racc -E"
+  * Racc is module
+
+=== 0.10.3 (1999-12-01)
+  * support embedded action
+  * modify .output bug
+
+=== 0.10.2 (1999-11-27)
+  * update document
+  * separate libracc.rb
+
+=== 0.10.1 (1999-11-19)
+  * rewrite runtime routine in C
+  * once next_token returns [false, *], not call next_token
+  * action is only default, not call next_token
+  * $end is obsolute
+  * LALRactionTable
+
+=== 0.10.0 (1999-11-06)
+  * next_value, peep_token is obsolute
+  * @__debug__ -&gt; @yydebug
+  * class...rule...end
+  * refine libracc.rb
+  * unify strscan library
+  * *.rb are installed in lib/ruby/VERSION/racc/
+
+=== 0.9.5 (1999-10-03)
+  * too few arguments for __show_stack__
+  * could not scan $end
+  * typo in d.format.rb
+
+=== 0.9.4 (1999-09-??)
+
+=== 0.9.3 (1999-09-03)
+
+=== 0.9.2 (1999-06-26)
+
+=== 0.9.1 (1999-06-08)
+
+=== 0.9.0 (1999-06-03)
+
+=== 0.8.11 (?)
+
+=== 0.8.10 (?)
+
+=== 0.8.9 (1999-03-21)
+
+=== 0.8.8 (1999-03-20)
+
+=== 0.8.7 (1999-03-01)
+
+=== 0.8.0 (1999-01-16)
+
+=== 0.5.0 (1999-01-07)
+
+=== 0.1.0 (1999-01-01)