wag 0.1.0

data/lib/wag/instructions/memory/grow.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module WAG
+  module Instruction
+    module Memory
+      class Grow < Base.instruction(0x40)
+        prepend WAG::Instructable
+      end
+    end
+  end
+end

data/lib/wag/instructions/memory/size.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module WAG
+  module Instruction
+    module Memory
+      class Size < Base.instruction(0x3f)
+        prepend WAG::Instructable
+      end
+    end
+  end
+end

data/lib/wag/instructions/nop.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module WAG
+  module Instruction
+    class Nop < Base.instruction(0x01)
+    end
+  end
+end

data/lib/wag/instructions/return.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module WAG
+  module Instruction
+    class Return < Base.instruction(0x0f)
+      prepend WAG::Instructable
+    end
+  end
+end

data/lib/wag/instructions/select.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module WAG
+  module Instruction
+    class Select < Base.instruction(0x1b)
+      prepend WAG::Instructable
+    end
+  end
+end

data/lib/wag/instructions/unreachable.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module WAG
+  module Instruction
+    class Unreachable < Base.instruction(0x00)
+    end
+  end
+end

data/lib/wag/label.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module WAG
+  class Label
+    include WAG::Encodable
+
+    attr_reader :value
+
+    def initialize(value)
+      if value.is_a?(Integer)
+        @value = value.to_i
+      else
+        value = value.to_s
+        @value = if value.start_with?('$')
+                   value.to_sym
+                 else
+                   "$#{value}".to_sym
+                 end
+      end
+    end
+
+    def to_sexpr
+      value
+    end
+
+    def self.from(value)
+      return value if value.is_a?(WAG::Label)
+
+      WAG::Label.new(value)
+    end
+  end
+end

data/lib/wag/local.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module WAG
+  # Local is not an instruction, but a nested keyword.
+  class Local
+    include WAG::Encodable
+
+    attr_reader :label, :type
+
+    def initialize(label, type)
+      @label = WAG::Label.from(label)
+      @type = WAG::Type.from(type)
+    end
+
+    def to_sexpr
+      [:local, label.to_sexpr, type.to_sexpr]
+    end
+  end
+end

data/lib/wag/local_instructions.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module WAG
+  class LocalInstructions
+    def initialize(instructions)
+      @instructions = instructions
+    end
+
+    %i[get set tee].each do |instruction_name|
+      camelised_name = "Local::#{WAG::Inflector.inflector.camelize(instruction_name)}"
+      define_method(instruction_name) do |*args, &block|
+        instruction = WAG::Instruction.const_get(camelised_name).new(*args)
+        @instructions << instruction
+        instruction.instance_exec(&block) if block
+        instruction
+      end
+    end
+  end
+end

data/lib/wag/memory.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module WAG
+  class Memory
+    include WAG::Encodable
+
+    attr_reader :label, :number, :min, :max
+
+    def initialize(*args)
+      @label = WAG::Label.from(args.shift) if args.first.is_a?(Symbol)
+
+      (@number, @min, @max) = args
+    end
+
+    def to_sexpr
+      [:memory].tap do |expr|
+        expr.push(label.to_sexpr) if label
+        expr.push(number)
+        if min
+          expr.push(min)
+          expr.push(max) if max
+        end
+      end
+    end
+  end
+end

data/lib/wag/memory_instructions.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module WAG
+  class MemoryInstructions
+    def initialize(instructions)
+      @instructions = instructions
+    end
+
+    %i[size grow].each do |instruction_name|
+      camelised_name = "Memory::#{WAG::Inflector.inflector.camelize(instruction_name)}"
+      define_method(instruction_name) do |*args, &block|
+        instruction = WAG::Instruction.const_get(camelised_name).new(*args)
+        @instructions << instruction
+        instruction.instance_exec(&block) if block
+        instruction
+      end
+    end
+  end
+end

data/lib/wag/module.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module WAG
+  class Module
+    include WAG::Encodable
+
+    def initialize
+      @data = []
+      @elements = []
+      @exports = []
+      @functions = []
+      @globals = []
+      @imports = []
+      @memories = []
+      @tables = []
+      @types = []
+    end
+
+    def build(&block)
+      instance_exec(&block)
+      self
+    end
+
+    def import(module_name, name, &block)
+      import = Import.new(module_name, name)
+      @imports << import
+      import.instance_exec(&block) if block
+      import
+    end
+
+    def export(name, &block)
+      export = Export.new(name)
+      @exports << export
+      export.instance_exec(&block) if block
+      export
+    end
+
+    def memory(number, min = nil, max = nil, &block)
+      mem = Memory.new(number, min, max)
+      @memories << mem
+      mem.instance_exec(&block) if block
+      mem
+    end
+
+    def global(label, type, &block)
+      global = Global.new(label, type)
+      @globals << global
+      global.instance_exec(&block) if block
+      global
+    end
+
+    def type(label, &block)
+      type = FunctionType.new(label)
+      @types << type
+      type.instance_exec(&block) if block
+      type
+    end
+
+    def elem(table_id, *labels, &block)
+      elem = Element.new(table_id, *labels)
+      @elements << elem
+      elem.instance_exec(&block) if block
+      elem
+    end
+
+    def data(offset, value)
+      data = Data.new(offset, value)
+      @data << data
+      data
+    end
+
+    def func(label = nil, &block)
+      func = Function.new(label)
+      @functions << func
+      func.instance_exec(&block) if block
+      func
+    end
+
+    def table(elements, type = :anyfunc, &block)
+      table = Table.new(elements, type)
+      @tables << table
+      table.instance_exec(&block) if block
+      table
+    end
+
+    def to_sexpr # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      mod = [:module]
+      mod.concat(@imports.map(&:to_sexpr))
+      mod.concat(@exports.map(&:to_sexpr))
+      mod.concat(@memories.map(&:to_sexpr))
+      mod.concat(@globals.map(&:to_sexpr))
+      mod.concat(@types.map(&:to_sexpr))
+      mod.concat(@tables.map(&:to_sexpr))
+      mod.concat(@elements.map(&:to_sexpr))
+      mod.concat(@data.map(&:to_sexpr))
+      mod.concat(@functions.map(&:to_sexpr))
+      mod
+    end
+  end
+end

data/lib/wag/param.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module WAG
+  class Param
+    include WAG::Encodable
+
+    attr_reader :type, :label
+
+    def initialize(type, label = nil)
+      @type = WAG::Type.from(type)
+      @label = WAG::Label.from(label) if label
+    end
+
+    def to_sexpr
+      return [:param, label.to_sexpr, type.to_sexpr] if label
+
+      [:param, type.to_sexpr]
+    end
+  end
+end

data/lib/wag/result.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module WAG
+  class Result
+    include WAG::Encodable
+
+    attr_reader :types
+
+    def initialize(*types)
+      @types = types.map { |t| WAG::Type.from(t) }
+    end
+
+    def to_sexpr
+      [:result].concat(types.map(&:to_sexpr))
+    end
+  end
+end

data/lib/wag/table.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module WAG
+  class Table
+    include WAG::Encodable
+    attr_reader :elements, :type
+
+    def initialize(elements, type = :anyfunc)
+      @elements = elements
+      @type = type
+    end
+
+    def to_sexpr
+      [:table, elements, type]
+    end
+  end
+end

data/lib/wag/then.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module WAG
+  # Then is not an instruction, but a nested keyword.
+  class Then
+    include WAG::Encodable
+    prepend WAG::Instructable
+
+    def to_sexpr
+      :then
+    end
+  end
+end

data/lib/wag/type.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module WAG
+  module Type
+    require 'wag/types/base'
+    require 'wag/types/f32'
+    require 'wag/types/f64'
+    require 'wag/types/i32'
+    require 'wag/types/i64'
+
+    module_function
+
+    def from(type)
+      return type if type.is_a?(WAG::Type::Base)
+
+      const_get(WAG::Inflector.inflector.camelize(type.to_s)).new
+    end
+  end
+end

data/lib/wag/types/base.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module WAG
+  module Type
+    class Base
+      def to_sexpr
+        name = WAG::Inflector.inflector.demodulize(self.class.name.to_s)
+        WAG::Inflector.inflector.underscore(name).to_sym
+      end
+
+      def value?
+        true
+      end
+    end
+  end
+end

data/lib/wag/types/f32.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module WAG
+  module Type
+    class F32 < Base
+    end
+  end
+end

data/lib/wag/types/f64.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module WAG
+  module Type
+    class F64 < Base
+    end
+  end
+end

data/lib/wag/types/i32.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module WAG
+  module Type
+    class I32 < Base
+    end
+  end
+end

data/lib/wag/types/i64.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module WAG
+  module Type
+    class I64 < Base
+    end
+  end
+end