undll32 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 79d24bcf938e3a23a7e87f932a6189c7248b690a1fc5766e7907cf056b0967e6
-  data.tar.gz: 29faa69356a53024534261b815fa3f7c3bfd5d01f429877fe5c6f1f5da273572
+  metadata.gz: dc86272423576ea01bf2666535b63302cfabd49e12b672c168d49b84fadaa814
+  data.tar.gz: 1f92550e71c6429d1fdd4ce75fffd759888fddd1a9f127c93424605fd38de2ce
 SHA512:
-  metadata.gz: f336b0b7936b6e1dd2d744126263e00869a68500e8346ce971393f8dfbc7520d4068b70cc7c3c3cc3187a5ae809b9b934f2a6c56724fcf6919284ae046736230
-  data.tar.gz: 490a671e93edc615934ae0372731aebec5d6978c54d2e4ffba85cfd978ab7f5ccf562e42d0ac9c44b15aada37e34c24bf6ec9c455039266de5f58f19d9956c82
+  metadata.gz: 4a9bc8bbbd5a4e597ce2847892552b4dc3a7b149aac05658bf0d68c9270e4d151a6af4f6557a314682ae90c5c9d11fa07b013dc067b0b8bb9b5ddc03d9192c02
+  data.tar.gz: '0692dddf565e76242e9c4bcb5e18d6f4bac407fe9bfb33ac1565e8fe9dfb87de6fb707cd7621f5695feae8eb24998d9e7205ae77235b41cc75c265feb8b91d0e'

data/lib/undll32.rb

@@ -15,6 +15,8 @@ module Undll32
   # buffer.buffer => "\0\0\0\0"
   # buffer.unpack => 0
   class Buffer
+    attr_accessor :struct
+
     def initialize struct
       case struct
       when Hash, Array, Symbol, Integer
@@ -33,22 +35,63 @@ module Undll32
       _unpack @struct
     end
 
-    def _unpack x
+    def load v
+      @_i = 0
+      _load @struct, v
+      unpack
+    end
+
+    def _load x, v
       case x
       when Integer
-        buffer[(@_i += x) - x, x].sub(/\0+$/, '')
+        return @_i += x if v.nil?
+        unless String === v
+          raise ArgumentError, "expected str, got #{v}"
+        end
+        x = [x, v.length].min
+        buffer[(@_i += x) - x, x] = v[0, x]
       when Symbol
         n = { C: 1, S: 2, L: 4, Q: 8 }[x]
         if n.nil?
           raise ArgumentError, "expected CSLQ, got #{x}"
         end
+        return @_i += n if v.nil?
+        unless Integer === v
+          raise ArgumentError, "expected int, got #{v}"
+        end
+        buffer[(@_i += n) - n, n] = [v].pack("#{x}")
+      when Array
+        return x.each { |a| _load a, nil } if v.nil?
+        unless Array === v and v.size == x.size
+          raise ArgumentError, "expected array[#{x.size}], got #{v}"
+        end
+        x.zip(v) { |a, b| _load a, b }
+      when Hash
+        return x.each { |k, y| _load y, nil } if v.nil?
+        unless Hash === v
+          raise ArgumentError, "expected hash, got #{v}"
+        end
+        x.each { |k, y| _load y, v[k] }
+      else
+        raise ArgumentError, "expected hash, array, sym, int, got #{x}"
+      end
+    ensure
+      $@.shift if $@
+    end
+
+    def _unpack x
+      case x
+      when Integer
+        buffer[(@_i += x) - x, x].sub(/\0+$/, '')
+      when Symbol
+        n = { C: 1, S: 2, L: 4, Q: 8 }[x]
         buffer[(@_i += n) - n, n].unpack1("#{x}")
       when Array
         x.map { |e| _unpack e }
       when Hash
         Hash[x.map { |k, v| [k, _unpack(v)] }]
       else
-        raise ArgumentError, "expected hash, array, sym, int, got #{struct}"
+        raise ArgumentError, "expected hash, array, sym, int, got #{x}"
       end
     ensure
       $@.shift if $@
@@ -69,50 +112,132 @@ module Undll32
       when Hash
         _buffer x.values
       else
-        raise ArgumentError, "expected hash, array, sym, int, got #{struct}"
+        raise ArgumentError, "expected hash, array, sym, int, got #{x}"
       end
     ensure
       $@.shift if $@
     end
+
+    def self.from_array code
+      unless code =~ /^\[[CSLQ]+\]$/
+        raise ArgumentError, "expected [CSLQ], got #{code}"
+      end
+      return new(code[1..-2].chars.map(&:to_sym))
+    end
+
+    def self.from_size code
+      m = code.match(/^\:(?<size>[^=]+)=?(?<value>.+)?$/)
+      if m.nil?
+        raise ArgumentError, "expected <number> or CSLQ, got #{code}"
+      end
+      if m[:size] =~ /^[CSLQ]+$/
+        s = m[:size].chars.map(&:to_sym)
+        if s.size == 1
+          return new(s[0]).tap { |b| b.load(m[:value].to_i) if m[:value] }
+        else
+          b = new(s)
+          b.load(m[:value].split(':').map(&:to_i)) if m[:value]
+          return b
+        end
+      end
+      if (n = m[:size].to_i)
+        return new(n).tap { |b| b.load(m[:value]) if m[:value] }
+      end
+      raise ArgumentError, "expected <number> or CSLQ, got #{code}"
+    end
+
+    def self.next_placeholder
+      @_placeholder_counter ||= 0
+      "__#{@_placeholder_counter += 1}__"
+    end
+
+    def self.from_struct code
+      default = {}
+      # code := '{' [name] [:type] [=value] [,...] '}'
+      env, keys, key = [], [], ''
+      seq = code.scan /\w+|\:[[:digit:]]+|\:[CSLQ:]+|=[^,\}]+|./
+      ret = while (token = seq.shift)
+        case token[0]
+        when '{'
+          keys.push(key.to_sym) unless key.empty?
+          env.push({})
+          key = ''
+        when '}'
+          env[-1][key.to_sym] = :L unless key.empty?
+          x = env.pop
+          break x if env.empty?
+          env[-1][keys.pop] = x
+          key = ''
+        when ':'
+          token << seq.shift if seq.first&.start_with?('=')
+          b = from_size(token)
+          key = next_placeholder if key.empty?
+          env[-1][key.to_sym] = b.struct
+          d = default
+          keys.each { |k| d[k] ||= {}; d = d[k] }
+          d[key.to_sym] = b.unpack
+          key = ''
+        when '='
+          e = token[1..-1]
+          e = Integer(e) rescue nil
+          type = Integer === e ? :L : (e.length + 1)
+          env[-1][key.to_sym] = type
+          d = default
+          keys.each { |k| d[k] ||= {}; d = d[k] }
+          if Integer === type
+            e = "\"#{e}\"".undump rescue e.undump
+          end
+          d[key.to_sym] = e
+          key = ''
+        when ','
+          next if key.empty?
+          env[-1][key.to_sym] = :L
+          key = ''
+        else
+          key << token
+        end
+      end
+      if ret.nil?
+        raise ArgumentError, 'expected }, got end-of-input'
+      end
+      new(ret).tap { |b| b.load(default) }
+    end
+
+    def self.from code
+      return from_array(code) if code.start_with?('[')
+      return from_size(code) if code.start_with?(':')
+      code = "{#{code}}" unless code.start_with?('{')
+      return from_struct(code)
+    end
   end
 
   # Undll32.run 'user32', 'MessageBox', 0, 'hello', 'world', 0
+  # Undll32.run 'user32', 'GetCursorPos', Buffer.new({:x => :L, :y => :L})
+  # Undll32.run 'user32', 'GetCursorPos', Buffer.from('x,y')
   def self.run(dll, func, *args)
     types = args.map { |e| Integer === e ? 'L' : 'p' }
     input = args.map { |e| Buffer === e ? e.buffer : e }
     Win32API.new(dll, func, types, 'i').call(*input)
   end
 
-  def self.parse xs
-    case x = xs.shift
-    when ':' then Buffer.new xs.shift.to_i
-    when '[' then Buffer.new xs.shift.chars.map(&:to_sym)
-    when '{'
-      x = Hash[xs.each_slice(4).map { |k, _, v, _| [k.to_sym, v.to_sym] }]
-      Buffer.new x
-    else
-      raise ArgumentError, "expected : [ {, got #{x}"
-    end
-  end
-
   def self.exe(argv=ARGV)
     return help if ARGV.include? '-h' or ARGV.include? '--help'
     dllfunc, *args = argv
     return help if dllfunc.nil?
     dll, func = dllfunc.split(',')
     return help if func.nil?
-    args.map! { |e|
+    args.map! do |e|
       e = e.dup
       if e.start_with?('+')
         e.slice!(0)
         next e if e.start_with?('+')
-        parse e.scan(/\w+|./)
+        Buffer.from(e)
       else
         n = Integer(e) rescue nil
         next n if n
         e
       end
-    }
+    end
     ret = run(dll, func, *args)
     args.each { |e| pp e.unpack if Buffer === e }
     ret
@@ -126,10 +251,10 @@ module Undll32
     EXAMPLE
       undll32 user32,MessageBox 0 hello world 0
       undll32 user32,GetCursorPos +[LL]
-      undll32 user32,GetCursorPos +{x:L,y:L}
+      undll32 user32,GetCursorPos +x,y
       undll32 user32,GetCursorPos +:8 # will be converted to string
 
-    EXPLAIN
+    ARGUMENTS
       0   => (Integer) 0
       str => 'str'
       +0  => '0'
@@ -138,6 +263,9 @@ module Undll32
       +{x:L,y:L} => Buffer.new({:x => :L, :y => :L})
       +:256      => Buffer.new(256)
 
+    VERSION
+      #{VERSION}
+
     USAGE
   end
 end

data/lib/undll32/version.rb

@@ -1,3 +1,3 @@
 module Undll32
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: undll32
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - hyrious
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-12-01 00:00:00.000000000 Z
+date: 2018-12-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler