wag 0.1.0

data/lib/wag/data.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module WAG
+  class Data
+    include WAG::Encodable
+
+    attr_reader :offset, :value
+
+    def initialize(offset, value)
+      @offset = offset.to_i
+      @value = value
+    end
+
+    def to_sexpr
+      [:data, [:"i32.const", offset], value]
+    end
+  end
+end

data/lib/wag/element.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module WAG
+  class Element
+    include WAG::Encodable
+
+    attr_reader :table_id, :labels
+
+    def initialize(table_id, *labels)
+      @table_id = table_id.to_i
+      @labels = labels.map { |l| WAG::Label.from(l) }
+    end
+
+    def to_sexpr
+      [:elem, [:"i32.const", table_id]].concat(labels.map(&:to_sexpr))
+    end
+  end
+end

data/lib/wag/encodable.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module WAG
+  # A simple mixin which formats s-expressions as WAT.
+  module Encodable
+    def to_wat
+      WAG::WAT.new(wat_encode(to_sexpr))
+    end
+
+    def to_wasm
+      to_wat.to_wasm
+    end
+
+    private
+
+    def wat_encode(data)
+      return "(#{data.map { |e| wat_encode(e) }.join(' ')})" if data.is_a?(Enumerable)
+      return data.inspect if data.is_a?(String)
+
+      data.to_s
+    end
+  end
+end

data/lib/wag/export.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module WAG
+  class Export
+    include WAG::Encodable
+
+    attr_reader :name, :desc
+
+    def initialize(name)
+      @name = name
+    end
+
+    def func(label, &block)
+      @desc = Function.new(label)
+      @desc.instance_exec(&block) if block
+      @desc
+    end
+
+    def global(label, type)
+      @desc = Global.new(label, type)
+    end
+
+    def memory(number, min = nil, max = nil, &block)
+      @desc = Memory.new(number, min, max)
+      @desc.instance_exec(&block) if block
+      @desc
+    end
+
+    def table(number, type = :anyfunc, &block)
+      @desc = Table.new(number, type)
+      @desc.instance_exec(&block) if block
+      @desc
+    end
+
+    def to_sexpr
+      [:export, name, desc.to_sexpr]
+    end
+  end
+end

data/lib/wag/f32_instructions.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module WAG
+  class F32Instructions
+    def initialize(instructions)
+      @instructions = instructions
+    end
+
+    %i[load store const eq ne lt gt le ge abs neg ceil floor trunc nearest
+       sqrt add sub mul div min max copysign convert_i32_s convert_i32_u
+       convert_i64_s convert_i64_u reinterpret_i32].each do |instruction_name|
+      camelised_name = "F32#{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/f64_instructions.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module WAG
+  class F64Instructions
+    def initialize(instructions)
+      @instructions = instructions
+    end
+
+    %i[load store const eq ne lt gt le ge abs neg ceil floor trunc nearest sqrt
+       add sub mul div min max copysign convert_i32_s convert_i32_u
+       convert_i64_s convert_i64_u promote_f32 reinterpret_i64].each do |instruction_name|
+      camelised_name = "F64#{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/function.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module WAG
+  class Function
+    include WAG::Encodable
+    prepend WAG::Instructable
+
+    attr_reader :label, :params
+
+    def initialize(label = nil)
+      @label = WAG::Label.from(label) if label
+      @params = []
+    end
+
+    def param(label = nil, type)
+      @params.push(WAG::Param.new(type, label))
+    end
+
+    def result(*types)
+      return @result if types.empty?
+
+      @result = WAG::Result.new(*types)
+    end
+
+    def to_sexpr
+      [:func].tap do |func|
+        func.push(@label.to_sexpr) if @label
+        func.concat(@params.map(&:to_sexpr)) unless @params.empty?
+        func.push(@result.to_sexpr) if @result
+      end
+    end
+  end
+end

data/lib/wag/function_type.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module WAG
+  class FunctionType < Function
+    def to_sexpr
+      [:type].tap do |type|
+        type.push(@label.to_sexpr) if @label
+        [:func].tap do |func|
+          func.concat(@params.map(&:to_sexpr)) unless @params.empty?
+          func.push(@result.to_sexpr) if @result
+          type.push(func)
+        end
+      end
+    end
+  end
+end

data/lib/wag/global.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module WAG
+  class Global
+    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
+      [:global, label.to_sexpr, type.to_sexpr]
+    end
+  end
+end

data/lib/wag/global_instructions.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module WAG
+  class GlobalInstructions
+    def initialize(instructions)
+      @instructions = instructions
+    end
+
+    %i[get set].each do |instruction_name|
+      camelised_name = "Global::#{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/i32_instructions.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module WAG
+  class I32Instructions
+    def initialize(instructions)
+      @instructions = instructions
+    end
+
+    %i[load load8_s load8_u load16_s load16_u store store8 store16 const eqz eq
+       ne lt_s lt_u gt_s gt_u le_s le_u ge_s ge_u clz ctz popcnt add sub mul
+       div_s div_u rem_s rem_u and or xor shl shr_s shr_u rotl rotr trunc_f32_s
+       trunc_f32_u trunc_f64_s trunc_f64_u reinterpret_f32].each do |instruction_name|
+      camelised_name = "I32::#{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/i64_instructions.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module WAG
+  class I64Instructions
+    def initialize(instructions)
+      @instructions = instructions
+    end
+
+    %i[load load8_s load8_u load16_s load16_u load32_s load32_u store store8
+       store16 store32 const eqz eq ne lt_s lt_u gt_s gt_u le_s le_u ge_s ge_u
+       clz ctz popcnt add sub mul div_s div_u rem_s rem_u and or xor shl shr_s
+       shr_u rotl rotr extend_i32_s extend_i32_u trunc_f32_s trunc_f32_u
+       trunc_f64_s trunc_f64_u reinterpret_f64].each do |instruction_name|
+      camelised_name = "I64::#{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/import.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module WAG
+  class Import
+    include WAG::Encodable
+
+    attr_reader :module_name, :name, :desc
+
+    def initialize(module_name, name)
+      @module_name = module_name
+      @name = name
+    end
+
+    def func(label, &block)
+      @desc = Function.new(label)
+      @desc.instance_exec(&block) if block
+      @desc
+    end
+
+    def global(label, type, &block)
+      @desc = Global.new(label, type)
+      @desc.instance_exec(&block) if block
+      @desc
+    end
+
+    def memory(number, min = nil, max = nil, &block)
+      @desc = Memory.new(number, min, max)
+      @desc.instance_exec(&block) if block
+      @desc
+    end
+
+    def table(number, type = :anyfunc, &block)
+      @desc = Table.new(number, type)
+      @desc.instance_exec(&block) if block
+      @desc
+    end
+
+    def to_sexpr
+      [:import, module_name, name, desc.to_sexpr]
+    end
+  end
+end

data/lib/wag/indices.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module WAG
+  module Indices
+    require 'wag/indices/base'
+    require 'wag/indices/func'
+    require 'wag/indices/global'
+    require 'wag/indices/label'
+    require 'wag/indices/local'
+    require 'wag/indices/mem'
+    require 'wag/indices/table'
+    require 'wag/indices/type'
+  end
+end

data/lib/wag/indices/base.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module WAG
+  module Indices
+    class Base
+      RANGE = [0..0xFFFFFFFF].freeze
+      attr_reader :value
+
+      def initialize(value)
+        raise "Index 0x#{value.to_s(16)} does not fit in an i32" unless RANGE.cover?(value)
+
+        @value = value
+      end
+    end
+  end
+end

data/lib/wag/indices/func.rb

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

data/lib/wag/indices/global.rb

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

data/lib/wag/indices/label.rb

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

data/lib/wag/indices/local.rb

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

data/lib/wag/indices/mem.rb

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

data/lib/wag/indices/table.rb

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

data/lib/wag/indices/type.rb

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

data/lib/wag/inflector.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'dry-inflector'
+
+module WAG
+  module Inflector
+    module_function
+
+    def inflector
+      @inflector ||= Dry::Inflector.new
+    end
+  end
+end