resedit 1.7.3 → 1.8

data/lib/resedit/classes/hexwriter.rb

@@ -4,9 +4,9 @@ module Resedit
 
     class HexWriter
 
-        attr_accessor :written
+        attr_accessor :written, :addressFormatter, :addr
 
-        def initialize(addr)
+        def initialize(addr, addressFormatter=nil)
             @written = 0
             @charsInLine = 0x10
             @addr = addr
@@ -17,23 +17,15 @@ module Resedit
             @chr = ''
             @cchr = ''
             @pcol = nil
-            @segments = nil
-        end
-
-        def setSegments(segments, sfix)
-            @segments = segments.sort.reverse
-            @sfix = sfix
+            @addressFormatter = addressFormatter
         end
 
         def addrFormat()
-            add = ''
-            if @segments
-                seg = (@addr-@sfix) >> 4
-                min = @segments.find{|e| e <= seg}
-                min = 0 if !min
-                add = sprintf(" %04X:%04X", min, @addr - @sfix - (min << 4))
+            if @addressFormatter
+                res = @addressFormatter.formatAddress(@addr)+" | "
+            else
+                res = sprintf("%08X | ", @addr)
             end
-            res = sprintf("%08X%s | ", @addr, add)
             @addr += @charsInLine
             return res
         end

data/lib/resedit/mz/bw.rb

@@ -0,0 +1,67 @@
+require 'resedit/classes/exefile'
+
+module Resedit
+
+    class BWHeader < ExeHeader
+        MAGIC = 0x5742
+        HSIZE = 0xB0
+        HDRDESCR = [:Magic, :LastPageBytes, :BlocksInFile, :Reserved1, :Reserved2, :MinAlloc, :MaxAlloc, :SS, :SP, :FirstRelocSel, :IP, :CS,
+                    :RuntimeGdtSize, :MAKEPMVer, :NextHeaderPos, :CVInfoOffset, :LastSelUsed, :PMemAlloc, :AllocIncr, :Reserved4, :Options,
+                    :TransStackSel, :ExpFlags, :ProgramSize, :GdtImageSize, :FirstSelector, :DefaultMemStrategy, :Reserved5, :TransferBufferSize,
+                    :Reserved6, :ExpPath]
+        HDRUNPACK = "v14V2v3s6v6HHvs48a64"
+
+        # unsigned_16 signature;          /* BW signature to mark valid file  */
+        # unsigned_16 last_page_bytes;    /* length of image mod 512          */
+        # unsigned_16 pages_in_file;      /* number of 512 byte pages         */
+        # unsigned_16 reserved1;
+        # unsigned_16 reserved2;
+        # unsigned_16 min_alloc;          /* required memory, in KB           */
+        # unsigned_16 max_alloc;          /* max KB (private allocation)      */
+        # unsigned_16 stack_seg;          /* segment of stack                 */
+        # unsigned_16 stack_ptr;          /* initial SP value                 */
+        # unsigned_16 first_reloc_sel;    /* huge reloc list selector         */
+        # unsigned_16 init_ip;            /* initial IP value                 */
+        # unsigned_16 code_seg;           /* segment of code                  */
+        # unsigned_16 runtime_gdt_size;   /* runtime GDT size in bytes        */
+        # unsigned_16 MAKEPM_version;     /* ver * 100, GLU = (ver+10)*100    */
+        # /* end of DOS style EXE header */
+        # unsigned_32 next_header_pos;    /* file pos of next spliced .EXP    */
+        # unsigned_32 cv_info_offset;     /* offset to start of debug info    */
+        # unsigned_16 last_sel_used;      /* last selector value used         */
+        # unsigned_16 pmem_alloc;         /* private xm amount KB if nonzero  */
+        # unsigned_16 alloc_incr;         /* auto ExtReserve amount, in KB    */
+        # unsigned_8  reserved4[6];
+        # /* the following used to be referenced as gdtimage[0..1] */
+        # unsigned_16 options;            /* runtime options                  */
+        # unsigned_16 trans_stack_sel;    /* sel of transparent stack         */
+        # unsigned_16 exp_flags;          /* see ef_ constants below          */
+        # unsigned_16 program_size;       /* size of program in paras         */
+        # unsigned_16 gdtimage_size;      /* size of gdt in file (bytes)      */
+        # unsigned_16 first_selector;     /* gdt[first_sel] = gdtimage[0], 0 => 0x80 */
+        # unsigned_8  default_mem_strategy;
+        # unsigned_8  reserved5;
+        # unsigned_16 transfer_buffer_size;   /* default in bytes, 0 => 8KB   */
+        # /* the following used to be referenced as gdtimage[2..15] */
+        # unsigned_8  reserved6[48];
+        # char        EXP_path[64];       /* original .EXP file name  */
+
+        def headerSize(); HSIZE end
+
+        def fileSize(); @info[:BlocksInFile] * BLK + @info[:LastPageBytes] end
+        def entry; sprintf("%04X:%04X", @info[:CS], @info[:IP]) end
+
+
+    end
+
+
+    class BWBody < ExeBody
+    end
+
+    class BW < ExeFile
+        HDRCLASS = BWHeader
+        BODYCLASS = BWBody
+
+    end
+
+end

data/lib/resedit/mz/le.rb

@@ -0,0 +1,234 @@
+require 'resedit/classes/exefile'
+
+module Resedit
+
+    class LEHeader < ExeHeader
+        MAGIC = [0x454C, 0x584C, 0x434C]
+        HSIZE = 0xAC
+        HDRDESCR = [:Magic, :BOrd, :WOrd, :FormatLevel, :CpuType, :OsType, :ModuleVersion, :ModuleFlags, :ModulePages, :EIPObj, :EIP, :ESPObj, :ESP,
+                    :PageSize, :PageShift, :FixupSize, :FixupCsum, :LoaderSize, :LoaderCsum, :ObjectTableOfs, :ObjectsInModule,
+                    :ObjectPageOfs, :ObjectIterOfs, :ResourceTableOfs, :ResourceTableEntries, :ResidentTableOfs, :EntryTableOfs,
+                    :ModuleDirectivesOfs, :ModuleDirectives, :FixupPageOfs, :FixupRecordOfs, :ImportTblOfs, :ImportEntries, :ImportProcOfs,
+                    :PerPageCsum, :DataPagesOfs, :PreloadPages, :NonResTableOfs, :NonResTableLen, :NonResTableCsum, :AutoDSObject,
+                    :DebugInfoOfs, :DebugInfoLen, :InstancePreload, :InstanceDemand, :Heapsize]
+        HDRUNPACK = "vHHVvvV40"
+
+        #    00h | "L"   "X" |B-ORD|W-ORD|     FORMAT LEVEL      |
+        #     +-----+-----+-----+-----+-----+-----+-----+-----+
+        # 08h | CPU TYPE  |  OS TYPE  |    MODULE VERSION     |
+        #     +-----+-----+-----+-----+-----+-----+-----+-----+
+        # 10h |     MODULE FLAGS      |   MODULE # OF PAGES   |
+        #     +-----+-----+-----+-----+-----+-----+-----+-----+
+        # 18h |     EIP OBJECT #      |          EIP          |
+        #     +-----+-----+-----+-----+-----+-----+-----+-----+
+        # 20h |     ESP OBJECT #      |          ESP          |
+        #     +-----+-----+-----+-----+-----+-----+-----+-----+
+        # 28h |       PAGE SIZE       |   PAGE OFFSET SHIFT / LE: last page bytes !!!  |
+        #     +-----+-----+-----+-----+-----+-----+-----+-----+
+        # 30h |  FIXUP SECTION SIZE   | FIXUP SECTION CHECKSUM|
+        #     +-----+-----+-----+-----+-----+-----+-----+-----+
+        # 38h |  LOADER SECTION SIZE  |LOADER SECTION CHECKSUM|
+        #     +-----+-----+-----+-----+-----+-----+-----+-----+
+        # 40h |    OBJECT TABLE OFF   |  # OBJECTS IN MODULE  |
+        #     +-----+-----+-----+-----+-----+-----+-----+-----+
+        # 48h | OBJECT PAGE TABLE OFF | OBJECT ITER PAGES OFF |
+        #     +-----+-----+-----+-----+-----+-----+-----+-----+
+        # 50h | RESOURCE TABLE OFFSET |#RESOURCE TABLE ENTRIES|
+        #     +-----+-----+-----+-----+-----+-----+-----+-----+
+        # 58h | RESIDENT NAME TBL OFF |   ENTRY TABLE OFFSET  |
+        #     +-----+-----+-----+-----+-----+-----+-----+-----+
+        # 60h | MODULE DIRECTIVES OFF | # MODULE DIRECTIVES   |
+        #     +-----+-----+-----+-----+-----+-----+-----+-----+
+        # 68h | FIXUP PAGE TABLE OFF  |FIXUP RECORD TABLE OFF |
+        #     +-----+-----+-----+-----+-----+-----+-----+-----+
+        # 70h | IMPORT MODULE TBL OFF | # IMPORT MOD ENTRIES  |
+        #     +-----+-----+-----+-----+-----+-----+-----+-----+
+        # 78h |  IMPORT PROC TBL OFF  | PER-PAGE CHECKSUM OFF |
+        #     +-----+-----+-----+-----+-----+-----+-----+-----+
+        # 80h |   DATA PAGES OFFSET FROM MZ !!!  |    #PRELOAD PAGES     |
+        #     +-----+-----+-----+-----+-----+-----+-----+-----+
+        # 88h | NON-RES NAME TBL OFF  | NON-RES NAME TBL LEN  |
+        #     +-----+-----+-----+-----+-----+-----+-----+-----+
+        # 90h | NON-RES NAME TBL CKSM |   AUTO DS OBJECT #    |
+        #     +-----+-----+-----+-----+-----+-----+-----+-----+
+        # 98h |    DEBUG INFO OFF     |    DEBUG INFO LEN     |
+        #     +-----+-----+-----+-----+-----+-----+-----+-----+
+        # A0h |   #INSTANCE PRELOAD   |   #INSTANCE DEMAND    |
+        #     +-----+-----+-----+-----+-----+-----+-----+-----+
+        # A8h |       HEAPSIZE        |
+        #
+
+        # Object Table
+        #     +-----+-----+-----+-----+-----+-----+-----+-----+
+        # 00h |     VIRTUAL SIZE      |    RELOC BASE ADDR    |
+        #     +-----+-----+-----+-----+-----+-----+-----+-----+
+        # 08h |     OBJECT FLAGS      |    PAGE TABLE INDEX   |
+        #     +-----+-----+-----+-----+-----+-----+-----+-----+
+        # 10h |  # PAGE TABLE ENTRIES |       RESERVED        |
+        #     +-----+-----+-----+-----+-----+-----+-----+-----+
+
+        attr_reader :tables
+
+        def initialize(exe, file, fsize)
+            @_tablesOrig = nil
+            @sofs = file.tell()
+            super(exe, file, fsize)
+        end
+
+        def loadTables(file)
+            if @_tablesOrig==nil
+                objtblend = @sofs+@info[:ObjectTableOfs]+@info[:ObjectsInModule]*0x18
+                #addData(file, objtblend-file.tell())
+                objtblend = @sofs+@info[:ObjectPageOfs]+@info[:ModulePages]*8
+                addData(file, objtblend-file.tell())
+            end
+            tbl = {:Objects => [], :Pages => []}
+            ofs = 0
+            for i in 0..@info[:ObjectsInModule]-1
+                descr = getData(@info[:ObjectTableOfs]+i*0x18, 0x18).unpack("V*")
+                tbl[:Objects] += [descr]
+                @exe.env.set("seg#{i}".to_sym, ofs.to_s)
+                ofs += descr[4]*@info[:PageSize]
+            end
+            for i in 0..@info[:ModulePages]-1
+                tbl[:Pages] += getData(@info[:ObjectPageOfs]+i*4, 4).unpack("V")
+            end
+            if @_tablesOrig==nil
+                @tables = @_tablesOrig = tbl
+            end
+            return tbl
+        end
+
+        def loadTail(file);
+            addData(file, headerSize() + @sofs - file.tell())
+        end
+
+        def readRelocs()
+            def read(pos,cnt, unp); [getData(@info[:FixupRecordOfs]+pos, cnt).unpack(unp),pos+cnt] end
+            ret = {}
+            pgs = getData(@info[:FixupPageOfs], 4*(@info[:ModulePages]+1)).unpack("V*")
+            for i in 0..@info[:ModulePages]-1
+                pos = pgs[i]
+                op = @tables[:Pages][i]
+                pgofs = ((op>>16) + ((op>>8) & 0xFF) -1) * @info[:PageSize]
+                ret[pgofs] = {}
+                while pos<pgs[i+1]
+                    v,pos = read(pos, 5, "CCvC")
+                    raise "Unknown fixup type #{v[0]} #{v[1]}" if (v[0]!=7 && v[0]!=2) || (v[1] & ~0x10 !=0 )
+                    trg, pos=read(pos, v[1]==0x10 ? 4 : 2,v[1]==0x10 ? "V" : "v")
+                    next if v[2]>0x7FFF
+                    ofs = pgofs+v[2]
+                    ret[pgofs][pgofs+v[2]] = @tables[:Objects][v[3]-1][1]+trg[0]
+                end
+            end
+            return ret
+        end
+
+
+        def mode(how)
+            super(how)
+            if @mode == HOW_ORIGINAL
+                @tables = @_tablesOrig
+            else
+                @_tables = loadTables(nil) if !@_tables
+                @tables = @_tables
+            end
+        end
+
+        def headerSize(); @info[:DataPagesOfs]-@exe.mzSize end
+
+        def fileSize(); headerSize()+(@info[:ModulePages]-1)*@info[:PageSize]+@info[:PageShift] end
+        def entry; sprintf("0x%08X", @info[:EIP]) end
+
+        def print(what, how=nil)
+            ret = super(what, how)
+            if what=="tables"
+                puts "Objects: #{@tables[:Objects].map{|o| o.map{|v| v.to_s(16)}}}"
+                puts "Pages: #{@tables[:Pages].map{|x| x.to_s(16)}}"
+                return true
+            end
+            return ret
+        end
+    end
+
+    class LEBody < ExeBody
+
+        def initialize(exe, file, fsize)
+            super(exe, file, fsize)
+        end
+
+        def sections()
+            if !@sex
+                ofs = 0
+                @sex=[]
+                @exe.header.tables[:Objects].each{|descr|
+                    sz = descr[4] * @exe.header.info[:PageSize]
+                    if sz!=0
+                        @sex += [[descr[1], ofs, sz]]
+                        ofs += sz
+                    end
+                }
+            end
+            @sex
+        end
+
+        def relocations()
+            if !@relocs
+                @relocs = @exe.header.readRelocs().sort_by{|k,v| k}.reverse.to_h
+                @relocs.each{|k,v|
+                    @relocs[k] = v.sort_by{|k2,v2| k2}.reverse.to_h
+                }
+            end
+            @relocs
+        end
+
+        def formatAddress(raw)
+            return sprintf("%08X %08X", raw, raw2addr(raw))
+        end
+
+        def raw2addr(ofs)
+            s = sections.find{|s| s[1]<=ofs && s[1]+s[2]>ofs}
+            raise "Not raw offset #{ofs.to_s(16)}" if !s
+            return s[0]+ofs-s[1]
+        end
+
+        def addr2raw(addr)
+            s = sections.find{|s| s[0]<=addr && s[0]+s[2]>addr}
+            raise "Not virtual address #{addr.to_s(16)}" if !s
+            return s[1]+addr-s[0]
+        end
+
+        def readRelocated(ofs, size);
+            rel = relocations()
+            d = getData(ofs, size)
+            @relocs.each{|o,v|
+                next if o>ofs+size
+                v.each{|a, r|
+                    next if a>ofs+size
+                    break if a<ofs
+                    pos = a-ofs
+                    d = d[0,pos] + [r].pack("V") + (d[pos+4..-1] or '')
+                }
+                break if o<ofs
+            }
+            return d[0,size]
+        end
+
+    end
+
+
+    class LE < ExeFile
+        HDRCLASS = LEHeader
+        BODYCLASS = LEBody
+        MODE = 32
+
+        attr_reader :mzSize
+
+        def load(file, sz, prev)
+            @mzSize = prev.header.fileSize()
+            super(file, sz, prev)
+        end
+
+    end
+
+end

data/lib/resedit/mz/multiexe.rb

@@ -0,0 +1,85 @@
+require 'resedit/classes/exefile'
+require 'resedit/mz/mz'
+require 'resedit/mz/bw'
+require 'resedit/mz/le'
+
+module Resedit
+
+    class Multiexe < ExeFile
+
+        KNOWN_TYPES = {'MZ' => MZ, 'BW' => BW, 'LE' => LE, 'LX' => LE, 'LC'=>LE}
+
+        attr_reader :cur
+
+        def initialize(path, quiet = false)
+            @cur = nil
+            @parts = []
+            super(path, quiet)
+        end
+
+        def load(f, fsize)
+            cid = 0
+            while !f.eof?
+                s = f.read(2).unpack('A2')[0]
+                f.seek(-2, :CUR)
+                #log("Loading part #{s} @ 0x#{f.tell.to_s(16)}")
+                raise "Unknown format #{s}" if !KNOWN_TYPES[s]
+                obj = KNOWN_TYPES[s].new(nil, @quiet)
+                sz = fsize - f.tell()
+                obj.load(f, sz, @parts.length>0 ? @parts[-1] : 0 )
+                cid = @parts.length() if obj.is_a?(LE)
+                @parts += [obj]
+            end
+            setPart(cid)
+        end
+
+        def loadConfig(cfg)
+            @parts.each.with_index{|pr, i|
+                pr.loadConfig(cfg[i.to_s])
+            }
+        end
+
+        def header; @cur.header end
+        def body; @cur.body end
+        def env; @cur.env end
+
+        def setPart(id); @cur = @parts[id] end
+        def close(); @parts.each{|pr| pr.close()} end
+
+        def print(what, how=nil)
+            if what=="parts"
+                puts "#{@parts.length} parts:"
+                @parts.each.with_index{|pr, i|
+                    puts "#{i}: #{pr.class} #{pr}"
+                }
+                return true
+            end
+            @cur.print(what, how)
+        end
+        def hex(ofs, size=nil, how=nil, disp=nil); @cur.hex(ofs, size, how, disp) end
+        def hexify(str); @cur.hexify(str) end
+        def getValue(value, type); @cur.getValue(value, type) end
+        def append(value, type=nil, where=nil); @cur.append(value, type, where) end
+        def replace(value, type=nil, where=nil); @cur.replace(value, type, where) end
+        def change(ofs, value, disp=nil, type=nil); @cur.change(ofs, value, disp, type) end
+        def reloc(ofs); @cur.reloc(ofs) end
+        def dasm(ofs, size=nil, how=nil) @cur.dasm(ofs, size, how) end
+        def valueof(str, type); @cur.valueof(str, type) end
+        def revert(what); @cur.revert(what) end
+        def readRelocated(ofs, size); @cur.readRelocated(ofs, size) end
+
+        def saveConfig()
+            cfg = {}
+            @parts.each.with_index{|pr, i|
+                cfg[i] = pr.saveConfig()
+            }
+            return cfg
+        end
+
+        def saveFile(f)
+            @parts.each{|pr| pr.saveFile(f)}
+        end
+
+    end
+
+end

data/lib/resedit/mz/mz.rb

@@ -1,175 +1,282 @@
-require 'resedit/mz/mz_header'
-require 'resedit/mz/mz_body'
-require 'resedit/classes/hexwriter'
-require 'resedit/mz/mzenv'
+require 'resedit/classes/exefile'
 
 module Resedit
 
-    class MZ
-        ZM = 0x4D5A
-
-        attr_reader :fname, :path, :name, :fsize
-        attr_reader :header, :body
-
-        def initialize(path, quiet = false)
-            raise "File not specified" if !path
-            @quiet = quiet
-            @path = path.downcase()
-            @fsize = File.size(path)
-            open(@path,"rb:ascii-8bit"){|f|
-                @header = MZHeader.new(self, f, fsize)
-                hsz = @header.headerSize()
-                @body = MZBody.new(self, f, @header.fileSize() - hsz)
-                save = f.read(2)
-                zm = save ? save.unpack('v')[0] : nil
-                if zm == ZM
-                    @header.loadChanges(f)
-                    @body.loadChanges(f)
-                    log("Change info loaded.")
-                end
-            }
-            @fname = File.basename(@path)
-            @name = File.basename(@path, ".*")
-            hi = @header.info()
-            env().set(:entry, hi[:CS].to_s+":"+hi[:IP].to_s)
-            env().set(:append, sprintf("0:0"))
-        end
+    class MZHeader < ExeHeader
+        MAGIC = 0x5A4D
+        HSIZE = 0x1C
+        HDRDESCR = [:Magic, :BytesInLastBlock, :BlocksInFile, :NumberOfRelocations, :HeaderParagraphs, :MinExtraParagraphs, :MaxExtraParagraphs,
+                    :SS, :SP, :Checksum, :IP, :CS, :RelocTableOffset, :OverlayNumber]
 
+        attr_reader :relocFix
 
-        def close()
+        def initialize(exe, file, size)
+            super(exe, file, size)
+            @relocFix = 0
+            @newOfs = false
+            if @info[:RelocTableOffset]>=0x40
+                @newOfs = getData(0x3C, 2).unpack("v")[0]
+            end
         end
 
+        def entry; sprintf("%04X:%04X", @info[:CS], @info[:IP]) end
 
-        def log(fmt, *args)
-            App::get().log(fmt, *args) if !@quiet
+        def setFileSize(size)
+            mode(HOW_CHANGED)
+            mod = size % BLK
+            setInfo(:BytesInLastBlock, [mod, size / BLK + (mod ? 1 : 0)])
         end
 
+        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
+            setInfo(:SS, ss+paras)
+            setInfo(:CS, cs+paras)
+            for i in 0..@info[:NumberOfRelocations]-1
+                rel = getRelocation(i)
+                rel[1] += paras-@relocFix
+                fix(@info[:RelocTableOffset] + i * 4, rel.pack('vv'))
+            end
+            mode(HOW_CHANGED)
+            @relocFix = paras
+            MZEnv.instance().set(:relocFix, paras.to_s)
+            return codesize
+        end
 
-        def env() return MZEnv.instance() end
-        def s2i(str) return MZEnv.instance().s2i(str) end
-
+        def addHeaderSize(size)
+            mode(HOW_CHANGED)
+            paras = size/16 + (size%16 == 0 ? 0 : 1)
+            insert(headerSize(), "\x00" * (paras * PARA))
+            setFileSize(fileSize() + paras * PARA)
+            setInfo(:HeaderParagraphs, @info[:HeaderParagraphs] + paras)
+            mode(HOW_CHANGED)
+        end
 
-        def is?(id)
-            id = id.downcase
-            return id == @path || id == @fname || id == @name
+        def loadChanges(cfg)
+            super(cfg)
+            mode(HOW_ORIGINAL)
+            ocs = @info[:CS]
+            mode(HOW_CHANGED)
+            ncs = @info[:CS]
+            @relocFix = ncs - ocs
         end
 
+        def headerSize(); @info[:HeaderParagraphs] * PARA end
 
-        def print(what, how=nil)
-            puts "Header changes:" if what=="changes"
-            res = @header.print(what, how)
-            puts "Code changes:" if what=="changes"
-            res |= @body.print(what, how)
-            raise "Don't know how to print: " + what if !res
+        def fileSize()
+            return @newOfs if @newOfs
+            sz = @info[:BlocksInFile] * BLK
+            if @info[:BytesInLastBlock] != 0
+                sz -= BLK - @info[:BytesInLastBlock]
+            end
+            return sz
         end
 
 
-        def hex(ofs, size=nil, how=nil, disp=nil)
-            ofs = ofs ? s2i(ofs) : 0
-            size = size ? s2i(size) : 0x100
-            isfile = disp && (disp[0]=='f' || disp[0]=='F') ? true : false
-            wr = HexWriter.new(ofs)
-            how = @header.parseHow(how)
-            hsz = 0
-            if isfile
-                @header.mode(how)
-                hsz = @header.headerSize()
-                size = @header.hex(wr, ofs, size, how) if ofs < hsz
-                ofs -= hsz
-                ofs = 0 if ofs < 0
-            end
-            wr.setSegments(@body.segments, hsz)
-            @body.hex(wr, ofs, size, how) if size > 0
-            wr.finish()
+        def getRelocation(idx)
+            raise "Wrong relocation index " if idx<0 || idx >= @info[:NumberOfRelocations]
+            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
+            return headerSize() - HSIZE - @info[:NumberOfRelocations] * 4
+        end
 
-        def getValue(value, type)
-            s = env().value2bytes(value, type)
-            return s.force_encoding(Encoding::ASCII_8BIT)
+        def setSpaceForRelocs(count)
+            add = count - @info[:NumberOfRelocations]
+            return if add<=0
+            add -= freeSpace()/4
+            return if add<=0
+            addHeaderSize(add*4)
+            setInfo(:NumberOfRelocations, count)
+            mode(HOW_CHANGED)
         end
 
+        def addReloc(ofs)
+            mode(HOW_CHANGED)
+            #check relocation exists
+            for i in 0..@info[:NumberOfRelocations]-1
+                rel = getRelocation(i)
+                if @exe.body.seg2Linear(rel[0], rel[1]) == ofs
+                    return false
+                end
+            end
+            #add relocation
+            setSpaceForRelocs(@info[:NumberOfRelocations]+1)
+            val = @exe.body.linear2seg(ofs)
+            setRelocation(@info[:NumberOfRelocations], val)
+            return true
+        end
 
-        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)
-                    s += sprintf(" %04X:%04X", a[1], a[0])
-                else
-                    s += sprintf(" %08X", a)
+        def print(what, how)
+            mode(parseHow(how))
+            if what == "header"
+                ofs=0
+                @info.each{|k,v|
+                    printf("%20s:\t%s\n", k.to_s, colVal(ofs, 2))
+                    ofs+=2
+                }
+                puts
+                fsz = fileSize()
+                hsz = headerSize()
+                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, 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())
+                printf("reloc fix: 0x%X\n", @relocFix)
+                return true
+            end
+            @exe.body.mode(@mode)
+            if what == "reloc"
+                ofs = @info[:RelocTableOffset]
+                for i in 0..@info[:NumberOfRelocations]-1
+                    s1 = colVal(ofs,2)
+                    s2 = colVal(ofs+2,2)
+                    s3 = @exe.body.segData(getRelocation(i), 2, true)
+                    printf("%08X\t%s:%s\t= %s\n", ofs, s2, s1, s3)
+                    ofs += 4
                 end
-            }
-            log("Appended at %s",s)
-            return res
+                return true
+            end
+            return super(what, how)
         end
 
+    end
+
 
-        def replace(value, type=nil, where=nil)
-            @body.removeAppend()
-            return append(value,type, where)
+    class MZBody < ExeBody
+
+        attr_reader :segments
+
+        def initialize(exe, file, size)
+            super(exe, file, size)
+            @segments = nil
         end
 
+        def reloadSegments()
+            @segments = Set.new()
+            for i in 0..@exe.header.info[:NumberOfRelocations]-1
+                r = @exe.header.getRelocation(i)
+                @segments.add(r[1])
+                sd = segData(r, 2)
+                next if !sd
+                val = sd.unpack('v')[0]
+                @segments.add(val)
+            end
+            @msegs = @segments.sort.reverse
+        end
 
-        def change(ofs, value, disp=nil, type=nil)
-            ofs = s2i(ofs)
-            isfile = disp && (disp[0]=='f' || disp[0]=='F') ? true : false
-            value = getValue(value, type)
-            if isfile
-                res = @header.change(ofs,value)
-            else
-                res = @body.change(ofs,value) + @header.headerSize()
+        def patchRelocs(add)
+            @segments = Set.new()
+            for i in 0..@exe.header.info[:NumberOfRelocations]-1
+                r = @exe.header.getRelocation(i)
+                @segments.add(r[1])
+                ofs = seg2Linear(r[0], r[1])
+                val = getData(ofs, 2).unpack('v')[0] + add
+                fix(ofs, [val].pack('v'))
+                @segments.add(val)
             end
-            log("Change added at %08X", res) if res
+            @msegs = @segments.sort.reverse
         end
 
-        def reloc(ofs)
-            ofs = s2i(ofs)
-            res = @header.addReloc(ofs)
-            log((res ? "Relocation added %08X" : "Relocation %08X already exists"), ofs)
+        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
 
 
-        def dasm(ofs, size=nil, how=nil)
-            ofs = s2i(ofs ? ofs : "entry")
-            size = size ? s2i(size) : [0x20, @body.bytes.length-ofs].min
-            @body.dasm(ofs, size, how)
+        def linear2seg(linear, inSegments=nil)
+            inSegments = [seg4Linear(linear)] if !inSegments
+            res = []
+            inSegments.each{|s|
+                raise sprintf("Linear %X less than segment %04X", inSegments[0], s) if linear < (s<<4)
+                a = linear - (s << 4)
+                res += [a,s]
+            }
+            return res
         end
 
 
-        def valueof(str, type)
-            puts "value of " + str + " is:"
-            p getValue(str, type).unpack("H*")
+        def segData(reloc, size, isStr=false)
+            ofs = seg2Linear(reloc[0], reloc[1])
+            return nil if ofs > @root.size()
+            return getData(ofs, size) if !isStr
+            return colVal(ofs, size)
         end
 
+        def formatAddress(addr)
+            @sfix=0
+            seg = (addr-@sfix) >> 4
+            min = @msegs.find{|e| e <= seg}
+            min = 0 if !min
+            return sprintf("%08X %04X:%04X", addr, min, addr - @sfix - (min << 4))
+        end
 
-        def revert(what)
-            wid = env().s2i_nt(what)
-            what = wid[1] ? wid[0] : what
-            res = @header.revert(what)
-            res |= @body.revert(what)
-            raise "Don't know how to revert: "+what if !res
-            log("Reverted")
+        def raw2addr(ofs); linear2seg(ofs) end
+        def addr2raw(addr); seg2Linear(addr[0], addr[1]) end
+
+
+        def append(bytes, where=nil)
+            mode(HOW_CHANGED)
+            relfix = @exe.header.relocFix
+            res = @addsz
+            buf = @addsz>0 ? @root.nbuf[0, @addsz] : ''
+            buf += bytes
+            removeAppend()
+            @addsz = buf.length
+            sz = @exe.header.rebuildHeader(@addsz)
+            insert(0, bytes + "\x00"*(sz-@addsz))
+            seg = linear2seg(res)
+            res = [res, seg, sz/0x10]
+            patchRelocs(sz/0x10 - relfix)
+            return res
         end
 
-        def hexify(str)
-            str.each_byte.map { |b| sprintf("%02X",b) }.join
+
+        def print(what, how)
+            if what=="header"
+                reloadSegments() if !@segments
+                puts "Known segments: " + @segments.sort.map{ |i| sprintf('%04X',i) }.join(", ")
+                return true
+            end
+            return super(what, how)
         end
 
 
-        def save(filename, final=nil)
-            raise "Unknown final: " + final if final && final != "final"
-            raise "Filename expected." if !filename
-            open(filename, "wb:ascii-8bit"){|f|
-                @header.saveData(f)
-                @body.saveData(f)
-                if !final || final!='final'
-                    f.write([ZM].pack('v'))
-                    @header.saveChanges(f)
-                    @body.saveChanges(f)
-                end
-            }
+        def printDasm(inst, str)
+            seg = linear2seg(inst.address)
+            printf("%08X %04X:%04X%s\n",inst.address, seg[1], seg[0], str)
+        end
+
+    end
+
+
+    class MZ < ExeFile
+        HDRCLASS = MZHeader
+        BODYCLASS = MZBody
+
+        def reloc(ofs)
+            ofs = s2i(ofs)
+            res = @header.addReloc(ofs)
+            log((res ? "Relocation added %08X" : "Relocation %08X already exists"), ofs)
         end
 
     end