resedit 1.5.1 → 1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c544c164c27a245f45cebe0ede011c1a8ebd19d2
-  data.tar.gz: a212b23cc05f16ec779469aecc74601b046ae468
+  metadata.gz: 5b4e01f23eab7befb55f58374b179252e580ba27
+  data.tar.gz: c70bea5859d5fcdb2c62379956034d641336d320
 SHA512:
-  metadata.gz: 85deaaad0d6928ceafda0bb8a6642b8af902f061870c1e8a0fc2ba33bf3e3c25c97c83ac38c2858534214f058f713b3e955bba3fa995eacf77abb4b9ea47ea42
-  data.tar.gz: a8c03dcca383eb79c3215009e4c3563e73cce82e05bd590946926b70ef3a56d57433e57ca51dbb4ea2fbf07596cad6106ccf6fadc66ed6fbd9cd2510db6815de
+  metadata.gz: bec413733f867fe85b74bfbb07f99bcb4be3b161f3a3539cf50ed5312e03365accff257b81a107308c1ad205e0c8eb7779f330bb62414e3c508af802ce64edab
+  data.tar.gz: f6ef54cd8d085aaf2821f3b7821ccdbaa4c15ac26a4cf38b734091f0095b6626a7333f673a1ccaa72bc49075fbec2d57839dd9588391a46fc25ea7dc2744b9a0

data/lib/resedit.rb

@@ -9,9 +9,13 @@ require 'resedit/text/huffman'
 require 'resedit/app/font_convert'
 require 'resedit/app/text_convert'
 require 'resedit/convert/bitconv'
+require 'resedit/convert/codepatch'
 require 'resedit/mz/mz'
+require 'resedit/classes/colorizer'
+require 'resedit/classes/hexwriter'
+require 'resedit/classes/changeable'
 
 
 module Resedit
-    VERSION = "1.5.1"
+    VERSION = "1.6"
 end

data/lib/resedit/app/app.rb

@@ -1,6 +1,6 @@
 require 'resedit/app/std_commands'
 require 'resedit/app/mz_command'
-require 'resedit/app/colorizer'
+require 'resedit/classes/colorizer'
 require 'logger'
 require 'readline'
 
@@ -34,7 +34,7 @@ module Resedit
                     @cmds[n] = c;
                 }
             }
-            @col = Colorizer.new(false)
+            @col = Colorizer.instance()
         end
 
 
@@ -83,7 +83,6 @@ module Resedit
             return nil if cmd.length()==0 || cmd[0][0]=='#'
             c = @cmds[cmd[0]]
             raise "Unknown command: #{cmd[0]}" if !c
-            res=[]
             prms = c.parseParams(cmd[1..-1])
             return c,prms
         end

data/lib/resedit/app/app_command.rb

@@ -67,8 +67,8 @@ module Resedit
                     pidx+=1
                 end
             end
-            @params.each{|p|
-                raise "Expected parameter #{p[:name]}" if res[p[:name]]==nil
+            @params.each{|pp|
+                raise "Expected parameter #{pp[:name]}" if res[pp[:name]]==nil
             }
             return res
         end

data/lib/resedit/app/mz_command.rb

@@ -1,4 +1,3 @@
-require 'resedit/app/app'
 require 'resedit/app/app_command'
 require 'resedit/mz/mz'
 require 'resedit/mz/mzenv'
@@ -15,14 +14,14 @@ module Resedit
             addParam('p3', "mz command parameter","")
             addParam('p4', "mz command parameter","")
             addParam('p5', "mz command parameter","")
-            addOption('help', 'h', nil, 'help on mz commands')
+            addOption('help', 'h', false, 'help on mz commands')
             @cmds = {
                 "help"=>[method(:help), "show help on mz commands", {"command" => "command to show help on"}],
                 "use"=>[method(:use), "select mz file", {"file" => "path to mz file"}],
                 "save"=>[method(:save), "save current file",{"filename" => "filename fir saving", "final"=>"don't save changes"}],
                 "close"=>[method(:close), "close file", {"file" => "path or id of file to close"}],
                 "print"=>[method(:info), "print info about mz objects", {"what" => "files/header/reloc/changes", "how" => "original/modified"}],
-                "append"=>[method(:append), "add bytes to current file", {"value" => "value", "type" => "value type", }],
+                "append"=>[method(:append), "add bytes to current file", {"value" => "value", "type" => "value type", "where" => "append offset. default: above ss:sp"}],
                 "replace"=>[method(:replace), "replace added bytes", {"value" => "value", "type"=>"value type"}],
                 "change"=>[method(:change), "change bytes at offset", {"ofs" => "data ofset", "value" => "value", "disp" => "code/file", "type"=>"value type"}],
                 "reloc"=>[method(:reloc), "add relocation", {"value" => "value"}],
@@ -94,7 +93,6 @@ module Resedit
 
 
         def use(params)
-            App::get().col.on = true
             mz = getfile(params['file'])
             if mz==nil
                 mz = MZ.new(params['file'])
@@ -113,7 +111,6 @@ module Resedit
             mz.close()
             mz = nil
             @cur = @files[0] if !@cur && @files.length > 0
-            App::get().col.on = false if @files.length == 0
             info()
         end
 

data/lib/resedit/app/std_commands.rb

@@ -1,5 +1,4 @@
 require 'resedit/app/app_command'
-require 'resedit'
 
 module Resedit
 

data/lib/resedit/classes/changeable.rb

@@ -0,0 +1,299 @@
+require 'resedit/classes/colorizer'
+require 'resedit/classes/hexwriter'
+require 'logger'
+
+module Resedit
+
+    class Changeable
+        HOW_CHANGED = 0
+        HOW_ORIGINAL = 1
+        COL_CHANGED = Colorizer::YELLOW
+        COL_ORIGINAL = Colorizer::PURPLE
+        LOG = Logger.new(STDOUT)
+
+        class Change
+
+            attr_accessor :buf, :sz, :n, :obuf, :nbuf
+
+            def initialize(obuf=nil, nbuf=nil)
+                @n = nil
+                @mode = HOW_CHANGED
+                _updbufs(obuf, nbuf)
+            end
+
+            def _updbufs(obuf=nil, nbuf=nil)
+                @obuf = obuf ? obuf : ''
+                @nbuf = nbuf
+                mode()
+            end
+
+            def mode(mode=nil)
+                @mode = mode if mode
+                @buf = (@mode == HOW_CHANGED && @nbuf) ? @nbuf : @obuf
+                @sz = @buf.length
+                @n.mode(mode) if @n && mode
+            end
+
+            def data(ofs, size)
+                return @n.data(ofs - @sz, size) if ofs > @sz
+                return @buf[ofs .. -1] + @n.data(0, size - @sz + ofs) if @sz < ofs+size
+                return @buf[ofs, size]
+            end
+
+            def all; return @buf + (@n ? @n.all() : '') end
+            def size; return @sz + (@n ? @n.size() : 0) end
+
+            def split(ofs, data, nu=false)
+                if ofs+(nu ? 0 : data.length) == @sz
+                    tail = @n
+                else
+                    ntail = @nbuf ? @nbuf[ofs + (nu ? 0 : data.length) .. -1] : nil
+                    tail = Change.new(@obuf[ofs + (nu ? 0 : data.length) .. -1], ntail)
+                    tail.n = @n
+                end
+                if ofs != 0
+                    body = Change.new(nu ? nil : @obuf[ofs, data.length], data)
+                    body.n = tail
+                    _updbufs(@buf[0, ofs], @nbuf ? @nbuf[0, ofs] : nil)
+                    @n = body
+                else
+                    _updbufs(nu ? nil : @obuf[0, data.length], data)
+                    @n = tail
+                end
+                mode(@mode)
+            end
+
+            def insert(ofs, data)
+                return @sz + @n.insert(ofs - @sz, data) if ofs > @sz
+                LOG.debug("inserting #{data} @#{ofs} of #{@buf} #{@sz}")
+                if @nbuf
+                    @nbuf = @nbuf[0, ofs] + data + @nbuf[ofs..-1]
+                    mode()
+                    return ofs
+                end
+                split(ofs, data, true)
+                mode()
+                return ofs
+            end
+
+            def change(ofs, data)
+                return @sz + @n.change(ofs - @sz, data) if ofs > @sz
+                nxt = data.length - @sz + ofs
+                size = nxt>0 ? data.length-nxt : data.length
+                @n.change(0, data[size..-1]) if nxt > 0
+                if @nbuf
+                    @nbuf = @nbuf[0,ofs] + data[0, size] + @nbuf[ofs+size..-1]
+                    mode()
+                    return ofs
+                end
+                split(ofs, data[0, size])
+                mode()
+                return ofs
+            end
+
+            def undo(ofs)
+                LOG.debug("undo #{ofs} #{@buf}")
+                return @n.undo(ofs - @sz) if ofs >= @sz
+                raise "Change not found @#{ofs}" if ofs != 0 || !@nbuf
+                @nbuf = nil
+                mode()
+            end
+
+            def revert
+                @nbuf = nil
+                mode()
+                @n.revert if @n
+            end
+
+            def changed?(ofs, size)
+                return @n.changed?(ofs - @sz, size) if ofs >= @sz
+                return true if @nbuf
+                return @n.changed?(0, size - @sz + ofs) if @sz < ofs+size
+                return false
+            end
+
+            def hex(writer, ofs, size, col)
+                if ofs > @sz
+                    return size if !n
+                    return n.hex(writer, ofs - @sz, size, col)
+                end
+                sz = @sz < ofs+size ? @sz-ofs : size
+                writer.addBytes(@buf[ofs, sz], @nbuf ? col : nil)
+                return 0 if sz==size
+                return n.hex(writer, 0, size-sz, col) if n
+                return size-sz
+            end
+
+            def getChanges(ofs=0)
+                ch = {}
+                if @nbuf
+                    ch[ofs] = [@obuf, @nbuf]
+                end
+                ch = ch.merge(@n.getChanges(ofs+@sz)) if @n
+                return ch
+            end
+
+            def normalize()
+                while @n && !@nbuf && @obuf.length==0
+                    @obuf = @n.obuf
+                    @nbuf = @n.nbuf
+                    @n = @n.n
+                end
+                @n=@n.n while @n && !@n.nbuf && @n.obuf.length==0
+                while @n &&
+                        ((@obuf.length>0 && @n.obuf.length>0) || (@obuf.length == 0 && @n.obuf.length==0)) &&
+                        ((@nbuf && @n.nbuf) || (!@nbuf && !@n.nbuf))
+                    @obuf += @n.obuf
+                    @nbuf = @nbuf ? @nbuf+@n.nbuf : nil
+                    @n=@n.n
+                end
+                mode()
+                @n.normalize() if @n
+            end
+
+            def dump()
+                printf("#{@sz}:O(#{@obuf.length})\t\t%s\n", @nbuf ? "N(#{@nbuf.length if @nbuf})" : "")
+                @n.dump() if @n
+            end
+
+            def cload(ofs, bytes, len)
+                LOG.debug("load #{ofs} #{bytes} #{len}")
+                return @n.cload(ofs - @sz, bytes, len) if ofs > @sz
+                change(ofs, bytes.length>0 ? bytes : '*'*len)
+                nd = ofs==0 ? self : @n
+                nd.nbuf = nd.obuf
+                nd.obuf = bytes
+            end
+        end
+
+        # Changeable
+
+        def initialize(fileOrBytes, fileSize=nil)
+            LOG.level = Logger::INFO
+            @col = Colorizer.instance()
+            @mode = HOW_CHANGED
+            @root = nil
+            addData(fileOrBytes, fileSize)
+        end
+
+        def addData(fileOrBytes, size=nil)
+            if fileOrBytes.is_a?(IO)
+                data = fileOrBytes.read(size)
+            else
+                data = fileOrBytes
+            end
+            data = @root.buf + data if @root
+            @root = Change.new(data)
+        end
+
+
+        def mode(how)
+            @root.mode(how)
+            @mode = how
+        end
+
+        def insert(offset, data)
+            return if !data || !data.length
+            @root.insert(offset, data)
+            @root.normalize()
+        end
+
+        def undo(offset)
+            @root.undo(offset)
+            @root.normalize()
+        end
+
+        def change(ofs, bytes)
+            @root.change(ofs, bytes)
+            @root.normalize()
+            return ofs
+        end
+
+        def changed?(ofs, size=1); return @root.changed?(ofs, size) end
+
+        def debug(); LOG.level = Logger::DEBUG end
+
+        def dbgdump
+            LOG.debug("---#{@root.size()}---\n")
+            @root.dump()
+        end
+
+        def getData(ofs, size); return @root.data(ofs, size) end
+
+        def bytes; return @root.all() end
+
+        def getChanges; @root.getChanges(); end
+
+        def revert(what)
+            if what=='all'
+                @root.revert()
+                @root.normalize()
+                return true
+            end
+            undo(what)
+            return true
+        end
+
+
+        def curcol; @mode == HOW_ORIGINAL ? COL_ORIGINAL : COL_CHANGED end
+
+        def colVal(ofs, size)
+            fmt = "%#{size*2}.#{size*2}X"
+            u = size == 2 ? "v" : V
+            return colStr( sprintf(fmt, getData(ofs, size).unpack(u)[0]) , changed?(ofs,size))
+        end
+
+        def colStr(str, cond=true)
+            str = sprintf("%04X", str) if !str.is_a?(String)
+            return str if !cond
+            return @col.color(curcol(), str)
+        end
+
+
+        def parseHow(how)
+            return HOW_CHANGED if !how || how == HOW_CHANGED
+            return HOW_ORIGINAL if how == HOW_ORIGINAL
+            return HOW_ORIGINAL if how[0] == 'o' || how[0] == 'O'
+            return HOW_CHANGED
+        end
+
+
+        def hex(writer, ofs, size, how)
+            mode(parseHow(how))
+            col = curcol()
+            return @root.hex(writer, ofs, size, col)
+        end
+
+
+        def saveData(file)
+            mode(HOW_CHANGED)
+            file.write(bytes())
+        end
+
+        def saveChanges(file)
+            mode(HOW_CHANGED)
+            chs = getChanges()
+            file.write([chs.length].pack('V'))
+            chs.each{|o,bts|
+                flg = bts[0].length==0 ? 0x80000000 : 0
+                file.write([o, bts[1].length | flg ].pack('VV'))
+                file.write(bts[0]) if flg==0
+            }
+        end
+
+        def loadChanges(file)
+            mode(HOW_CHANGED)
+            @root.revert
+            clen = file.read(4).unpack('V')[0]
+            for _ in 0..clen-1
+                ofs, len = file.read(8).unpack('VV')
+                isNu = len & 0x80000000 !=0
+                len &= 0x7FFFFFFF
+                @root.cload(ofs, isNu ? "" : file.read(len), len)
+            end
+            mode(HOW_CHANGED)
+        end
+
+    end
+
+end

data/lib/resedit/{app → classes}/colorizer.rb

@@ -1,3 +1,5 @@
+require 'singleton'
+
 module Resedit
 
     class Colorizer
@@ -12,8 +14,10 @@ module Resedit
 
         attr_accessor :on
 
-        def initialize(on=true)
-            @on = on;
+        include Singleton
+
+        def initialize()
+            @on = true
         end
 
         def color(col, text)

data/lib/resedit/{mz → classes}/hexwriter.rb

@@ -1,4 +1,4 @@
-require 'resedit/app/app'
+require 'resedit/classes/colorizer'
 
 module Resedit
 
@@ -10,7 +10,7 @@ module Resedit
             @written = 0
             @charsInLine = 0x10
             @addr = addr
-            @col = App::get().col
+            @col = Colorizer.instance()
             @size = 0
             @line = nil
             @cline = ''

data/lib/resedit/convert/codepatch.rb

@@ -0,0 +1,66 @@
+module Resedit
+
+    class CodePatch
+        FMT_BINARY = 0
+        FMT_HEXSTRING = 1
+
+        class Chunk
+            NOP = "\x90"
+            attr_reader :data, :ofs, :size, :format
+
+            def initialize(data, format, splitter=NOP)
+                splitter.force_encoding(Encoding::ASCII_8BIT)
+                @data, @format = data, format
+                @ofs, @size = [], []
+                ofs=0
+                data.split(splitter).each{ |part|
+                    @ofs += [ofs]
+                    @size += [part.length()]
+                    ofs += part.length+1
+                }
+            end
+
+            def addr(idx, adr)
+                adr[0] += @ofs[idx]
+                return adr
+            end
+
+            def hexdata()
+                @data.each_byte.map { |b| sprintf("%02X",b) }.join
+            end
+
+            def value(idx, size, adr = nil, rep = "\xFF\xFF\xFF\xFF")
+                NOP.force_encoding(Encoding::ASCII_8BIT)
+                rep.force_encoding(Encoding::ASCII_8BIT)
+                ret = data[@ofs[idx], @size[idx]]
+                if adr and rep
+                    #replace with seg:ofs
+                    ret.gsub!(rep, mkadr(adr))
+                end
+                raise "Code is bigger #{ret.length()} than expected #{size}" if ret.length>size
+                while ret.length()<size
+                    ret += NOP
+                end
+                if @format == CodePatch::FMT_HEXSTRING
+                    ret = ret.each_byte.map { |b| sprintf("%02X",b) }.join
+                end
+                return ret
+            end
+
+            def mkadr(adr)
+                ret = (adr[0]&0xFF).chr + ((adr[0]>>8)&0xFF).chr
+                ret += (adr[1]&0xFF).chr + ((adr[1]>>8)&0xFF).chr
+                return ret
+            end
+
+        end
+
+        def self.loadPatch(fname, format = FMT_HEXSTRING, chunksplit="\x90\x90\x90\x90\x90")
+            chunksplit.force_encoding(Encoding::ASCII_8BIT)
+            bytes = File.read(fname, encoding:Encoding::ASCII_8BIT)
+            return bytes.split(chunksplit).each.map{|data| CodePatch::Chunk.new(data, format)}
+        end
+
+    end
+
+end

data/lib/resedit/mz/mz.rb

@@ -1,6 +1,6 @@
 require 'resedit/mz/mz_header'
 require 'resedit/mz/mz_body'
-require 'resedit/mz/hexwriter'
+require 'resedit/classes/hexwriter'
 require 'resedit/mz/mzenv'
 
 module Resedit
@@ -32,7 +32,7 @@ module Resedit
             @name = File.basename(@path, ".*")
             hi = @header.info()
             env().set(:entry, hi[:CS].to_s+":"+hi[:IP].to_s)
-            env().set(:append, sprintf("%04X:0",@body.appSeg))
+            env().set(:append, sprintf("0:0"))
         end
 
 
@@ -90,8 +90,9 @@ module Resedit
         end
 
 
-        def append(value, type=nil)
-            res = @body.append(getValue(value,type))
+        def append(value, type=nil, where=nil)
+            where = s2i(where) if where
+            res = @body.append(getValue(value,type), where)
             s = ""
             res.each{|a|
                 if a.is_a?(Array)
@@ -105,9 +106,9 @@ module Resedit
         end
 
 
-        def replace(value, type=nil)
+        def replace(value, type=nil, where=nil)
             @body.removeAppend()
-            return append(value,type)
+            return append(value,type, where)
         end
 
 
@@ -120,7 +121,7 @@ module Resedit
             else
                 res = @body.change(ofs,value) + @header.headerSize()
             end
-            log("Change added at %08X", res)
+            log("Change added at %08X", res) if res
         end
 
         def reloc(ofs)
@@ -167,7 +168,6 @@ module Resedit
             }
         end
 
-
     end
 
 end

data/lib/resedit/mz/mz_body.rb

@@ -1,4 +1,5 @@
-require 'resedit/mz/changeable'
+require 'resedit/classes/changeable'
+
 begin
     require 'crabstone'
     include Crabstone
@@ -12,10 +13,16 @@ module Resedit
 
     class MZBody < Changeable
 
-        attr_reader :segments, :appSeg
+        attr_reader :segments, :appSeg, :mz
 
         def initialize(mz, file, size)
-            super(mz, file, size)
+            @mz = mz
+            super(file, size)
+            @segments = nil
+            @addsz = 0
+        end
+
+        def reloadSegments()
             @segments = Set.new()
             for i in 0..@mz.header.info[:NumberOfRelocations]-1
                 r = @mz.header.getRelocation(i)
@@ -23,22 +30,25 @@ module Resedit
                 val = segData(r, 2).unpack('v')[0]
                 @segments.add(val)
             end
-            @appSeg = (@realSize >> 4) + 1
         end
 
-
-        def loadChanges(f)
-            super(f)
-            @appSeg = (@realSize >> 4) + 1
-            @segments.add(@appSeg)
+        def patchRelocs(add)
+            @segments = Set.new()
+            for i in 0..@mz.header.info[:NumberOfRelocations]-1
+                r = @mz.header.getRelocation(i)
+                @segments.add(r[1])
+                ofs = seg2Linear(r[0], r[1])
+                val = getData(ofs, 2).unpack('v')[0] + add
+                change(ofs, [val].pack('v'))
+                @segments.add(val)
+            end
         end
 
-
         def seg2Linear(a,s) (s << 4) + a end
 
-
         def seg4Linear(linear)
             linear >>= 4
+            reloadSegments() if !@segments
             min = @segments.sort.reverse.find{|e| e <= linear}
             return min ? min : 0
         end
@@ -58,51 +68,42 @@ module Resedit
 
         def segData(reloc, size, isStr=false)
             ofs = seg2Linear(reloc[0], reloc[1])
-            return "None" if ofs>@bytes.length
+            #return "None" if ofs > @root.size()
             return getData(ofs, size) if !isStr
             return colVal(ofs, size)
         end
 
 
         def removeAppend()
-            @segments.each{|s|
-                @segments.delete(s) if (s << 4) > @realSize
-            }
-            super()
+            mode(HOW_CHANGED)
+            undo(0) if @root.obuf.length==0
+            @addsz = 0
         end
 
-
         def revert(what)
-            @realOfs = @mz.header.headerSize()
             super(what)
+            @addsz = 0
         end
 
-
-        def append(bytes)
-            mode(HOW_ORIGINAL)
-            res = 0
-            addseg = false
-            if !@add
-                addseg = true
-                res = 0x10 - (@realSize % 0x10)
-                res = 0 if res == 0x10
-                bytes = ("\x90" * res).force_encoding(Encoding::ASCII_8BIT) + bytes if res > 0
-            end
-            res += super(bytes)
-            @mz.header.setCodeSize(@bytes.length + @add.length)
+        def append(bytes, where=nil)
+            mode(HOW_CHANGED)
+            res = @addsz
+            buf = @addsz>0 ? @root.nbuf[0, @addsz] : ''
+            buf += bytes
+            removeAppend()
+            @addsz = buf.length
+            sz = @mz.header.rebuildHeader(@addsz)
+            insert(0, bytes + "\x00"*(sz-@addsz))
             seg = linear2seg(res)
-            res = [res, seg]
-            if addseg
-                raise "Segs not match" if (@appSeg << 4) != res[0]
-                @segments.add(@appSeg)
-                res += [ [ 0, @appSeg] ]
-            end
+            res = [res, seg, sz/0x10]
+            patchRelocs(sz/0x10)
             return res
         end
 
 
         def print(what, how)
             if what=="header"
+                reloadSegments() if !@segments
                 puts "Known segments: " + @segments.sort.map{ |i| sprintf('%04X',i) }.join(", ")
                 return true
             end

data/lib/resedit/mz/mz_header.rb

@@ -1,4 +1,4 @@
-require 'resedit/mz/changeable'
+require 'resedit/classes/changeable'
 
 module Resedit
 
@@ -8,17 +8,18 @@ module Resedit
         PARA = 0x10
         HSIZE = 0x1C
 
-        attr_reader :info
+        attr_reader :info, :mz
 
         def initialize(mz, file, size)
             raise "Not MZ file" if size < HSIZE
-            super(mz, file, HSIZE)
+            @mz = mz
+            super(file, HSIZE)
             @fsize = size
             @_infoOrig = loadInfo()
             @_info = nil
             @info = @_infoOrig
             raise "Not MZ file" if MAGIC != @info[:Magic]
-            readMore(file, headerSize() - HSIZE)
+            addData(file, headerSize() - HSIZE)
         end
 
 
@@ -56,8 +57,22 @@ module Resedit
             change(2, ch.pack('vv'))
         end
 
-        def setCodeSize(size)
-            changeSize(size + headerSize())
+        def rebuildHeader(codesize)
+            mode(HOW_ORIGINAL)
+            ss = @info[:SS]
+            cs = @info[:CS]
+            sz = fileSize()-headerSize()
+            codesize += PARA - codesize % PARA if codesize % PARA!=0
+            changeSize(sz + codesize + headerSize())
+            paras = codesize / PARA
+            change(14, [ss+paras].pack('v'))
+            change(22, [cs+paras].pack('v'))
+            for i in 0..@mz.header.info[:NumberOfRelocations]-1
+                rel = getRelocation(i)
+                rel[1]+=paras
+                setRelocation(i, rel)
+            end
+            return codesize
         end
 
         def addHeaderSize(size)
@@ -88,6 +103,11 @@ module Resedit
             return getData(@info[:RelocTableOffset] + idx * 4, 4).unpack('vv')
         end
 
+        def setRelocation(idx, data)
+            raise "Wrong relocation index " if idx<0 || idx>@info[:NumberOfRelocations]
+            change(@info[:RelocTableOffset] + idx * 4, data.pack('vv'))
+        end
+
 
         def freeSpace(middle = false)
             return @info[:RelocTableOffset] - HSIZE  if middle
@@ -109,14 +129,13 @@ module Resedit
                 mode(HOW_CHANGED)
             end
             val = @mz.body.linear2seg(ofs)
-            puts "VAL"+ val.to_s()
             pos = @info[:RelocTableOffset]+@info[:NumberOfRelocations]*4
+            cnt = @info[:NumberOfRelocations]
             change(pos, val.pack('vv'))
-            change(6, [@info[:NumberOfRelocations]+1].pack('v'))
+            change(6, [cnt+1].pack('v'))
             return true
         end
 
-
         def print(what, how)
             mode(parseHow(how))
             if what == "header"
@@ -128,11 +147,11 @@ module Resedit
                 puts
                 fsz = fileSize()
                 hsz = headerSize()
-                s = colStr(sprintf("%d (%X)", fsz,fsz), changed?(2,4))
+                s = colStr(sprintf("%d (%X)", fsz,fsz), changed?(2, 4))
                 printf("mz file size: %s\treal file size: %d (0x%X)\n", s, @fsize, @fsize)
-                printf("header size: %s\n", colStr(hsz, changed?(8)))
-                printf("code size: %s\n", colStr(fsz - hsz, @mz.body.add != nil))
-                printf("reloc table size: %s\n", colStr(@info[:NumberOfRelocations] * 4, changed?(6)))
+                printf("header size: %s\n", colStr(hsz, changed?(8, 2)))
+                printf("code size: %s\n", colStr(fsz - hsz, @mz.body.changed?(0)))
+                printf("reloc table size: %s\n", colStr(@info[:NumberOfRelocations] * 4, changed?(6, 2)))
                 printf("free space in header: before relocs 0x%X,  after relocs 0x%X\n", freeSpace(true), freeSpace())
                 return true
             end
@@ -148,7 +167,6 @@ module Resedit
                 end
                 return true
             end
-            return super(what, how)
         end
 
 

data/lib/resedit/mz/mzenv.rb

@@ -37,7 +37,7 @@ module Resedit
             sz = s.length / 2 + s.length % 2 if !sz || sz==0
             hx = eval('0x'+s, binding())
             s=""
-            for i in 0..sz-1
+            for _ in 0..sz-1
                 s += sprintf("%02X", hx & 0xFF)
                 hx >>= 8
             end

data/lib/resedit/text/huffman.rb

@@ -170,7 +170,7 @@ module Resedit
             bytes.each_byte{|b|
                 raise sprintf("No byte in encode table: %02X", b)  if !tbl[b]
                 val = tbl[b][0]
-                for i in 0..tbl[b][1]-1
+                for _ in 0..tbl[b][1]-1
                     byte |= ((val & 1) << bytelen)
                     val >>= 1
                     bytelen += 1

data/lib/resedit/text/text.rb

@@ -32,7 +32,7 @@ module Resedit
             end
         end
 
-        def addLine(line, meta)
+        def addLine(line, meta = nil)
             line.encode!("utf-8",@encoding) if @encoding
             line.force_encoding('utf-8')
             @lines += [line]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: resedit
 version: !ruby/object:Gem::Version
-  version: 1.5.1
+  version: '1.6'
 platform: ruby
 authors:
 - bjfn
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-02 00:00:00.000000000 Z
+date: 2017-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chunky_png
@@ -49,20 +49,21 @@ files:
 - lib/resedit.rb
 - lib/resedit/app/app.rb
 - lib/resedit/app/app_command.rb
-- lib/resedit/app/colorizer.rb
 - lib/resedit/app/font_convert.rb
 - lib/resedit/app/io_commands.rb
 - lib/resedit/app/mz_command.rb
 - lib/resedit/app/std_commands.rb
 - lib/resedit/app/text_convert.rb
+- lib/resedit/classes/changeable.rb
+- lib/resedit/classes/colorizer.rb
+- lib/resedit/classes/hexwriter.rb
 - lib/resedit/convert/bitconv.rb
+- lib/resedit/convert/codepatch.rb
 - lib/resedit/font/font.rb
 - lib/resedit/font/font_char.rb
 - lib/resedit/image/image.rb
 - lib/resedit/image/image_factory.rb
 - lib/resedit/image/png_image.rb
-- lib/resedit/mz/changeable.rb
-- lib/resedit/mz/hexwriter.rb
 - lib/resedit/mz/mz.rb
 - lib/resedit/mz/mz_body.rb
 - lib/resedit/mz/mz_header.rb
@@ -83,9 +84,9 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - "~>"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/resedit/mz/changeable.rb

@@ -1,248 +0,0 @@
-require 'resedit/app/colorizer'
-require 'resedit/mz/hexwriter'
-require 'resedit/mz/mzenv'
-
-module Resedit
-
-    class Changeable
-        HOW_CHANGED = 0
-        HOW_ORIGINAL = 1
-        COL_CHANGED = Colorizer::YELLOW
-        COL_ORIGINAL = Colorizer::PURPLE
-
-        attr_reader :mz, :bytes, :add, :changes, :realSize, :realOfs
-
-        def initialize(mz, file, size)
-            @mz = mz
-            @bytes = file.read(size)
-            @realOfs = 0
-            @realSize = @bytes.size
-            @add = nil
-            @changes = {}
-            @c2 = []
-            @col = App::get().col
-            @mode = HOW_ORIGINAL
-        end
-
-        def readMore(file, size)
-            @bytes += file.read(size)
-            @realSize = @bytes.size
-        end
-
-
-        def mode(how)
-            return if @mode == how
-            if how == HOW_CHANGED
-                @bytes += @add if @add
-            else
-                @add = @bytes[@realSize..-1] if @bytes.length > @realSize
-                @bytes = @bytes[0, @realSize]
-            end
-            @changes.each{|c,bts|
-                @changes[c] = @bytes[c, bts.length]
-                bts.each_byte{|b|
-                    @bytes[c] = b.chr
-                    c += 1
-                }
-            }
-            @mode = how
-        end
-
-        def append(bytes)
-            mode(HOW_ORIGINAL)
-            pos = @bytes.length + (@add ? @add.length : 0)
-            @add = @add ? @add + bytes : bytes
-            return pos
-        end
-
-        def removeAppend()
-            mode(HOW_ORIGINAL)
-            @add = nil
-            @bytes = @bytes[0,@realSize]
-            return true
-        end
-
-
-        def changed?(ofs, size=2)
-            return true if ofs+size > @realSize
-            lower = @c2.find { |e| e < (ofs + size) }
-            return false if !lower
-            return lower + @changes[lower].length > ofs
-        end
-
-        def nextChange(ofs)
-            return ofs if changed?(ofs,1)
-            return @c2.reverse.find { |e| e > ofs }
-        end
-
-        def checkRange(ofs, size)
-            raise "Wrong offset: "+ofs.to_s if ofs < 0 || ofs >= @bytes.length
-            raise "Byte range overflow: " + ((ofs + size)-@bytes.length).to_s if ofs + size > @bytes.length
-        end
-
-        def bufWrite(buf, str, index)
-            return buf[0, index] + str + buf[index+str.length .. -1]
-        end
-
-        def change(ofs, bytes)
-            if ofs > @realSize
-                mode(HOW_CHANGED)
-                checkRange(ofs, bytes.length)
-                bytes.each_byte{|b|
-                    @bytes[ofs] = b.chr
-                    ofs += 1
-                }
-                return ofs
-            end
-            mode(HOW_ORIGINAL)
-            checkRange(ofs, bytes.length)
-            if changed?(ofs,bytes.length)
-                lower = @c2.find { |e| e < ofs + bytes.length }
-                strt = [lower, ofs].min()
-                en = [lower+@changes[lower].length, ofs+bytes.length].max()
-                buf = ("\0" * (en-strt)).force_encoding(Encoding::ASCII_8BIT)
-                buf = bufWrite(buf, @changes[lower], lower - strt)
-                buf = bufWrite(buf, bytes, ofs - strt)
-                @changes.delete(lower)
-                @c2.delete(lower)
-                change(strt, buf)
-            else
-                @changes[ofs] = bytes
-                @c2 = @changes.keys.reverse
-            end
-            return ofs
-        end
-
-        def revertChange(ofs)
-            raise sprintf("Change not found at: ") if !@changes[ofs]
-            mode(HOW_ORIGINAL)
-            @changes.delete(ofs)
-            @c2 = @changes.keys.reverse
-            return ofs
-        end
-
-        def revert(what)
-            mode(HOW_ORIGINAL)
-            if what=='all'
-                removeAppend()
-                @changes = {}
-                @c2=[]
-                return true
-            end
-            if what == 'append' || what==@realSize+@realOfs
-                removeAppend()
-                return true
-            end
-            return false if !@changes[what-@realOfs]
-            revertChange(what-@realOfs)
-            return true
-        end
-
-
-        def curcol() return @mode == HOW_ORIGINAL ? COL_ORIGINAL : COL_CHANGED end
-
-        def colVal(ofs, size)
-            fmt = "%#{size*2}.#{size*2}X"
-            u = size == 2 ? "v" : V
-            return colStr( sprintf(fmt, getData(ofs, size).unpack(u)[0]) , changed?(ofs,size))
-        end
-
-        def colStr(str, cond=true)
-            str = sprintf("%04X", str) if !str.is_a?(String)
-            return str if !cond
-            return @col.color(curcol(), str)
-        end
-
-        def getData(ofs, size)
-            checkRange(ofs, size)
-            return @bytes[ofs,size]
-        end
-
-
-        def parseHow(how)
-            return HOW_CHANGED if !how || how == HOW_CHANGED
-            return HOW_ORIGINAL if how == HOW_ORIGINAL
-            return HOW_ORIGINAL if how[0] == 'o' || how[0] == 'O'
-            return HOW_CHANGED
-        end
-
-        def print(what, how)
-            mode(parseHow(how))
-            if what=="changes"
-                @changes.each{|ofs,bts|
-                    bts = getData(ofs, bts.length)
-                    printf("%08X: %s\n", ofs+@realOfs, colStr(bts.bytes.map { |b| sprintf("%02X",b) }.join))
-                }
-                if @add
-                    printf("%08X: %s\n", @realSize+@realOfs, colStr(@add.bytes.map { |b| sprintf("%02X",b) }.join))
-                end
-                puts
-                return true
-            end
-            return false
-        end
-
-
-        def hex(writer, ofs, size, how)
-            mode(parseHow(how))
-            col = curcol()
-            return size if ofs > @bytes.length
-            while size > 0
-                if ofs>=@realSize
-                    sz = [size, @bytes.length - ofs].min
-                    if sz
-                        writer.addBytes(@bytes[ofs, sz], col)
-                        size -= sz
-                    end
-                    return size
-                end
-                x = nextChange(ofs)
-                x = @realSize if !x
-                sz = [size, x-ofs].min
-                if sz
-                    writer.addBytes(@bytes[ofs, sz], nil)
-                    size -= sz
-                    ofs += sz
-                end
-                return 0 if size == 0
-                if @changes[x]
-                    sz = [size, @changes[x].length].min
-                    if sz
-                        writer.addBytes(@bytes[ofs, sz], col)
-                        size -= sz
-                        ofs += sz
-                    end
-                end
-            end
-        end
-
-        def saveData(file)
-            mode(HOW_CHANGED)
-            file.write(@bytes)
-        end
-
-        def saveChanges(file)
-            mode(HOW_CHANGED)
-            file.write([@realSize, @changes.length].pack('VV'))
-            @changes.each{|c,bts|
-                file.write([c, bts.length].pack('VV'))
-                file.write(bts)
-            }
-        end
-
-        def loadChanges(file)
-            mode(HOW_CHANGED)
-            @realSize,clen=file.read(8).unpack('VV')
-            @add = @bytes[@realSize..-1] if @bytes.length > @realSize
-            @bytes = @bytes[0, @realSize]
-            for i in 0..clen-1
-                ofs, bts = file.read(8).unpack('VV')
-                @changes[ofs] = file.read(bts)
-            end
-            @c2 = @changes.keys.reverse
-            mode(HOW_ORIGINAL)
-        end
-
-    end
-
-end