resedit 1.3.1

data/lib/resedit/text/conv_keybru.rb

@@ -0,0 +1,84 @@
+# encoding: utf-8
+
+module Resedit
+
+    class KeyboardRuConvertTable < ConvertTable
+
+        def initialize()
+            super()
+            @table={
+                'Q' => 'Й',
+                'W' => 'Ц',
+                'E' => 'У',
+                'R' => 'К',
+                'T' => 'Е',
+                'Y' => 'Н',
+                'U' => 'Г',
+                'I' => 'Ш',
+                'O' => 'Щ',
+                'P' => 'З',
+                '{' => 'Х',
+                '}' => 'Ъ',
+                'A' => 'Ф',
+                'S' => 'Ы',
+                'D' => 'В',
+                'F' => 'А',
+                'G' => 'П',
+                'H' => 'Р',
+                'J' => 'О',
+                'K' => 'Л',
+                'L' => 'Д',
+                ':' => 'Ж',
+                "\"" => 'Э',
+                'Z' => 'Я',
+                'X' => 'Ч',
+                'C' => 'С',
+                'V' => 'М',
+                'B' => 'И',
+                'N' => 'Т',
+                'M' => 'Ь',
+                '<' => 'Б',
+                '>' => 'Ю',
+
+                'q' => 'й',
+                'w' => 'ц',
+                'e' => 'у',
+                'r' => 'к',
+                't' => 'е',
+                'y' => 'н',
+                'u' => 'г',
+                'i' => 'ш',
+                'o' => 'щ',
+                'p' => 'з',
+                '[' => 'х',
+                ']' => 'ъ',
+                'a' => 'ф',
+                's' => 'ы',
+                'd' => 'в',
+                'f' => 'а',
+                'g' => 'п',
+                'h' => 'р',
+                'j' => 'о',
+                'k' => 'л',
+                'l' => 'д',
+                ';' => 'ж',
+                "\'" => 'э',
+                'z' => 'я',
+                'x' => 'ч',
+                'c' => 'с',
+                'v' => 'м',
+                'b' => 'и',
+                'n' => 'т',
+                'm' => 'ь',
+                ',' => 'б',
+                '.' => 'ю',
+
+                '~'  => 'Ё',
+                '`'  => 'ё'
+            }
+        end
+
+
+    end
+
+end

data/lib/resedit/text/conv_table.rb

@@ -0,0 +1,10 @@
+module Resedit
+
+    class ConvertTable
+
+        def initialize()
+        end
+
+    end
+
+end

data/lib/resedit/text/escaper.rb

@@ -0,0 +1,117 @@
+module Resedit
+
+    class TextEscaper
+
+        STD_TABLE = {0x5C=>"\\\\", 0x0A=>"\\n", 0x0D=>"\\r", 0x09=>"\\t", 0x07=>"\\a", 0x08=>"\\b", 0x0C=>"\\f", 0x0B=>"\\v", 0x1B=>"\\e"}
+
+        def escape(line)
+            out=""
+            line.each_byte {|b|
+                out += _escape(b)
+            }
+            return out
+        end
+
+        def unescape(line); end
+
+        protected
+
+        def tableReplace(str,tbl,numproc=true)
+            ntbl={}
+            if tbl
+                tbl.each{|b,v|
+                    ntbl[v[0]]={} if !ntbl[v[0]]
+                    ntbl[v[0]][v]=b
+                }
+            end
+            pos=0
+            res=""
+            while pos < str.length
+                val=str[pos]
+                inc=1
+                if ntbl[val]
+                    ntbl[val].each{|v,b|
+                        next if str.length < pos+v.length+1
+                        if v==str[pos,v.length]
+                            val=b.chr
+                            inc=v.length
+                            break
+                        end
+                    }
+                end
+                if inc==1 && numproc && val=="\\"
+                    raise "Bad escape sequence: "+str if str.length < pos+5
+                    num = str[pos+1,3]
+                    byte = num[0].upcase=="X" ? num[1,2].to_i(16) : num.to_i
+                    raise "Bad numeric escape "+num+": "+str if (byte==0 and num!="000" and num!="x00") || byte>255 || byte<0
+                    val=byte.chr
+                    inc=4
+                end
+                res += val
+                pos += inc
+            end
+            return res
+        end
+
+        def _escape(b); end
+    end
+
+
+    class SlashEscaper < TextEscaper
+
+        def _escape(b)
+            return '\\\\' if b==0x5c
+            b<0x20 ? sprintf("\\x%02X", b) : b.chr
+        end
+
+        def unescape(line)
+            tableReplace(line,{0x5C=>"\\\\"})
+        end
+
+    end
+
+
+    class StdEscaper < SlashEscaper
+
+        def _escape(b)
+            STD_TABLE[b] ? STD_TABLE[b] : super(b)
+        end
+
+        def unescape(line)
+            tableReplace(line,STD_TABLE)
+        end
+
+    end
+
+
+    class TableEscaper < TextEscaper
+
+        def initialize(table=nil, stdTable=STD_TABLE)
+            @table={}
+            if stdTable
+                stdTable.each {|b, e|
+                    add(b, e)
+                }
+            end
+            if table
+                table.each {|b, e|
+                    add(b,e)
+                }
+            end
+        end
+
+        def add(byte, esc)
+            @table[byte] = esc
+        end
+
+        def _escape(b)
+            @table[b] ? @table[b] : b.chr
+        end
+
+        def unescape(line)
+            tableReplace(line,@table,false)
+        end
+
+    end
+
+end

data/lib/resedit/text/format_text.rb

@@ -0,0 +1,44 @@
+
+module Resedit
+
+    class TextFormat
+
+        def initialize(encoding)
+            @encoding=encoding
+        end
+
+        def saveLines(fname, lines, meta); end
+
+        def loadLines(fname); end
+
+    end
+
+    class FormatTxt < TextFormat
+
+        def initialize(encoding)
+            super((encoding or 'cp1251'))
+        end
+
+        def saveLines(fname, lines, meta)
+            open(fname+".txt", "w:"+@encoding) {|f|
+                lines.each {|l|
+                    l.force_encoding('utf-8')
+                    f.write(l)
+                    f.write("\r\n")
+                }
+            }
+        end
+
+        def loadLines(fname)
+            lns=[]
+            open(fname+".txt", "r:"+@encoding+":utf-8").each_line {|line|
+                lns += [line.chomp]
+            }
+            lns=lns[0..-2] if lns.last == ""
+            return lns
+        end
+
+
+    end
+
+end

data/lib/resedit/text/format_xml.rb

@@ -0,0 +1,46 @@
+require 'resedit/text/format_text'
+require 'builder'
+require 'rexml/document'
+
+module Resedit
+
+    class FormatXml < TextFormat
+
+        def initialize(encoding)
+            super('utf-8')
+        end
+
+        def saveLines(fname, lines, meta)
+            open(fname+".xml", "w:"+@encoding) {|f|
+                xml=Builder::XmlMarkup.new(:indent => 2 , :target=>f)
+                xml.instruct! :xml, :encoding => @encoding
+                xml.body {|b|
+                    lines.each.with_index{|l,i|
+                        mt = {'id' => i}
+                        mt.update(meta[i]) if meta[i]
+                        b.text(l, mt)
+                    }
+                }
+            }
+        end
+
+        def loadLines(fname)
+            hs={}
+            open(fname+".xml", "r:"+@encoding) {|f|
+                doc=REXML::Document.new(f)
+                doc.elements.each("body/text"){|e|
+                    hs[e.attributes['id']] = e.text
+                }
+            }
+            raise "No data in xml" if !hs.length
+            lns=[]
+            for i in 0..hs.length-1
+                raise "Text not found: "+i if !hs[i]
+                lns+=[ hs[i] ]
+            end
+            return lns
+        end
+
+    end
+
+end

data/lib/resedit/text/huffman.rb

@@ -0,0 +1,190 @@
+require 'resedit/app/app'
+module Resedit
+
+    class Huffman
+
+        class Node
+            attr_accessor :value, :parent, :left, :right
+
+            def initialize(value=nil, parent=nil)
+                @value=value
+            end
+
+            def addNode(isLeft,value=nil)
+                n=Node.new(value)
+                if isLeft
+                    @left=n
+                else
+                    @right=n
+                end
+                return n
+            end
+
+            def addLeft(value=nil)
+                addNode(true, value)
+            end
+
+            def addRight(value=nil)
+                addNode(false, value)
+            end
+
+            def getLeafs(leftS,rightS,path='')
+                return {path=>@value} if @value
+                l=@left.getLeafs(leftS, rightS, path+leftS)
+                r=@right.getLeafs(leftS, rightS, path+rightS)
+                return l.merge(r)
+            end
+
+        end
+
+
+        class Balancer
+            attr_reader :huff
+            def initialize(huff)
+                @huff = huff
+                @tbl = {}
+            end
+
+            def addData(bytes)
+                bytes.each_byte{|b|
+                    @tbl[b] = 0 if !@tbl[b]
+                    @tbl[b] += 1
+                }
+            end
+
+            def balanceValues()
+            end
+
+            def balanceTree()
+                raise "Not implemented."
+            end
+        end
+
+
+        attr_reader :tree
+
+        def initialize(zeroLeft, reverseBitsInByte=false)
+            @tree=Huffman::Node.new()
+            @zeroLeft, @reverseBits = zeroLeft,reverseBitsInByte
+        end
+
+        def decodeTable(recalc=false)
+            if @recalc || !@decodeTbl
+                tbl = @tree.getLeafs(@zeroLeft ? '0' : '1', @zeroLeft ? '1' : '0')
+                @decodeTbl = {}
+                tbl.each{|k,v|
+                    @decodeTbl[k.length] = {} if !@decodeTbl[k.length]
+                    @decodeTbl[k.length][k.to_i(2)] = v
+                }
+            end
+            return @decodeTbl
+        end
+
+        def encodeTable(recalc=false)
+            if @recalc || !@encodeTbl
+                tbl = @tree.getLeafs(@zeroLeft ? '0' : '1', @zeroLeft ? '1' : '0')
+                @encodeTbl = {}
+                tbl.each{|k,v|
+                    @encodeTbl[v] = [k.reverse.to_i(2), k.length]
+                }
+            end
+            return @encodeTbl
+        end
+
+
+        def balancer()
+            return Huffman::Balancer.new(self)
+        end
+
+        def debug()
+            tbl=decodeTable()
+            info="---huffman table---\n"
+            bts={}
+            tbl.keys.sort.each{|sz|
+                tbl[sz].each{|k,v|
+                    fmt = "0x%02X\t%2d\t%0" + sz.to_s + "b\n"
+                    info += sprintf(fmt,v,sz,k)
+                    if not bts[v]
+                        bts[v] = 1
+                    else
+                        bts[v] += 1
+                    end
+                }
+            }
+            info += sprintf("---%d bytes---\n",bts.length)
+            for i in 0..255
+                if !bts[i]
+                    info+=sprintf("0x%02X - ABSENT\n", i)
+                else
+                    info+=sprintf("0x%02X - %d times\n", i, bts[i]) if bts[i]!=1
+                end
+            end
+            App.get().logd(info)
+        end
+
+        def revbyte(byte)
+            return byte if !@reverseBits
+            return sprintf("%08b", byte).reverse.to_i(2)
+        end
+
+        def decode(bitstream, endl=0)
+            res = ''
+            tbl = decodeTable()
+            max = tbl.keys.max
+            pos = 0
+            byte = bitstream[pos].ord
+            bytelen = 8
+            buf = 0
+            buflen = 0
+            while true
+                buf <<= 1
+                buflen += 1
+                raise "Huffman decode length overflow" if buflen>max
+                buf |= byte & 1
+                byte >>= 1
+                bytelen -= 1
+                if tbl[buflen] && tbl[buflen][buf]
+                    return res if tbl[buflen][buf] == endl
+                    res += tbl[buflen][buf].chr
+                    buf = 0
+                    buflen = 0
+                end
+
+                next if bytelen>0
+                pos += 1
+                break if pos >= bitstream.length
+                bytelen = 8
+                byte = revbyte(bitstream[pos].ord)
+            end
+            return res
+        end
+
+        def encode(bytes, endl=0)
+            if endl != nil && bytes[-1] != endl
+                bytes += endl.chr
+            end
+            res = ''
+            tbl = encodeTable()
+            byte = 0
+            bytelen = 0
+            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
+                    byte |= ((val & 1) << bytelen)
+                    val >>= 1
+                    bytelen += 1
+                    if bytelen == 8
+                        res += revbyte(byte).chr
+                        bytelen = 0
+                        byte = 0
+                    end
+                end
+            }
+            res += revbyte(byte).chr if bytelen > 0
+            return res
+        end
+
+    end
+
+end