rlang 0.3.0

data/lib/builder/wat/builder.rb

@@ -0,0 +1,52 @@
+# Rubinius WebAssembly VM
+# Copyright (c) 2019, Laurent Julliard and contributors
+# All rights reserved.
+
+require_relative '../ext/tempfile'
+
+module Builder::Wat
+  class Builder
+
+    @@wat_compiler = 'wat2wasm'
+
+    attr_reader :target, :source
+
+    def initialize(source, target, include_paths = nil)
+      check_compiler
+      @source = source
+      @target = target
+      @include_paths = include_paths || ['.', File.expand_path('../../machine', source)]
+      if File.extname(source) == '.erb'
+        @wat_path = self.assemble
+      else
+        @wat_path = source
+      end
+    end
+
+    def check_compiler
+      raise "wat2wasm compiler not found. Make sure it is in your PATH" \
+        unless system("#{@@wat_compiler} --help >/dev/null")
+    end
+
+    def compile
+      @target ||= @wat_path.gsub(/\.wat$/,'.wasm')
+      %x{ #{@@wat_compiler} #{@wat_path} -o #{@target} }
+      @target
+    end
+
+    def cleanup
+      File.unlink(@wat_path) unless @wat_path == @source
+    end
+
+    # Create a tempfile with .wat extension from 
+    # an erb template
+    def assemble
+      renderer = Renderer.new(@include_paths)
+      tf = Tempfile.new([File.basename(@source), '.wat'])
+      tf.persist! # do not delete tempfile if inspection needed
+      tf.write(renderer.render(@source))
+      tf.close
+      tf.path
+    end
+  end
+end

data/lib/builder/wat/renderer.rb

@@ -0,0 +1,28 @@
+# Rubinius WebAssembly VM
+# Copyright (c) 2019, Laurent Julliard and contributors
+# All rights reserved.
+
+require 'pathname'
+require 'erb'
+
+module Builder
+  module Wat
+    class Renderer 
+      attr_reader :template_path, :binding_klass
+
+      def initialize(template_paths)
+        # an array of load path to consider for erb files
+        @template_paths = template_paths
+      end
+
+      def render(erb_file)
+        path = ''
+        unless Pathname.new(erb_file).absolute?
+          path = @template_paths.find { |tp| File.exist?(File.join(tp, erb_file)) } || ''
+        end
+        #puts "Rendering #{File.join(path, erb_file)}"
+        ERB.new(File.read(File.join(path, erb_file))).result(binding)
+      end
+    end
+  end
+end

data/lib/builder/wat.rb

@@ -0,0 +1,3 @@
+
+require_relative './wat/renderer'
+require_relative './wat/builder'

data/lib/builder.rb

@@ -0,0 +1,7 @@
+# Rubinius WebAssembly VM
+# Copyright (c) 2019, Laurent Julliard and contributors
+# All rights reserved.
+
+require_relative './builder/ext'
+require_relative './builder/wat'
+require_relative './builder/rlang'

data/lib/rlang/lib/malloc.c

@@ -0,0 +1,97 @@
+/* Rubinius WebAssembly VM
+ Copyright (c) 2019, Laurent Julliard and contributors
+ All rights reserved.
+
+ This file is provided for reference and as a point of
+ comparison with the Rlang implementation in malloc.rb
+*/
+
+#define NULL 0
+typedef long Align; /* for alignment to long boundary */
+union header {      /* block header */
+  struct
+  {
+    union header *ptr; /* next block if on free list */
+    unsigned size;     /* size of this block */
+  } s;
+  Align x; /* force alignment of blocks */
+};
+typedef union header Header;
+
+static Header base;          /* empty list to get started */
+static Header *freep = NULL; /* start of free list */
+
+/* malloc: general-purpose storage allocator */
+void *malloc(unsigned nbytes)
+{
+  Header *p, *prevp;
+  Header *morecore(unsigned);
+  unsigned nunits;
+  nunits = (nbytes + sizeof(Header) - 1) / sizeof(Header) + 1;
+  if ((prevp = freep) == NULL)
+  { /* no free list yet */
+    base.s.ptr = freep = prevp = &base;
+    base.s.size = 0;
+  }
+  for (p = prevp->s.ptr;; prevp = p, p = p->s.ptr)
+  {
+    if (p->s.size >= nunits)
+    {                          /* big enough */
+      if (p->s.size == nunits) /* exactly */
+        prevp->s.ptr = p->s.ptr;
+      else
+      { /* allocate tail end */
+        p->s.size -= nunits;
+        p += p->s.size;
+        p->s.size = nunits;
+      }
+      freep = prevp;
+      return (void *)(p + 1);
+    }
+    if (p == freep) /* wrapped around free list */
+      if ((p = morecore(nunits)) == NULL)
+        return NULL; /* none left */
+  }
+}
+
+#define NALLOC 1024 /* minimum #units to request */
+/* morecore: ask system for more memory */
+static Header *morecore(unsigned nu)
+{
+  char *cp, *sbrk(int);
+  Header *up;
+  if (nu < NALLOC)
+    nu = NALLOC;
+  cp = sbrk(nu * sizeof(Header));
+  if (cp == (char *)-1) /* no space at all */
+    return NULL;
+  up = (Header *)cp;
+  up->s.size = nu;
+  free((void *)(up + 1));
+  return freep;
+}
+
+/* free: put block ap in free list */
+void free(void *ap)
+{
+  Header *bp, *p;
+  bp = (Header *)ap - 1; /* point to block header */
+  for (p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
+    if (p >= p->s.ptr && (bp > p || bp < p->s.ptr))
+      break; /* freed block at start or end of arena */
+  if (bp + bp->s.size == p->s.ptr)
+  { /* join to upper nbr */
+    bp->s.size += p->s.ptr->s.size;
+    bp->s.ptr = p->s.ptr->s.ptr;
+  }
+  else
+    bp->s.ptr = p->s.ptr;
+  if (p + p->s.size == bp)
+  { /* join to lower nbr */
+    p->s.size += bp->s.size;
+    p->s.ptr = bp->s.ptr;
+  }
+  else
+    p->s.ptr = bp;
+  freep = p;
+}

data/lib/rlang/lib/malloc.rb

@@ -0,0 +1,169 @@
+# Rubinius WebAssembly VM
+# Copyright (c) 2019, Laurent Julliard and contributors
+# All rights reserved.
+#
+# This is a simple memory allocator derived
+# from K&R C Language 2nd Edition p 185-189
+#
+# For a detailed explanation of the allocator code see
+# https://gnuchops.wordpress.com/2013/02/26/memory-allocator-for-embedded-system-k-r-ritchie-book/
+
+require 'rlang/lib/memory'
+require 'rlang/lib/unistd'
+
+# These 3 global variables below are used by the
+# dynamic memory allocator. They must however be 
+# defined in the end applications.
+
+# Heap base address (make sure it's aligned on 
+# an address compatible with the most restrictive data type
+# used in WASM (I64). So make this address a multiple of 8
+# $HEAP = 10024
+
+# Maximum amount of memory the heap can grow
+# NOTE: must be less than the upper WASM memory limit (4GB)
+# $HEAP_MAX_SIZE = 1073741824  # 1GB
+
+# Current heap size (starts at 0, the first malloc will
+# set it up)
+# $HEAP_SIZE = 0
+
+# minimum number of units to request
+$NALLOC = 1024
+
+# Header structure at beginning of each allocated
+# memory block
+# (this structure is also called a unit and the memory
+# allocation will always happen on a boundary aligned
+# with the most restrictive type of WASM that is to say i64)
+# As the struct below is 8 byte long and i64 is too our
+# unit memory allocation size will be 8 bytes here.
+# 
+# struct {
+#   header *ptr;  /* next block if on free list */ => 4 bytes in WASM
+#   unsigned size /* size of this block */         => 4 bytes in WASM
+# } header;
+#
+
+# Allocate some unused memory space to make 
+# sure so that freep doesn't point to memory
+# address 0 because it has a sepcial meaning
+# Allocate 20 bytes (5 x I32 integers)
+DAta[:dummy_malloc_data] = [0, 0, 0, 0, 0]
+
+class Header
+  wattr :ptr, :size
+  wattr_type ptr: :Header, size: :I32
+end
+    
+class Malloc
+
+  @@base = Header.new          # empty list to get started
+  @@freep = 0.cast_to(:Header) # start of free list
+
+  # declare ahead of time because is used in
+  # the code before it is actually defined
+  result :Malloc, :free, :nil
+
+# -------- Dynamic Memory Allocator Functions -----------
+
+  # malloc: allocate n bytes of memory and return pointer
+  # to data block
+  def self.malloc(nbytes)
+    local p: :Header, prevp: :Header
+
+    # allocate memory by chunk of units (the unit is
+    # the size of a Header object here)
+    # units = (nbytes+sizeof(Header)-1)/sizeof(Header) + 1;
+    nunits = (nbytes + Header.size - 1) / Header.size + 1
+
+    # No free list yet. Initialize it.
+    if (prevp = @@freep) == 0 
+      @@base.ptr = @@freep = prevp = @@base
+      @@base.size = 0
+    end
+
+    # scan the free list for a big enough free block
+    # (first in list is taken)
+    p = prevp.ptr
+    while true
+      if (p.size >= nunits) # big enough
+        if (p.size == nunits) 
+          # exactly the requested size
+          prevp.ptr = p.ptr
+        else
+          # bigger free block found
+          # Allocate tail end
+          p.size -= nunits
+          p += p.size
+          p.size = nunits
+        end
+        @@freep = prevp
+        # TODO: we should actually cast to default WASM type
+        return (p + 1).cast_to(:I32)
+      end
+
+      # wrapped around free list
+      if p == @@freep
+        if (p = self.morecore(nunits)) == 0
+          return 0
+        end
+      end
+
+      prevp = p; p = p.ptr
+    end
+
+    # Rlang specific: remember that while construct 
+    # doesn't evaluate to a value so we must add an
+    # explicit return here.
+    # However we should **never** get there so return NULL
+    return 0
+  end
+  
+  # morecore: ask system for more memory
+  def self.morecore(nu)
+    result :Header
+    local up: :Header
+
+    nu = $NALLOC if nu < $NALLOC
+    cp = Unistd::sbrk(nu * Header.size)
+    return 0 if cp == -1 # no space at all
+
+    up = cp.cast_to(:Header)
+    up.size = nu
+    self.free((up + 1).to_I32)
+    return @@freep
+  end
+
+  # Free memory block
+  def self.free(ap)
+    result :none
+    local bp: :Header, p: :Header
+
+    bp = ap.cast_to(:Header) - 1 # point to block header
+    p = @@freep
+    while !(bp > p && bp < p.ptr)
+      # freed block at start or end of arena 
+      break if (p >= p.ptr && (bp > p || bp < p.ptr))
+      p = p.ptr
+    end
+
+    if (bp + bp.size == p.ptr)
+      # join to upper nbr
+      bp.size += p.ptr.size
+      bp.ptr = p.ptr.ptr
+    else
+      bp.ptr = p.ptr
+    end
+
+    if (p + p.size == bp)
+      # join to lower nbr
+      p.size += bp.size
+      p.ptr = bp.ptr
+    else
+      p.ptr = bp
+    end
+    @@freep = p
+  end
+
+end

data/lib/rlang/lib/memory.rb

@@ -0,0 +1,11 @@
+class Memory
+
+  def self.size
+    inline wat: '(memory.size)'
+  end
+
+  def self.grow(delta)
+    inline wat: '(memory.grow (local.get $delta))'
+  end
+  
+end

data/lib/rlang/lib/type/i32.rb

@@ -0,0 +1,7 @@
+# Rubinius WebAssembly VM
+# Copyright (c) 2019, Laurent Julliard and contributors
+# All rights reserved.
+#
+class I32
+  def self.size; 4; end
+end

data/lib/rlang/lib/type/i64.rb

@@ -0,0 +1,7 @@
+# Rubinius WebAssembly VM
+# Copyright (c) 2019, Laurent Julliard and contributors
+# All rights reserved.
+#
+class I64
+  def self.size; 8; end
+end

data/lib/rlang/lib/type.rb

@@ -0,0 +1,6 @@
+# Rubinius WebAssembly VM
+# Copyright (c) 2019, Laurent Julliard and contributors
+# All rights reserved.
+#
+require_relative './type/i32'
+require_relative './type/i64'

data/lib/rlang/lib/unistd.rb

@@ -0,0 +1,47 @@
+
+# Rubinius WebAssembly VM
+# Copyright (c) 2019, Laurent Julliard and contributors
+# All rights reserved.
+#
+# mimic the sbrk Unix function, requesting n more bytes
+# sbrk(n) returns the address of the allocated block or -1 if it failed
+# srbk(0) returns the current value of the break
+# Note: in WASM we can only grow linear memory by pages (64 KB block)
+class Unistd
+  def self.sbrk(n)
+    # local variables used. All default type
+    # wasm_mem_size:  current wasm memory size (in bytes)
+    # heap_break:     current heap break
+    #
+    # new_heap_size:  new heap size (HEAP_SIZE + n)
+    # new_heap_break: new heap break (HEAP + HEAP_SIZE + n)
+    # more_pages:     how many more WASM pages are needed
+
+    # return current break if n is 0
+    heap_break = $HEAP + $HEAP_SIZE
+    return heap_break if n == 0
+
+    # check if new heap size is beyond authorized limit
+    new_heap_size = $HEAP_SIZE + n
+    return -1 if new_heap_size >= $HEAP_MAX_SIZE
+
+    # We are good, so now check if we need more WASM 
+    # memory pages (1 page = 64 KB)
+    wasm_mem_size = Memory.size * 65536
+    new_heap_break = heap_break + n
+
+    # need to grow memory? if so by how many WASM pages ?
+    if new_heap_break >= wasm_mem_size
+      more_pages = (new_heap_break - wasm_mem_size) / 65536 + 1
+    end
+
+    # go grow WASM memory by so many pages. Return -1 if it fails
+    return -1 if Memory.grow(more_pages) == -1
+  
+    # set new heap size
+    $HEAP_SIZE = new_heap_size
+  
+    # heap_break is the address where the new free space starts
+    return heap_break
+  end
+end

data/lib/rlang/lib.rb

@@ -0,0 +1,10 @@
+# Rubinius WebAssembly VM
+# Copyright (c) 2019-2020, Laurent Julliard and contributors
+# All rights reserved.
+
+# Rlang standard library
+
+require_relative './lib/type'
+require_relative './lib/memory'
+require_relative './lib/unistd'
+require_relative './lib/malloc'

data/lib/rlang/parser/const.rb

@@ -0,0 +1,15 @@
+# Rubinius WebAssembly VM
+# Copyright (c) 2019, Laurent Julliard and contributors
+# All rights reserved.
+
+# Constant variables
+
+require_relative './ext/type'
+require_relative './cvar'
+
+# Constants and Class variables are managed
+# in exactly the same way
+module Rlang::Parser
+  class Const < CVar
+  end
+end

data/lib/rlang/parser/cvar.rb

@@ -0,0 +1,44 @@
+# Rubinius WebAssembly VM
+# Copyright (c) 2019, Laurent Julliard and contributors
+# All rights reserved.
+#
+# Class variables
+# Note: Const class inherits from this class
+
+require_relative '../../utils/log'
+require_relative './wtype'
+require_relative './data'
+
+module Rlang::Parser
+  class CVar
+    include Log
+    attr_reader :name, :class_name
+    attr_accessor :wtype
+
+    def initialize(class_name, name, value=0, wtype=WType::DEFAULT)
+      @name = name
+      @class_name = class_name
+      @wtype = wtype
+      # Allocate and initialize the new cvar
+      raise "Error: Class variable #{self.wasm_name} already created!" if DAta.exist? self.wasm_name.to_sym
+      @data = DAta.new(self.wasm_name.to_sym, value, wtype)
+      logger.debug "creating #{self.class} #{class_name}::#{name} @ #{@address} with value #{value} / wtype #{wtype}"
+    end
+
+    def address
+      @data.address
+    end
+
+    def value
+      @data.value
+    end
+
+    def wasm_name
+      "$#{@class_name}::#{@name}"
+    end
+
+    def wasm_type
+      @wtype.wasm_type
+    end
+  end
+end

data/lib/rlang/parser/data.rb

@@ -0,0 +1,105 @@
+require_relative '../../utils/log'
+require_relative './ext/string'
+require_relative './wtype'
+require_relative './ext/integer'
+
+
+# Don't use class name Data because it's a deprecated
+# Ruby class and it generates warning at runtime
+module Rlang::Parser
+  class DAta
+    include Log
+
+    TMPL = '(data 0 (i32.const %{addr}) "%{value}") ;; %{comment}'
+
+    @@label_table = {}
+    @@current_address = 0
+
+    attr_reader :label, :wtype, :address, :value
+
+    def initialize(label, value, wtype=WType::DEFAULT)
+      raise "Data label '#{label}' already initialized" \
+        if self.class.exist? label
+      @label = label
+      @wtype = wtype
+      @address = @@current_address
+      @@label_table[@label] = self
+      @value = []
+      self.append_value(value, wtype)
+      logger.debug "New Data[#{@label}] initialized with #{@value} at address #{@address}"
+    end
+
+    def append_value(value, wtype)
+      @value << value
+      if value.is_a?(String) 
+        @@current_address += value.length
+      else
+        logger.warn "Data type #{@wtype} misaligned!!! (Data[:#{@label}] value #{value} at address #{@address}" \
+          unless self.aligned?
+        @@current_address += @wtype.size
+      end
+    end
+
+    def aligned?
+      (@@current_address % @wtype.size) == 0
+    end
+
+    def self.exist?(label)
+      @@label_table.has_key? label
+    end
+
+    def self.[](label)
+      raise "Unknown data label '#{label}'" unless self.exist? label
+      @@label_table[label].address
+    end
+
+    def self.append(label, value, wtype=WType::DEFAULT)
+      logger.debug "appending #{value} to DAta[#{label}]"
+      if self.exist? label
+        @@label_table[label].append_value(value, wtype)
+      else
+        self.new(label, value, wtype)
+      end
+    end
+
+    def self.current_address=(address)
+      @@current_address = address
+    end
+
+    # Align current address to closest multiple of
+    # n by higher value
+    def self.align(n)
+      if (m = @@current_address % n) != 0
+        @@current_address = (@@current_address - m) + n
+      end
+      logger.debug "Aligning current address to #{@@current_address}"
+      @@current_address
+    end
+
+    # Transpile data to WAT code
+    # in order of increasing address
+    def self.transpile
+      output = []
+      @@label_table.sort_by {|s,d| d.address}.each do |s,d|
+        logger.debug "Generating data #{d.inspect}"
+        address = d.address
+        d.value.each do |elt|
+          if elt.is_a? String
+            output << TMPL % {addr: address, value: elt.to_wasm, comment: s}
+            address += d.value.size
+          elsif elt.is_a? Integer
+            output << TMPL % {addr: address, value: elt.to_little_endian(d.wtype.size), comment: "(#{elt} #{s})"}
+            address += d.wtype.size
+          elsif elt.is_a? DAta
+            output << TMPL % {addr: address, value: elt.address.to_little_endian(d.wtype.size), comment: "(#{elt} #{s})"}
+            address += d.wtype.size
+          else
+            raise "Unknown Data type: #{value.class}"
+          end
+        end
+      end
+      output.join("\n")
+    end
+  end
+
+end

data/lib/rlang/parser/export.rb

@@ -0,0 +1,22 @@
+require_relative './ext/type'
+
+module Rlang::Parser
+  class Export
+    @@exports = []
+    attr_reader :object
+    
+    # Object can be either a method object or a global object
+    def initialize(object)
+      @object = object
+      @@exports << self
+    end
+
+    # Export Rlang funcs, etc... grouping them
+    # by object type for Wasm code readability
+    def self.transpile
+      @@exports.sort_by {|e| e.object.class.to_s}.collect do |export|
+        export.object.export_wasm_code
+      end.join("\n")
+    end
+  end
+end

data/lib/rlang/parser/ext/integer.rb

@@ -0,0 +1,5 @@
+class Integer
+  def to_little_endian(byte_count)
+    ("%0#{byte_count*2}X" % self).scan(/../).reverse.map {|byte| "\\#{byte}"}.join('')
+  end
+end

data/lib/rlang/parser/ext/string.rb

@@ -0,0 +1,5 @@
+class String
+  def to_wasm
+    self.split('').map {|c| (32..126).include?(c.ord) ? c : "\\#{'%02X' % c.ord}"}.join('')
+  end
+end