ragweed 0.2.0-java

data/lib/ragweed/ptr.rb

@@ -0,0 +1,48 @@
+# TODO: make read/write work for other oses
+
+class Ragweed::Ptr
+  # A dubious achievement. Wrap Integers in a pointer class, which,
+  # when you call to_s, returns the marshalled type, and which exports
+  # read/write methods.
+  attr_accessor :p
+  attr_reader :val
+
+  # ptr-to-zero?
+  def null?
+    @val == 0
+  end
+
+  # initialize with a number or another pointer (implements copy-ctor)
+  def initialize(i)
+    if i.kind_of? self.class
+      @val = i.val
+      @p = i.p
+    elsif not i
+      @val = 0
+    else
+      @val = i
+    end
+  end
+
+  # return the raw pointer bits
+  def to_s; @val.to_l32; end
+
+  # return the underlying number
+  def to_i; @val; end
+
+  # only works if you attach a process 
+  def write(arg); p.write(self, arg); end
+  def read(sz); p.read(self, sz); end
+
+  # everything else: work like an integer --- also, where these
+  # calls return numbers, turn them back into pointers, so pointer
+  # math doesn't shed the class wrapper
+  def method_missing(meth, *args) 
+    ret = @val.send meth, *args
+    if ret.kind_of? Numeric
+      ret = Ragweed::Ptr.new(ret)
+      ret.p = self.p
+    end
+    ret
+  end
+end

data/lib/ragweed/rasm/bblock.rb

@@ -0,0 +1,73 @@
+module Ragweed; end
+module Ragweed::Rasm
+  # Ruby inline assembler.
+  class Bblock
+    # Don't call this directly; use Bblock#make
+    def initialize
+      @insns = Ragweed::Rasm::Subprogram.new
+    end
+
+    # Wrap the methods of Rasm::Subprogram we care about:
+
+    # Assemble the instructions, which also calculates appropriate
+    # jump labels.
+    def assemble; @insns.assemble; end
+
+    # Disassemble the block (after it's been assembled) into
+    # Frasm objects.
+    def disassemble; @insns.disassemble; end
+
+    # Generate a human-readable assembly listing.
+    def listing; @insns.dump_disassembly; end
+
+    # Append more instructions to a previously created block;
+    # see Bblock#make
+    def append(&block)
+      instance_eval(&block)
+    end
+
+    # Takes a block argument, containing (mostly) assembly
+    # instructions, as interpreted by Rasm. For example:
+    #
+    #     Bblock.make {
+    #         push ebp
+    #         mov  ebp, esp
+    #         push ebx
+    #         xor ebx, ebx
+    #         addl esp, 4
+    #         pop ebp
+    #         ret
+    #     }
+    #
+    # Each of those instructions is in fact the name of a class
+    # in Rasm, lowercased; Bblock has a method_missing that catches
+    # and instantiates them.
+    #
+    # Your block can contain arbitrary Ruby, but remember that it
+    # runs in the scope of an anonymous class and so cannot directly
+    # reference instance variables.
+    def self.make(&block)
+      c = Bblock.new
+      c.instance_eval(&block)
+      c
+    end
+
+    # method to fix collision with Kernel#sub properly
+    def sub(*args)
+      Ragweed::Rasm::Sub.new(*args)
+    end
+
+    def method_missing(meth, *args)
+      k = Ragweed::Rasm.const_get(meth.to_s.capitalize)
+
+      # If it's a class, it's an assembly opcode; otherwise,
+      # it's a register or operand.
+      if k.class == Class
+        @insns << (k = k.new(*args))
+      else
+        k
+      end
+      k
+    end
+  end
+end