enclave 0.1.0

data/ext/enclave/mruby/mrblib/kernel.rb

@@ -0,0 +1,45 @@
+##
+# Kernel
+#
+# ISO 15.3.1
+module Kernel
+
+  # 15.3.1.2.1 Kernel.`
+  # provided by Kernel#`
+  # 15.3.1.3.3
+  def `(s)
+    raise NotImplementedError.new("backquotes not implemented")
+  end
+
+  ##
+  # 15.3.1.2.3  Kernel.eval
+  # 15.3.1.3.12 Kernel#eval
+  # NotImplemented by mruby core; use mruby-eval gem
+
+  ##
+  # ISO 15.3.1.2.8 Kernel.loop
+  # not provided by mruby
+
+  ##
+  # Calls the given block repetitively.
+  #
+  # ISO 15.3.1.3.29
+  private def loop(&block)
+    return to_enum(:loop) unless block
+
+    while true
+      yield
+    end
+  rescue StopIteration => e
+    e.result
+  end
+
+  # 11.4.4 Step c)
+  def !~(y)
+    !(self =~ y)
+  end
+
+  def to_enum(*a)
+    raise NotImplementedError.new("fiber required for enumerator")
+  end
+end

data/ext/enclave/mruby/mrblib/numeric.rb

@@ -0,0 +1,160 @@
+##
+# Numeric
+#
+# ISO 15.2.7
+class Numeric
+  include Comparable
+  ##
+  # Returns the receiver simply.
+  #
+  # ISO 15.2.7.4.1
+  def +@
+    self
+  end
+
+  ##
+  # Returns the receiver's value, negated.
+  #
+  # ISO 15.2.7.4.2
+  def -@
+    0 - self
+  end
+
+  ##
+  # Returns the absolute value of the receiver.
+  #
+  # ISO 15.2.7.4.3
+  def abs
+    if self < 0
+      -self
+    else
+      self
+    end
+  end
+end
+
+##
+# Integer
+#
+# ISO 15.2.8
+##
+class Integer
+  ##
+  # Calls the given block once for each Integer
+  # from `self` downto `num`.
+  #
+  # ISO 15.2.8.3.15
+  def downto(num, &block)
+    return to_enum(:downto, num) unless block
+
+    i = self.to_i
+    while i >= num
+      yield i
+      i -= 1
+    end
+    self
+  end
+
+  ##
+  # Returns self + 1
+  #
+  # ISO 15.2.8.3.19
+  def next
+    self + 1
+  end
+  # ISO 15.2.8.3.21
+  alias succ next
+
+  ##
+  # Calls the given block `self` times.
+  #
+  # ISO 15.2.8.3.22
+  def times(&block)
+    return to_enum(:times) unless block
+
+    i = 0
+    while i < self
+      yield i
+      i += 1
+    end
+    self
+  end
+
+  ##
+  # Calls the given block once for each Integer
+  # from `self` upto `num`.
+  #
+  # ISO 15.2.8.3.27
+  def upto(num, &block)
+    return to_enum(:upto, num) unless block
+
+    i = self.to_i
+    while i <= num
+      yield i
+      i += 1
+    end
+    self
+  end
+
+  ##
+  # Calls the given block from `self` to `num`
+  # incremented by `step` (default 1).
+  #
+  def step(num=nil, step=1, &block)
+    raise ArgumentError, "step can't be 0" if step == 0
+    return to_enum(:step, num, step) unless block
+
+    i = __coerce_step_counter(step)
+    if num == self || step.infinite?
+      block.call(i) if step > 0 && i <= (num||i) || step < 0 && i >= (num||-i)
+    elsif num == nil
+      while true
+        block.call(i)
+        i += step
+      end
+    elsif step > 0
+      while i <= num
+        block.call(i)
+        i += step
+      end
+    else
+      while i >= num
+        block.call(i)
+        i += step
+      end
+    end
+    self
+  end
+end
+
+class Float
+  ##
+  # Calls the given block from `self` to `num`
+  # incremented by `step` (default 1).
+  #
+  def step(num=nil, step=1, &block)
+    raise ArgumentError, "step can't be 0" if step == 0
+    return to_enum(:step, num, step) unless block
+
+    i = self
+    if num == self || step.infinite?
+      block.call(i) if step > 0 && i <= (num||i) || step < 0 && i >= (num||-i)
+    elsif num == nil
+      while true
+        block.call(i)
+        i += step
+      end
+    elsif step > 0
+      while i <= num
+        block.call(i)
+        i += step
+      end
+    else
+      while i >= num
+        block.call(i)
+        i += step
+      end
+    end
+    self
+  end
+end if Object.const_defined?(:Float)

data/ext/enclave/mruby/mrblib/range.rb

@@ -0,0 +1,98 @@
+##
+# Range
+#
+# ISO 15.2.14
+class Range
+  ##
+  # Range is enumerable
+  #
+  # ISO 15.2.14.3
+  include Enumerable
+
+  ##
+  # Calls the given block for each element of `self`
+  # and pass the respective element.
+  #
+  # ISO 15.2.14.4.4
+  def each(&block)
+    return to_enum(:each) unless block
+
+    val = self.begin
+    last = self.end
+
+    if val.kind_of?(Integer) && last.nil?
+      i = val
+      while true
+        block.call(i)
+        i += 1
+      end
+      return self
+    end
+
+    if val.kind_of?(String) && last.nil?
+      if val.respond_to? :__upto_endless
+        return val.__upto_endless(&block)
+      else
+        str_each = true
+      end
+    end
+
+    if val.kind_of?(Integer) && last.kind_of?(Integer) # integers are special
+      lim = last
+      lim += 1 unless exclude_end?
+      i = val
+      while i < lim
+        block.call(i)
+        i += 1
+      end
+      return self
+    end
+
+    if val.kind_of?(String) && last.kind_of?(String) # strings are special
+      if val.respond_to? :upto
+        return val.upto(last, exclude_end?, &block)
+      else
+        str_each = true
+      end
+    end
+
+    raise TypeError, "can't iterate" unless val.respond_to? :succ
+
+    return self if (val <=> last) > 0
+
+    while (val <=> last) < 0
+      block.call(val)
+      val = val.succ
+      if str_each
+        break if val.size > last.size
+      end
+    end
+
+    block.call(val) if !exclude_end? && (val <=> last) == 0
+    self
+  end
+
+  # redefine #hash 15.3.1.3.15
+  def hash
+    # Use self.begin/self.end instead of first/last to handle endless/beginless ranges
+    h = self.begin.hash ^ self.end.hash
+    h += 1 if self.exclude_end?
+    h
+  end
+
+  ##
+  # call-seq:
+  #    rng.to_a                   -> array
+  #    rng.entries                -> array
+  #
+  # Returns an array containing the items in the range.
+  #
+  #   (1..7).to_a  #=> [1, 2, 3, 4, 5, 6, 7]
+  #   (1..).to_a   #=> RangeError: cannot convert endless range to an array
+  def to_a
+    a = __num_to_a
+    return a if a
+    super
+  end
+  alias entries to_a
+end

data/ext/enclave/mruby/mrblib/string.rb

@@ -0,0 +1,173 @@
+##
+# String
+#
+# ISO 15.2.10
+class String
+  # ISO 15.2.10.3
+  include Comparable
+
+  ##
+  # Calls the given block for each line
+  # and pass the respective line.
+  #
+  # ISO 15.2.10.5.15
+  def each_line(separator = "\n", &block)
+    return to_enum(:each_line, separator) unless block
+
+    if separator.nil?
+      block.call(self)
+      return self
+    end
+    raise TypeError unless separator.is_a?(String)
+
+    paragraph_mode = false
+    if separator.empty?
+      paragraph_mode = true
+      separator = "\n\n"
+    end
+    start = 0
+    string = dup
+    self_len = self.bytesize
+    sep_len = separator.bytesize
+
+    while (pointer = string.byteindex(separator, start))
+      pointer += sep_len
+      pointer += 1 while paragraph_mode && string.getbyte(pointer) == 10 # 10 == \n
+      block.call(string.byteslice(start, pointer - start))
+      start = pointer
+    end
+    return self if start == self_len
+
+    block.call(string.byteslice(start, self_len - start))
+    self
+  end
+
+  ##
+  # Replace all matches of `pattern` with `replacement`.
+  # Call block (if given) for each match and replace
+  # `pattern` with the value of the block. Return the
+  # final value.
+  #
+  # ISO 15.2.10.5.18
+  def gsub(*args, &block)
+    return to_enum(:gsub, *args) if args.length == 1 && !block
+    raise ArgumentError, "wrong number of arguments (given #{args.length}, expected 1..2)" unless (1..2).include?(args.length)
+
+    pattern, replace = *args
+    plen = pattern.length
+    if args.length == 2 && block
+      block = nil
+    end
+    offset = 0
+    result = []
+    while found = self.byteindex(pattern, offset)
+      result << self.byteslice(offset, found - offset)
+      offset = found + plen
+      result << if block
+        block.call(pattern).to_s
+      else
+        self.__sub_replace(replace, pattern, found)
+      end
+      if plen == 0
+        result << self.byteslice(offset, 1)
+        offset += 1
+      end
+    end
+    result << self.byteslice(offset..-1) if offset < length
+    result.join
+  end
+
+  ##
+  # Replace all matches of `pattern` with `replacement`.
+  # Call block (if given) for each match and replace
+  # `pattern` with the value of the block. Modify
+  # `self` with the final value.
+  #
+  # ISO 15.2.10.5.19
+  def gsub!(*args, &block)
+    raise FrozenError, "can't modify frozen String" if frozen?
+    return to_enum(:gsub!, *args) if args.length == 1 && !block
+    str = self.gsub(*args, &block)
+    return nil unless self.index(args[0])
+    self.replace(str)
+  end
+
+#  ##
+#  # Calls the given block for each match of `pattern`
+#  # If no block is given return an array with all
+#  # matches of `pattern`.
+#  #
+#  # ISO 15.2.10.5.32
+#  def scan(pattern, &block)
+#    # TODO: String#scan is not implemented yet
+#  end
+
+  ##
+  # Replace only the first match of `pattern` with
+  # `replacement`. Call block (if given) for each
+  # match and replace `pattern` with the value of the
+  # block. Return the final value.
+  #
+  # ISO 15.2.10.5.36
+  def sub(*args, &block)
+    unless (1..2).include?(args.length)
+      raise ArgumentError, "wrong number of arguments (given #{args.length}, expected 2)"
+    end
+
+    pattern, replace = *args
+    if args.length == 2 && block
+      block = nil
+    end
+    result = []
+    found = self.index(pattern)
+    return self.dup unless found
+    result << self.byteslice(0, found)
+    offset = found + pattern.length
+    result << if block
+      block.call(pattern).to_s
+    else
+      self.__sub_replace(replace, pattern, found)
+    end
+    result << self.byteslice(offset..-1) if offset < length
+    result.join
+  end
+
+  ##
+  # Replace only the first match of `pattern` with
+  # `replacement`. Call block (if given) for each
+  # match and replace `pattern` with the value of the
+  # block. Modify `self` with the final value.
+  #
+  # ISO 15.2.10.5.37
+  def sub!(*args, &block)
+    raise FrozenError, "can't modify frozen String" if frozen?
+    str = self.sub(*args, &block)
+    return nil unless self.index(args[0])
+    self.replace(str)
+  end
+
+  ##
+  # Call the given block for each byte of `self`.
+  def each_byte(&block)
+    return to_enum(:each_byte, &block) unless block
+    pos = 0
+    while pos < bytesize
+      block.call(getbyte(pos))
+      pos += 1
+    end
+    self
+  end
+
+  # those two methods requires Regexp that is optional in mruby
+  ##
+  # ISO 15.2.10.5.3
+  #def =~(re)
+  # re =~ self
+  #end
+
+  ##
+  # ISO 15.2.10.5.27
+  #def match(re, &block)
+  #  re.match(self, &block)
+  #end
+end

data/ext/enclave/mruby/mrblib/symbol.rb

@@ -0,0 +1,8 @@
+class Symbol
+  def to_proc
+    mid = self
+    ->(obj,*args,**opts,&block) do
+      obj.__send__(mid, *args, **opts, &block)
+    end
+  end
+end

data/ext/enclave/mruby/oss-fuzz/mruby_fuzzer.c

@@ -0,0 +1,18 @@
+#include <stdlib.h>
+#include <string.h>
+#include <mruby.h>
+#include <mruby/compile.h>
+
+int LLVMFuzzerTestOneInput(uint8_t *Data, size_t size) {
+    if (size < 1) {
+        return 0;
+    }
+    char *code = malloc(size+1);
+    memcpy(code, Data, size);
+    code[size] = '\0';
+    mrb_state *mrb = mrb_open();
+    mrb_load_string(mrb, code);
+    mrb_close(mrb);
+    free(code);
+    return 0;
+}

data/ext/enclave/mruby/oss-fuzz/proto_to_ruby.h

@@ -0,0 +1,55 @@
+#include <cstdint>
+#include <cstddef>
+#include <string>
+#include <ostream>
+#include <sstream>
+#include <stack>
+#include <ruby.pb.h>
+
+namespace ruby_fuzzer {
+  class protoConverter
+  {
+  public:
+    protoConverter() {
+      m_numLiveVars = 1;
+      m_numVarsPerScope.push(m_numLiveVars);
+    }
+    protoConverter(protoConverter const& x) {
+      m_numLiveVars = x.m_numLiveVars;
+      m_numVarsPerScope = x.m_numVarsPerScope;
+    }
+    ~protoConverter() {}
+    std::string FunctionToString(Function const& _input);
+
+  private:
+    void visit(ArrType const&);
+    void visit(Array const&);
+    void visit(AssignmentStatement const&);
+    void visit(BinaryOp const&);
+    void visit(BuiltinFuncs const&);
+    void visit(Const const&);
+    void visit(Function const&);
+    void visit(HashType const&);
+    void visit(IfElse const&);
+    void visit(KVPair const&);
+    void visit(MathConst const&);
+    void visit(MathOps const&);
+    void visit(MathType const&);
+    void visit(ObjectSpace const&);
+    void visit(Rvalue const&);
+    void visit(Statement const&);
+    void visit(StatementSeq const&);
+    void visit(StringExtNoArg const&);
+    void visit(Ternary const&);
+    void visit(Time const&);
+    void visit(VarRef const&);
+    template <class T>
+    void visit(google::protobuf::RepeatedPtrField<T> const& _repeated_field);
+
+    std::string removeSpecial(const std::string &x);
+
+    std::ostringstream m_output;
+    std::stack<uint8_t> m_numVarsPerScope;
+    int32_t m_numLiveVars;
+  };
+}

data/ext/enclave/mruby/src/allocf.c

@@ -0,0 +1,37 @@
+/*
+** allocf.c - default memory allocation function
+**
+** See Copyright Notice in mruby.h
+*/
+#include <stdlib.h>
+#include <mruby.h>
+
+/* This function serves as the default memory allocation function and accepts two arguments:
+ *
+ * - `p`: The previous pointer to the memory region. For memory allocation, this parameter is NULL.
+ * - `size`: The new size of the memory region to be returned. If size is 0, the memory region will be freed.
+ *
+ * All memory allocation from the inside of mruby uses this function.
+ *
+ * If you want to use your own memory allocator, you have two options:
+ *
+ *  - provide your own version of malloc() / realloc() / free()
+ *
+ *  - redefine mrb_basic_alloc_func() in your application.
+ *
+ * See doc/guides/memory.md for detail.
+ */
+
+void*
+mrb_basic_alloc_func(void *p, size_t size)
+{
+  if (size == 0) {
+    /* `free(NULL)` should be no-op */
+    free(p);
+    return NULL;
+  }
+  else {
+    /* `realloc(NULL, size)` should work as `malloc(size)` */
+    return realloc(p, size);
+  }
+}