opal-wedge 0.9.0.dev

data/stdlib/racc/parser.rb

@@ -0,0 +1,215 @@
+# Opal port of racc/parser.rb.
+#
+# Original license:
+#
+# $originalId: parser.rb,v 1.8 2006/07/06 11:42:07 aamine Exp $
+#
+# Copyright (c) 1999-2006 Minero Aoki
+#
+# This program is free software.
+# You can distribute/modify this program under the same terms of ruby.
+#
+# As a special exception, when this code is copied by Racc
+# into a Racc output file, you may use that output file
+# without restriction.
+module Racc
+
+  class Parser
+
+    def _racc_setup
+      self.class::Racc_arg
+    end
+
+    def do_parse
+      _racc_do_parse_rb _racc_setup, false
+    end
+
+    def _racc_do_parse_rb(arg, in_debug)
+      action_table   = arg[0]
+      action_check   = arg[1]
+      action_default = arg[2]
+      action_pointer = arg[3]
+
+      goto_table     = arg[4]
+      goto_check     = arg[5]
+      goto_default   = arg[6]
+      goto_pointer   = arg[7]
+
+      nt_base        = arg[8]
+      reduce_table   = arg[9]
+      token_table    = arg[10]
+      shift_n        = arg[11]
+      reduce_n       = arg[12]
+
+      use_result     = arg[13]
+
+      # racc sys vars
+      racc_state     = [0]
+      racc_tstack    = []
+      racc_vstack    = []
+
+      racc_t         = nil
+      racc_tok       = nil
+      racc_val       = nil
+      racc_read_next = true
+
+      racc_user_yyerror = false
+      racc_error_status = 0
+
+      token = nil; act = nil; i = nil; nerr = nil; custate = nil
+
+      while true
+        i = action_pointer[racc_state[-1]]
+
+        if i
+          if racc_read_next
+            if racc_t != 0 # not EOF
+              token = next_token
+
+              racc_tok = token[0]
+              racc_val = token[1]
+
+              if racc_tok == false # EOF
+                racc_t = 0
+              else
+                racc_t = token_table[racc_tok]
+                racc_t = 1 unless racc_t
+                # racc_t ||= 1
+              end
+
+              racc_read_token(racc_t, racc_tok, racc_val) if @yydebug
+              racc_read_next = false
+            end
+          end
+
+          i += racc_t
+
+          if (i < 0) || (act = action_table[i]).nil? || (action_check[i] != racc_state[-1])
+            act = action_default[racc_state[-1]]
+          end
+
+        else
+          act = action_default[racc_state[-1]]
+        end
+
+        puts "(act: #{act}, shift_n: #{shift_n}, reduce_n: #{reduce_n})" if @yydebug
+        if act > 0 && act < shift_n
+          if racc_error_status > 0
+            if racc_t != 1
+              racc_error_status -= 1
+            end
+          end
+
+          racc_vstack.push racc_val
+          curstate = act
+          racc_state << act
+          racc_read_next = true
+
+          if @yydebug
+            racc_tstack.push racc_t
+            racc_shift racc_t, racc_tstack, racc_vstack
+          end
+
+        elsif act < 0 && act > -reduce_n
+          reduce_i   = act * -3
+          reduce_len = reduce_table[reduce_i]
+          reduce_to  = reduce_table[reduce_i + 1]
+          method_id  = reduce_table[reduce_i + 2]
+
+          tmp_t = racc_tstack.last reduce_len
+          tmp_v = racc_vstack.last reduce_len
+
+          racc_state.pop reduce_len
+          racc_vstack.pop reduce_len
+          racc_tstack.pop reduce_len
+
+          if use_result
+            reduce_call_result = self.__send__ method_id, tmp_v, nil, tmp_v[0]
+            racc_vstack.push reduce_call_result
+          else
+            raise "not using result??"
+          end
+
+          racc_tstack.push reduce_to
+
+          if @yydebug
+            racc_reduce tmp_t, reduce_to, racc_tstack, racc_vstack
+          end
+
+          k1 = reduce_to - nt_base
+
+          if (reduce_i = goto_pointer[k1]) != nil
+            reduce_i += racc_state[-1]
+
+            if (reduce_i >= 0) && ((curstate = goto_table[reduce_i]) != nil) && (goto_check[reduce_i] == k1)
+              racc_state.push curstate
+            else
+              racc_state.push goto_default[k1]
+            end
+
+          else
+            racc_state.push goto_default[k1]
+          end
+
+        elsif act == shift_n
+          # action
+          return racc_vstack[0]
+
+        elsif act == -reduce_n
+          # reduce
+          raise SyntaxError, "unexpected '#{racc_tok.inspect}'"
+
+        else
+          raise "Rac: unknown action: #{act}"
+        end
+
+        if @yydebug
+          racc_next_state racc_state[-1], racc_state
+        end
+        # raise "and finished loop"
+      end
+
+    end # _racc_do_parse_rb
+
+    def racc_read_token(t, tok, val)
+      puts "read    #{tok}(#{racc_token2str(t)}) #{val.inspect}"
+      puts "\n"
+    end
+
+    def racc_shift(tok, tstack, vstack)
+      puts "shift  #{racc_token2str tok}"
+      racc_print_stacks tstack, vstack
+      puts "\n"
+    end
+
+    def racc_reduce(toks, sim, tstack, vstack)
+      puts "reduce #{toks.empty? ? '<none>' : toks.map { |t| racc_token2str(t) }}"
+      puts "  --> #{racc_token2str(sim)}"
+      racc_print_stacks tstack, vstack
+    end
+
+    def racc_next_state(curstate, state)
+      puts "goto  #{curstate}"
+      racc_print_states state
+      puts "\n"
+    end
+
+    def racc_token2str(tok)
+      self.class::Racc_token_to_s_table[tok]
+    end
+
+    def racc_print_stacks(t, v)
+      puts '  ['
+      t.each_index do |i|
+        puts "    (#{racc_token2str(t[i])} #{v[i].inspect})"
+      end
+      puts '  ]'
+    end
+
+    def racc_print_states(s)
+      puts '  ['
+      s.each { |st| puts "   #{st}" }
+      puts '  ]'
+    end
+  end
+end

data/stdlib/rbconfig.rb

@@ -0,0 +1,18 @@
+module RbConfig
+  versions = RUBY_VERSION.split('.')
+  CONFIG = {
+    'ruby_version' => RUBY_VERSION,
+    'MAJOR'        => versions[0],
+    'MINOR'        => versions[1],
+    'TEENY'        => versions[2],
+    'RUBY'         => RUBY_ENGINE,
+    'RUBY_INSTALL_NAME' => RUBY_ENGINE,
+    'RUBY_SO_NAME'      => RUBY_ENGINE,
+    'target_os'         => 'ECMA-262',
+    'host_os'           => 'ECMA-262',
+    'PATH_SEPARATOR'    => ':'
+  }
+end
+
+# required for mspec it would appear
+RUBY_EXE = 'bundle exec bin/opal'

data/stdlib/securerandom.rb

@@ -0,0 +1,12 @@
+module SecureRandom
+  def self.uuid
+    "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".gsub /[xy]/ do |ch,|
+      %x{
+        var r = Math.random() * 16 | 0,
+            v = ch == "x" ? r : (r & 3 | 8);
+
+        return v.toString(16);
+      }
+    end
+  end
+end

data/stdlib/set.rb

@@ -0,0 +1,170 @@
+class Set
+  include Enumerable
+
+  def self.[](*ary)
+    new(ary)
+  end
+
+  def initialize(enum = nil, &block)
+    @hash = Hash.new
+
+    return if enum.nil?
+    raise ArgumentError, 'value must be enumerable' unless Enumerable === enum
+
+    if block
+      enum.each { |item| add block.call(item) }
+    else
+      merge(enum)
+    end
+  end
+
+  def dup
+    result = self.class.new
+    result.merge(self)
+  end
+
+  def -(enum)
+    unless enum.respond_to? :each
+      raise ArgumentError, "value must be enumerable"
+    end
+
+    dup.subtract(enum)
+  end
+  alias difference -
+
+  def inspect
+    "#<Set: {#{to_a.join(',')}}>"
+  end
+
+  def ==(other)
+    if self.equal?(other)
+      true
+    elsif other.instance_of?(self.class)
+      @hash == other.instance_variable_get(:@hash)
+    elsif other.is_a?(Set) && self.size == other.size
+      other.all? { |o| @hash.include?(o) }
+    else
+      false
+    end
+  end
+
+  def add(o)
+    @hash[o] = true
+    self
+  end
+  alias << add
+
+  def classify(&block)
+    return enum_for(:classify) unless block_given?
+
+    result = Hash.new { |h, k| h[k] = self.class.new }
+
+    each { |item| result[yield(item)].add item }
+
+    result
+  end
+
+  def collect!(&block)
+    return enum_for(:collect!) unless block_given?
+    result = self.class.new
+    each { |item| result << yield(item) }
+    replace result
+  end
+  alias map! collect!
+
+  def delete(o)
+    @hash.delete(o)
+    self
+  end
+
+  def delete?(o)
+    if include?(o)
+      delete(o)
+      self
+    else
+      nil
+    end
+  end
+
+  def delete_if
+    block_given? or return enum_for(__method__)
+    # @hash.delete_if should be faster, but using it breaks the order
+    # of enumeration in subclasses.
+    select { |o| yield o }.each { |o| @hash.delete(o) }
+    self
+  end
+
+  def add?(o)
+    if include?(o)
+      nil
+    else
+      add(o)
+    end
+  end
+
+  def each(&block)
+    return enum_for :each unless block_given?
+    @hash.each_key(&block)
+    self
+  end
+
+  def empty?
+    @hash.empty?
+  end
+
+  def eql?(other)
+    @hash.eql?(other.instance_eval { @hash })
+  end
+
+  def clear
+    @hash.clear
+    self
+  end
+
+  def include?(o)
+    @hash.include?(o)
+  end
+  alias member? include?
+
+  def merge(enum)
+    enum.each { |item| add item }
+    self
+  end
+
+  def replace(enum)
+    clear
+    merge(enum)
+
+    self
+  end
+
+  def size
+    @hash.size
+  end
+  alias length size
+
+  def subtract(enum)
+    enum.each { |item| delete item }
+    self
+  end
+  
+  def |(enum)
+    unless enum.respond_to? :each
+      raise ArgumentError, "value must be enumerable"
+    end
+    dup.merge(enum)
+  end
+  
+  alias + |
+  alias union |
+
+  def to_a
+    @hash.keys
+  end
+end
+
+module Enumerable
+  def to_set(klass = Set, *args, &block)
+    klass.new(self, *args, &block)
+  end
+end

data/stdlib/singleton.rb

@@ -0,0 +1,40 @@
+module Singleton
+  def clone
+    raise TypeError, "can't clone instance of singleton #{self.class}"
+  end
+
+  def dup
+    raise TypeError, "can't dup instance of singleton #{self.class}"
+  end
+
+  module SingletonClassMethods
+
+    def clone
+      Singleton.__init__(super)
+    end
+
+    def inherited(sub_klass)
+      super
+      Singleton.__init__(sub_klass)
+    end
+  end
+
+  class << Singleton
+    def __init__(klass)
+      klass.instance_eval {
+        @singleton__instance__ = nil
+      }
+      def klass.instance
+        return @singleton__instance__ if @singleton__instance__
+        @singleton__instance__ = new()
+      end
+      klass
+    end
+
+    def included(klass)
+      super
+      klass.extend SingletonClassMethods
+      Singleton.__init__(klass)
+    end
+  end
+end