unmangler 0.0.1 → 0.0.2

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NTJiYThhZDM5Mzk5ZWVmNTJhNDgxNDEzYTVhYzhhOTU0MjNjOTQ1Ng==
+    NTMyYTYwYzU4MDAwYWMxZmQxOTFmYzhmMjA1YjAyZmViYmJjOWJhYw==
   data.tar.gz: !binary |-
-    MWFiNWRjNGZiODgxOGNkZWQyYmJmMmM4MjNhMGZhOWRkMTVjNzMwZQ==
+    OWE2NmRhMjY2MGZkN2UxMDI4MDliYTBmZTY0NThlMDlmOWE4MDU5ZQ==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    NGIzMGJmNjg5NzlhOTVlMWNjOTkzZTJlNzdkODcyMDZhNmQwODlmNzkwZDlk
-    NmY0ZGE1MDdlYjY1MmUyZDk2YWNiZjkwMGJhZTZmZmVjM2M4ZjQ5MjhhYjQ5
-    NTVlYTRjZTc0NmMwMDc4ZjY3NWViNzUzMjhjZjRlODdlYzdlZjI=
+    NWQwNmIzN2YyN2UwYjE4OWZiY2IxMDdhNzI2YjAyOGE1YzQ4NDE3NWU5YmNi
+    NzA0NDk4ODc0NDM2MTYwZTIzNmMyZTFhYmY3ZmJkYWUwMjhlODEzNGM3OTQx
+    ODUyMDM3ODdkMzNkNmYyMGMzODEyYTA3OGY5NGMxMjJjZmMwY2Q=
   data.tar.gz: !binary |-
-    YTY0ZWQ0ZDExZWUzMGRhZWVjYmFjNGY1ZmVkZjgyNmI3ZDhkMGQ0NDk2MGQ0
-    YTFiNTJiYTg3ZWM1NjI1Y2QyMWRhZTE2MWU2MmZiOTViN2FkNTg2YjZlMDA3
-    NjA0YTBlYTM3MTcyMGYzNjVhZDYyNDhhOTgyMWMzZDBkODEyMWU=
+    NThiMGEzM2NkMTY5YWZmYzA2MTE2YjIwMzlkYjU5NzIzYzE5N2IxYzg5NzI3
+    YWVhOTQ1M2EzZWMyN2QzMmE0NTlmYzBiZjViOWE2NjUzNjIxOWRjY2U3OGQ1
+    MDcwMTM5MTJiOWM1ZjgyYTkyNDc4N2JlNzhmNWUxOTQ4N2M2Yzk=

data/.gitignore

@@ -15,3 +15,7 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+samples/*.yaml
+samples/*.yml
+/?
+/?.*

data/lib/unmangler.rb

@@ -1,19 +1,21 @@
+require 'unmangler/string_ptr'
+require 'unmangler/base'
 require 'unmangler/version'
 require 'unmangler/borland'
+require 'unmangler/msvc'
 
 module Unmangler
   class << self
     def unmangle name, args={}
-      if name[0,1] == "@"
+      if name[0] == "@"
         Unmangler::Borland.safe_unmangle name, args
         # TODO: check if result is same as input
         # and try to unmangle with MS if it is
+      elsif name[0] == '?'
+        Unmangler::MSVC.safe_unmangle name, args
       elsif name[0,2] == '_Z'
         # GCC ?
         name
-      elsif name[0,1] == '?'
-        # MS ?
-        name
       else
         # return original name
         name

data/lib/unmangler/base.rb

@@ -0,0 +1,27 @@
+module Unmangler
+  class Base
+    def isdigit c
+      c =~ /\A\d\Z/
+    end
+
+    def assert cond
+      raise unless cond
+    end
+
+    # same as 'unmangle', but catches all exceptions and returns original name
+    # if can not unmangle
+    def safe_unmangle name, *args
+      unmangle name, *args
+    rescue
+      name
+    end
+
+    def self.unmangle *args
+      new.unmangle(*args)
+    end
+
+    def self.safe_unmangle *args
+      new.safe_unmangle(*args)
+    end
+  end
+end

data/lib/unmangler/borland.rb

@@ -1,6 +1,5 @@
 #!/usr/bin/env ruby
-
-require 'unmangler/string_ptr'
+require File.expand_path("base", File.dirname(__FILE__))
 
 # ported from Embarcadero RAD Studio XE3
 # $(BDS)\source\cpprtl\Source\misc\unmangle.c
@@ -9,7 +8,7 @@ require 'unmangler/string_ptr'
 
 module Unmangler; end
 
-class Unmangler::Borland
+class Unmangler::Borland < Unmangler::Base
   attr_accessor :kind
 
   UM_UNKNOWN       = 0x00000000
@@ -57,11 +56,6 @@ class Unmangler::Borland
 
   MAXBUFFLEN = 8192 # maximum output length
 
-  # The mangler, when mangling argument types, will create
-  #   backreferences if the type has already been seen. These take the
-  #   form t?, where ? can be either 0-9, or a-z.
-
-
   # New mangle scheme lengths:
   #   len == 254 ==> old hash
   #   len == 253 ==> new MD5 hash
@@ -86,6 +80,7 @@ class Unmangler::Borland
   end
 
   def copy_char c
+    #puts "[d] copy_char #{c.inspect} from #{caller[0]}"
     @target[0] = (c == 0 ? "\x00" : c)
     @target.inc!
   end
@@ -131,11 +126,13 @@ class Unmangler::Borland
     "rand"=> "&=", "rdiv"=> "/=", "rlsh"=> "<<=","rmin"=> "-=", "rmod"=> "%=",
     "rmul"=> "*=", "ror" => "|=", "rplu"=> "+=", "rrsh"=> ">>=","rsh" => ">>",
     "rxor"=> "^=", "subs"=> "[]", "sub" => "-",  "xor" => "^",  "arow"=> "->",
-    "nwa" => "new[]", "dele"=> "delete", "dla" => "delete[]"
+    "nwa" => "new[]", "dele"=> "delete", "dla" => "delete[]",
+    # not in unmangle.c, but from IDA
+    "cctr" => "`class constructor`", "cdtr" => "`class destructor`"
   }
 
   def copy_op src
-    copy_string(OPS[src] || src)
+    copy_string(OPS[src] || "?#{src}?")
   end
 
   def copy_return_type(start, callconv, regconv, process_return)
@@ -170,7 +167,7 @@ class Unmangler::Borland
     #   string, it means the location of all the qualifier names is
     #   about to move.
 
-    unless [0,nil,false].include?(@adjust_quals)
+    if @adjust_quals
       @namebase += ret_len if @namebase
       @qualend  += ret_len if @qualend
       @prevqual += ret_len if @prevqual
@@ -182,13 +179,12 @@ class Unmangler::Borland
   def copy_type(start, arglvl)
     start = start.dup if start.is_a?(StringPtr)
 
-    tname         = nil
+    tname = buff  = nil
     c             = input()
     is_const      = false
     is_volatile   = false
     is_signed     = false
     is_unsigned   = false
-    maxloop       = 101
     savedsavechar = nil
 
     arglvl =
@@ -197,6 +193,7 @@ class Unmangler::Borland
       else true
       end
 
+    maxloop = 101
     loop do
       assert((maxloop-=1) > 0)
       case c
@@ -220,7 +217,7 @@ class Unmangler::Borland
       i = 0
 
       begin      # compute length
-          i = i * 10 + (c.ord - '0'.ord)
+          i = i*10 + c.to_i
           c = advance()
       end while isdigit(c)
 
@@ -252,9 +249,8 @@ class Unmangler::Borland
       advance()
       copy_type(@target, 0)
       len = @target - name
-      len = MAXBUFFLEN - 1 if (len > MAXBUFFLEN - 1)
-      strncpy(buff, name, len)
-      buff[len] = 0
+      #len = MAXBUFFLEN - 1 if (len > MAXBUFFLEN - 1)
+      buff = name[0,len]
       @target = name
     end
 
@@ -274,18 +270,17 @@ class Unmangler::Borland
 
     when 'C'      # C++ wide char
       c = advance()
-      if (c == 's')
+      if c == 's'
         tname = "char16_t"
-      elsif (c == 'i')
+      elsif c == 'i'
         tname = "char32_t"
       else
-        raise "Unknown type"
+        raise "Unknown wide char type: 'C#{c}'"
       end
 
     when 'M','r','h','p' # member pointer, reference, rvalue reference, pointer
       if (@savechar == 'M')
-        c = input()  # [BTS-??????]
-        case c
+        case c = input()  # [BTS-??????]
         when 'x'; is_const = true; c = advance()    # [BCB-272500]
         when 'w'; is_volatile = true; c = advance()
         end
@@ -315,7 +310,7 @@ class Unmangler::Borland
       when 'h'; append('&&')
       when 'p'; append(' *')
       when 'M'
-        assert(buff[0])
+        assert(buff)
         copy_char(' ')
         copy_string(buff)
         append '::*'
@@ -363,7 +358,7 @@ class Unmangler::Borland
       end
 
       save_adjqual = @adjust_quals
-      @adjust_quals = 0
+      @adjust_quals = false
 
       copy_char('(')
       copy_args('$', 0)
@@ -403,7 +398,7 @@ class Unmangler::Borland
   def copy_delphi4args(_end, tmplargs)
     first = true
     _begin = start = nil
-    termchar = 0
+    termchar = nil
 
     tmplargs =
       case tmplargs
@@ -438,11 +433,7 @@ class Unmangler::Borland
 
         when 'i'
           if _begin[0,5] == '4bool'
-            if input() == '0'
-                copy_string("false")
-            else
-                copy_string("true")
-            end
+            copy_string( input() == '0' ? "false" : "true" )
             advance()
             break
           else
@@ -482,13 +473,16 @@ class Unmangler::Borland
     end # while c && c != _end
   end
 
-  PEntry = Struct.new :targpos, :len
+  # The mangler, when mangling argument types, will create
+  # backreferences if the type has already been seen. These take the
+  # form t?, where ? can be either 0-9, or a-z.
+  PEntry = Struct.new :start, :len
 
   def copy_args(_end, tmplargs)
     c = input()
     first = true
     _begin = start = nil
-    scanned = 0
+    scanned = false
     param_table = []
 
     tmplargs =
@@ -497,7 +491,7 @@ class Unmangler::Borland
       else true
       end
 
-    while (c && c != _end)
+    while c && ![0, "\0", _end].include?(c)
       if first
         first = false
       else
@@ -507,42 +501,40 @@ class Unmangler::Borland
       _begin   = @source.dup
       start    = @target.dup
 
-      param_table << PEntry.new
-      param_table.last.targpos = @target.dup
-
-      scanned = 0
+      param_table << PEntry.new( @target.dup )
+      scanned = false
 
-      while (c == 'x' || c == 'w')
+      while c == 'x' || c == 'w'
         # Decode 'const'/'volatile' modifiers [BCB-265738]
         case c
         when 'x'; copy_string("const ")
         when 'w'; copy_string("volatile ")
         end
-        scanned = 1
+        scanned = true
         c = advance()
       end
 
-      if (scanned && c != 't')
+      if scanned && c != 't'
         @source = _begin.dup
       end
 
-      if (c != 't')
-        copy_type(@target, ! tmplargs)
-      else
+      if c == 't'
         c = advance()
-        ptindex = c.to_i(16) - 1
-        assert(param_table[ptindex].targpos)
+        ptindex = c.to_i(36) - 1
+        assert(param_table[ptindex].start)
         assert(param_table[ptindex].len > 0)
-        copy_string param_table[ptindex].targpos[0, param_table[ptindex].len]
+        copy_string param_table[ptindex].start[0, param_table[ptindex].len]
         advance()
+      else
+        copy_type(@target, ! tmplargs)
       end
 
-      param_table.last.len = @target - param_table.last.targpos
+      param_table.last.len = @target - param_table.last.start
 
       c = input()
 
       if (tmplargs && c == '$') # non-type template argument
-        termchar = 0
+        termchar = nil
         @target = start.dup
         c = advance()
         advance()
@@ -555,11 +547,7 @@ class Unmangler::Borland
 
           when 'i'
             if _begin[0,5] == "4bool"
-              if (input() == '0')
-                copy_string("false")
-              else
-                copy_string("true")
-              end
+              copy_string( input() == '0' ? "false" : "true" )
               advance()
               break
             end
@@ -567,7 +555,7 @@ class Unmangler::Borland
 
           when 'j','g','e'
             copy_until('$')
-            copy_char(termchar) if (termchar)
+            copy_char(termchar) if termchar
             break
 
           when 'm'
@@ -615,7 +603,7 @@ class Unmangler::Borland
     # name from a template argument, for example.
 
     save_setqual = @set_qual
-    @set_qual = 0
+    @set_qual = false
 
     if isDelphi4name
       copy_delphi4args(TMPLCODE, 1)
@@ -633,27 +621,16 @@ class Unmangler::Borland
     advance()
   end
 
-  def isdigit c
-    c =~ /\A\d\Z/
-  end
-
-  def assert cond
-    unless cond
-#      puts
-#      puts
-#      p @source
-#      p @source[0..-1]
-#      puts
-#      p @target
-#      puts
-      raise
-    end
-  end
-
   def copy_name tmplname
     start = save_setqual = nil
     c = input()
 
+    tmplname =
+      case tmplname
+      when 0, nil, false; false
+      else true
+      end
+
     # Start outputting the qualifier names and the base name.
 
     while true
@@ -715,7 +692,7 @@ class Unmangler::Borland
           end
 
         when ARGLIST    # special name, or arglist
-          return unless [0,nil,false].include?(tmplname)
+          return if tmplname
 
           c = advance()
           if c == 'x'
@@ -766,7 +743,7 @@ class Unmangler::Borland
             advance()
             copy_string("operator ")
             save_setqual = @set_qual
-            @set_qual = 0
+            @set_qual = false
             copy_type(@target, 0)
             @set_qual = save_setqual
             assert(input() == ARGLIST)
@@ -902,8 +879,13 @@ class Unmangler::Borland
   #     will be unmangled, and not the arguments.
 
   def unmangle src, args = {}
+    # all Borland mangled names start with '@' character.
     return src if !src || src.empty? || src[0] != '@'
 
+    # check for Microsoft compatible fastcall names, which are of the form:
+    # @funcName@<one or more digits indicating size of all parameters>
+    return src if src =~ /\A@.*@\d+\Z/
+
     # unmangle args? defaulting to true
     doArgs = args.fetch(:args, true)
 
@@ -927,19 +909,16 @@ class Unmangler::Borland
 
     @savechar = 0
 
-    # All mangled names start with '@' character.
-
     src = src[1..-1] # skip initial '@'
 
-    # check for Microsoft compatible fastcall names, which are of the form:
-    # @funcName@<one or more digits indicating size of all parameters>
-    return src if src =~ /\A@.*@\d+\Z/
-
-    # Pascal names can not contain lowercase letters
-    if src !~ /[a-z]/
-      # convert uppercase Pascal names to lowercase
-      src.downcase!
-    end
+# ZZZ XXX not sure if it's needed now
+#    if src[/[a-z]/]
+#      # contains lowercase letters => not Pascal
+#      # b/c Pascal names can not contain lowercase letters
+#    else
+#      # Pascal, convert uppercase Pascal names to lowercase
+#      src.downcase!
+#    end
 
     # This is at LEAST a member name, if not a fully mangled template
     # or function name. So, begin outputting the subnames. We set up
@@ -950,14 +929,14 @@ class Unmangler::Borland
     @source_string = src
     @source    = StringPtr.new(@source_string)
     @prevqual  = @qualend = @base_name = @base_end = nil
-    @set_qual  = 1
+    @set_qual  = true
 
     # Start outputting the qualifier names and the base name.
 
     @namebase = @target.dup
 
     copy_name(0)
-    @set_qual = 0
+    @set_qual = false
     @base_end = @target.dup
 
     if (@kind & UM_KINDMASK) == UM_TPDSC || (@kind & UM_SPECMASK) != 0
@@ -966,25 +945,17 @@ class Unmangler::Borland
       @namebase = p + 1
     end
 
-    if (@kind & UM_KINDMASK) == UM_CONSTRUCTOR || (@kind & UM_KINDMASK) == UM_DESTRUCTOR
-      start = nil
-
-      if (@kind & UM_KINDMASK) == UM_DESTRUCTOR
-        copy_char('~')
-      end
+    if [UM_CONSTRUCTOR,UM_DESTRUCTOR].include?( @kind & UM_KINDMASK )
+      copy_char('~') if @kind & UM_KINDMASK == UM_DESTRUCTOR
 
-      if !@qualend
+      if @qualend
+        start = @prevqual ? (@prevqual+2) : @namebase.dup
+        len = @qualend - start
+        copy_string(start, len)
+      else
         # It's a bcc-created static constructor??
         # give it a name.
         copy_string("unknown")
-      else
-        if !@prevqual
-            start = @namebase.dup
-        else
-            start = @prevqual + 2
-        end
-        len = @qualend - start
-        copy_string(start, len)
       end
     end
 
@@ -998,8 +969,8 @@ class Unmangler::Borland
       # Output the function parameters, and return type in the case
       #   of template function specializations.
 
-      @set_qual = 0
-      @adjust_quals = 1
+      @set_qual = false
+      @adjust_quals = true
 
       copy_type(@namebase, 0)
 
@@ -1019,6 +990,9 @@ class Unmangler::Borland
       @kind |= UM_QUALIFIED
     end
 
+    # trim unwanted result tail, if any
+    @target[0..-1] = ''
+
     # If the user wanted the qualifier and base name saved, then do it now.
 
     # TODO
@@ -1050,37 +1024,29 @@ class Unmangler::Borland
       @result.sub! /\A__tpdsc__ /,''
     end
 
-    @result
-  end
-
-  # same as 'unmangle', but catches all exceptions and returns original name
-  # if can not unmangle
-  def safe_unmangle name, *args
-    unmangle name, *args
-  rescue
-    name
-  end
+    # copy IDA syntax for class ctor/dtor:
+    #   was: Classes::TThread::operator `class destructor`()
+    #   now: Classes::TThread::`class destructor`()
+    @result.sub! '::operator `class', '::`class'
 
-  def self.unmangle *args
-    new.unmangle(*args)
+    @result
   end
 
-  def self.safe_unmangle *args
-    new.safe_unmangle(*args)
-  end
 end # class Unmangler
 
 ###################################################################
 
 if $0 == __FILE__
+  $:.unshift("./lib")
+  require 'unmangler/string_ptr'
   require 'awesome_print'
   require 'pp'
 
-  def check src, want, do_args = true
+  def check src, want, args = {}
     u = Unmangler::Borland.new
     got = nil
     begin
-      got = u.unmangle(src, do_args)
+      got = u.unmangle(src, args)
     rescue
       pp u
       raise
@@ -1088,14 +1054,21 @@ if $0 == __FILE__
     if got == want
       print ".".green
     else
-      puts "[!] want: #{want.inspect}"
-      puts "[!]  got: #{got.inspect}"
-      pp u
       puts
+      puts "[!]  src: #{src.inspect.gray}"
+      puts "[!] want: #{want.inspect.yellow}"
+      puts "[!]  got: #{got.inspect.red}"
+      puts
+      pp u
       exit 1
     end
   end
 
+  if ARGV.any?
+    check ARGV[0], ARGV[1]
+    exit
+  end
+
   check "@afunc$qxzcupi",   "afunc(const signed char, int *)"
   check "@foo$qpqfi$d",     "foo(double (*)(float, int))"
   check "@myclass@func$qil","myclass::func(int, long)"
@@ -1133,8 +1106,16 @@ if $0 == __FILE__
   check "@Dbcommon@GetTableNameFromSQLEx$qqrx17System@WideString25Dbcommon@IDENTIFIEROption",
     "__fastcall Dbcommon::GetTableNameFromSQLEx(const System::WideString, Dbcommon::IDENTIFIEROption)"
 
-#  check "@Sysutils@Supports$qqrx45System@_DelphiInterface$t17System@IInterface_rx5_GUIDpv",
-#    "__fastcall Sysutils::Supports(const System::DelphiInterface<System::IInterface>, _GUID const &, void *)"
+  check "@$xt$p27System@%AnsiStringT$us$i0$%", "__tpdsc__ System::AnsiStringT<0> *"
+
+  check "@Adomcore_4_3@TDomNamedNodeMap@$bctr$qqrpx21Adomcore_4_3@TDomNodepx13Classes@TListx54System@%Set$t25Adomcore_4_3@TDomNodeType$iuc$0$iuc$11%xo",
+    "__fastcall Adomcore_4_3::TDomNamedNodeMap::TDomNamedNodeMap(Adomcore_4_3::TDomNode *, Classes::TList *, const System::Set<Adomcore_4_3::TDomNodeType, 0, 11>, const bool)"
+
+  check '@ATL@%CComObjectRootEx$25ATL@CComSingleThreadModel%@$bctr$qv',
+    "ATL::CComObjectRootEx<ATL::CComSingleThreadModel>::CComObjectRootEx<ATL::CComSingleThreadModel>()"
+
+  check '@Classes@TThread@$bcdtr$qqrv',    '__fastcall Classes::TThread::`class destructor`()'
+  check '@Timespan@TTimeSpan@$bcctr$qqrv', '__fastcall Timespan::TTimeSpan::`class constructor`()'
 
   ####################################
   # w/o args
@@ -1142,11 +1123,11 @@ if $0 == __FILE__
 
   check "@Dbcommon@GetTableNameFromSQLEx$qqrx17System@WideString25Dbcommon@IDENTIFIEROption",
     "Dbcommon::GetTableNameFromSQLEx",
-    false
+    :args => false
 
   check "@std@%vector$51boost@archive@detail@basic_iarchive_impl@cobject_id69std@%allocator$51boost@archive@detail@basic_iarchive_impl@cobject_id%%@$bsubs$qui",
     "std::vector<boost::archive::detail::basic_iarchive_impl::cobject_id, std::allocator<boost::archive::detail::basic_iarchive_impl::cobject_id> >::operator []",
-    false
+    :args => false
 
   puts
 end