チェンジセット 412

差分発生行の前後
無視リスト:
コミット日時:
2008/05/17 00:18:54 (7 ヶ月前)
コミッタ:
yossy
ログメッセージ:

Added ClassPrinter? to ByteCodeDisassembler?.

ファイル:

凡例:

変更無し
追加
削除
更新
コピー
移動
  • as3/ByteCodeDisassembler/ByteCodeDisassembler.as

    r299 r412  
    22{ 
    33        import flash.display.Sprite; 
     4        import flash.errors.EOFError; 
     5        import flash.events.Event; 
     6        import flash.events.IOErrorEvent; 
    47        import flash.net.URLRequest; 
    58        import flash.net.URLStream; 
    6         import flash.events.Event; 
    79        import flash.utils.ByteArray; 
     10         
    811        import org.libspark.disassemble.SwfStream; 
    9         import flash.events.IOErrorEvent; 
    10         import flash.errors.EOFError; 
    11         import org.libspark.disassemble.abc.AbcParser; 
     12        import org.libspark.disassemble.abc.ClassPrinter; 
    1213         
    1314        public class ByteCodeDisassembler extends Sprite 
     
    2425                        /** 
    2526                        'C:\\DataFiles\\Projects\\Spark\\asunit\\as3\\dev\\bin\\asunit_dev.swf' 
     27                        /** 
     28                        'C:\\DataFiles\\Spike\\flex\\ByteCode\\bin\\ByteCode-debug.swf' 
    2629                        /**/ 
    27                         'C:\\DataFiles\\Spike\\flex\\ByteCode\\bin\\ByteCode-debug.swf' 
     30                        '/Users/yossy/DataFiles/Work/Astro/playerglobal/library.swf' 
    2831                        /**/ 
    2932                        ; 
     
    5861                                                        for (; swf.readByte() != 0x00; ) { 
    5962                                                        } 
    60                                                         trace('frame(' + frame + ')'); 
     63                                                        // trace('frame(' + frame + ')'); 
    6164                                                        var abcBytes:ByteArray = new ByteArray(); 
    6265                                                        swf.readBytes(abcBytes, 0, length - (swf.position - tagStart)); 
    63                                                         new AbcParser(abcBytes).parse(); 
     66                                                        // new AbcParser(abcBytes).parse(); 
     67                                                        new ClassPrinter(abcBytes).parse(); 
    6468                                                } 
    6569                                                break; 
     
    7377                        } 
    7478                        catch (e:VerifyError) { 
    75                                 trace(e); 
     79                                trace(e.getStackTrace()); 
    7680                        } 
    7781                        catch (e:EOFError) { 
  • as3/ByteCodeDisassembler/org/libspark/disassemble/ByteStream.as

    r299 r412  
    3434                public function readU32():uint 
    3535                { 
    36                         var result:uint = 0; 
    37                         var byte:uint = readU8(); 
    38                         result |= byte & 0x7f; 
    39                         var shift:uint = 0; 
    40                         while ((byte & 0x80) != 0x00) { 
    41                                 byte = readU8(); 
    42                                 ++shift; 
    43                                 result |= (byte & 0x7f) << (7 * shift); 
     36                        var result:uint = readU8(); 
     37                        if ((result & 0x00000080) == 0) { 
     38                                return result; 
    4439                        } 
    45                         return result; 
     40                        result = (result & 0x0000007f) | readU8() << 7; 
     41                        if ((result & 0x00004000) == 0) { 
     42                                return result; 
     43                        } 
     44                        result = (result & 0x00003fff) | readU8() << 14; 
     45                        if ((result & 0x00200000) == 0) { 
     46                                return result; 
     47                        } 
     48                        result = (result & 0x001fffff) | readU8() << 21; 
     49                        if ((result & 0x10000000) == 0) { 
     50                                return result; 
     51                        } 
     52                        return (result & 0x0fffffff) | readU8() << 28; 
    4653                } 
    4754                 
  • as3/ByteCodeDisassembler/org/libspark/disassemble/abc/AbcParser.as

    r299 r412  
    9696                                        for (p = 0; p < paramCount; ++p) { 
    9797                                                params[p] = constantPool.getString(paramNames[p]) + ':' +  
    98                                                         (paramTypes[p] != 0 ? constantPool.getQName(paramTypes[p]) : '*'); 
     98                                                        (paramTypes[p] != 0 ? constantPool.getMultiName(paramTypes[p]) : '*'); 
    9999                                        } 
    100100                                } 
     
    102102                                        for (p = 0; p < paramCount; ++p) { 
    103103                                                params[p] = '$' + p + ':' +  
    104                                                         (paramTypes[p] != 0 ? constantPool.getQName(paramTypes[p]) : '*'); 
     104                                                        (paramTypes[p] != 0 ? constantPool.getMultiName(paramTypes[p]) : '*'); 
    105105                                        } 
    106106                                } 
     
    124124                                buf += '(' + params.join(',') + ')'; 
    125125                                if (type != 0) { 
    126                                         buf += ':' + constantPool.getQName(type); 
     126                                        buf += ':' + constantPool.getMultiName(type); 
    127127                                } 
    128128                                else { 
     
    135135                                for each (var paramType:uint in paramTypes) { 
    136136                                        if (paramType != 0) { 
    137                                                 buf += 'type(' + constantPool.getQName(paramType) + ')'; 
     137                                                buf += 'type(' + constantPool.getMultiName(paramType) + ')'; 
    138138                                        } 
    139139                                        else { 
     
    143143                                buf += ')'; 
    144144                                if (type != 0) { 
    145                                         buf += 'return(' + constantPool.getQName(type) + ')' 
     145                                        buf += 'return(' + constantPool.getMultiName(type) + ')' 
    146146                                } 
    147147                                else { 
     
    198198                                var name:uint = stream.readU32(); 
    199199                                var kind:uint = stream.readU8(); 
    200                                 var slotID:uint = stream.readU32(); 
    201200                                var tag:uint = kind & 0x0f; 
    202                                 var flags:uint = tag >>> 4; 
    203                                 buf += "\n" + '  ' + i + ':name(' + constantPool.getFixQName(name) + ')tag('; 
     201                                var flags:uint = kind >>> 4; 
     202                                buf += "\n" + '  ' + i + ':name(' + name + ':' + constantPool.getMultiName(name) + ')tag('; 
    204203                                switch (tag) { 
    205204                                        case 0: // var 
     
    210209                                                } 
    211210                                                buf += ')'; 
     211                                                var slotID:uint = stream.readU32(); 
    212212                                                var typeId:uint = stream.readU32(); 
    213213                                                var valueId:uint = stream.readU32(); 
    214                                                 buf += 'slot(' + slotID + ')type(' + constantPool.getQName(typeId) + ')'; 
     214                                                buf += 'slot(' + slotID + ')type(' + constantPool.getMultiName(typeId) + ')'; 
    215215                                                if (valueId != 0) { 
    216                                                         var valueKind:uint = stream.readU32(); 
     216                                                        var valueKind:uint = stream.readU8(); 
    217217                                                        buf += 'value(' + constantPool.getValue(valueId, valueKind) + ')'; 
    218218                                                } 
     
    232232                                                buf += ((flags & 1) != 0 ? 'final' : 'virtual') + ':'; 
    233233                                                buf += ((flags & 2) != 0 ? 'override' : 'new') + ')'; 
     234                                                var dispID:uint = stream.readU32(); 
    234235                                                var methodInfo:uint = stream.readU32(); 
    235                                                 buf += 'display(' + slotID + ')info(' + methodInfo + ')'; 
     236                                                buf += 'display(' + dispID + ')info(' + methodInfo + ')'; 
    236237                                                break; 
    237238                                        case 4: // class 
    238239                                                buf += 'class)'; 
     240                                                var slotID:uint = stream.readU32(); 
    239241                                                var classId:uint = stream.readU32(); 
    240242                                                buf += 'slot(' + slotID + ')class(' + classId + ')'; 
     
    242244                                        case 5: // function 
    243245                                                buf += 'func)'; 
     246                                                var slotID:uint = stream.readU32(); 
    244247                                                var methodInfo:uint = stream.readU32(); 
    245248                                                buf += 'slot(' + slotID + ')?(' + methodInfo + ')'; 
    246249                                                break; 
    247250                                        default: 
     251                                                buf += tag + ')'; 
    248252                                                break; 
    249253                                } 
     
    283287                                if (isInterface) flagList.push('interface'); 
    284288                                var hasProtected:Boolean = (flags & 8) != 0; 
    285                                 buf += 'name(' + constantPool.getQName(name) + ')super(' + constantPool.getQName(superName) + ')'; 
     289                                buf += 'name(' + constantPool.getMultiName(name) + ')super(' + constantPool.getMultiName(superName) + ')'; 
    286290                                buf += 'flags(' + flagList.join(':') + ')'; 
    287291                                if (hasProtected) { 
    288292                                        var protectedNamespace:uint = stream.readU32(); 
    289                                         buf += 'protected(' + constantPool.getNamespaceName(protectedNamespace) + ')'; 
     293                                        buf += 'protected(' + constantPool.getNamespace(protectedNamespace) + ')'; 
    290294                                } 
    291295                                buf += '))'; 
     
    440444                                            break; 
    441445                                        case 34: 
    442                                             pushCode('PushConstant', cp.getGeneralMultiName(stream.readU32())); 
     446                                            pushCode('PushConstant', cp.getMultiName(stream.readU32())); 
    443447                                            break; 
    444448                                        case 44: 
     
    446450                                            break; 
    447451                                        case 49: 
    448                                             pushCode('PushNamespace', cp.getNamespaceName(stream.readU32())); 
     452                                            pushCode('PushNamespace', cp.getNamespace(stream.readU32())); 
    449453                                            break; 
    450454                                        case 46: 
     
    500504                                            break; 
    501505                                        case 69: 
    502                                             pushCode('CallSuper', cp.getGeneralMultiName(stream.readU32()), 'argc:' + stream.readU32()); 
     506                                            pushCode('CallSuper', cp.getMultiName(stream.readU32()), 'argc:' + stream.readU32()); 
    503507                                            break; 
    504508                                        case 73: 
     
    506510                                            break; 
    507511                                        case 70: 
    508                                             pushCode('CallProperty', cp.getGeneralMultiName(stream.readU32()), 'argc:' + stream.readU32()); 
     512                                            pushCode('CallProperty', cp.getMultiName(stream.readU32()), 'argc:' + stream.readU32()); 
    509513                                            break; 
    510514                                        case 76: 
    511                                             pushCode('CallPropertyLex', cp.getGeneralMultiName(stream.readU32()), 'argc:' + stream.readU32()); 
     515                                            pushCode('CallPropertyLex', cp.getMultiName(stream.readU32()), 'argc:' + stream.readU32()); 
    512516                                            break; 
    513517                                        case 74: 
    514                                             pushCode('ConstructProperty', cp.getGeneralMultiName(stream.readU32()), 'argc:' + stream.readU32()); 
     518                                            pushCode('ConstructProperty', cp.getMultiName(stream.readU32()), 'argc:' + stream.readU32()); 
    515519                                            break; 
    516520                                        case 78: 
    517                                                 pushCode('CallSuperVoid', cp.getGeneralMultiName(stream.readU32()), 'argc:' + stream.readU32()); 
     521                                                pushCode('CallSuperVoid', cp.getMultiName(stream.readU32()), 'argc:' + stream.readU32()); 
    518522                                                break; 
    519523                                        case 79: 
    520                                                 pushCode('CallPropertyVoid', cp.getGeneralMultiName(stream.readU32()), 'argc:' + stream.readU32()); 
     524                                                pushCode('CallPropertyVoid', cp.getMultiName(stream.readU32()), 'argc:' + stream.readU32()); 
    521525                                                break; 
    522526                                        case 71: 
     
    575579                                            break; 
    576580                                        case 102: 
    577                                             pushCode('GetProperty', cp.getGeneralMultiName(stream.readU32())); 
     581                                            pushCode('GetProperty', cp.getMultiName(stream.readU32())); 
    578582                                            break; 
    579583                                        case 4: 
    580                                             pushCode('GetSuper', cp.getGeneralMultiName(stream.readU32())); 
     584                                            pushCode('GetSuper', cp.getMultiName(stream.readU32())); 
    581585                                            break; 
    582586                                        case 89: 
    583                                             pushCode('GetDescendants', cp.getGeneralMultiName(stream.readU32())); 
     587                                            pushCode('GetDescendants', cp.getMultiName(stream.readU32())); 
    584588                                            break; 
    585589                                        case 91: 
     
    587591                                            break; 
    588592                                        case 106: 
    589                                             pushCode('DeleteProperty', cp.getGeneralMultiName(stream.readU32())); 
     593                                            pushCode('DeleteProperty', cp.getMultiName(stream.readU32())); 
    590594                                            break; 
    591595                                        case 97: 
    592                                             pushCode('SetProperty', cp.getGeneralMultiName(stream.readU32())); 
     596                                            pushCode('SetProperty', cp.getMultiName(stream.readU32())); 
    593597                                            break; 
    594598                                        case 104: 
    595                                             pushCode('InitProperty', cp.getGeneralMultiName(stream.readU32())); 
     599                                            pushCode('InitProperty', cp.getMultiName(stream.readU32())); 
    596600                                            break; 
    597601                                        case 5: 
    598                                             pushCode('SetSuper', cp.getGeneralMultiName(stream.readU32())); 
     602                                            pushCode('SetSuper', cp.getMultiName(stream.readU32())); 
    599603                                            break; 
    600604                                        case 28: 
     
    650654                                            break; 
    651655                                        case 128: 
    652                                             pushCode('Coerce', cp.getGeneralMultiName(stream.readU32())); 
     656                                            pushCode('Coerce', cp.getMultiName(stream.readU32())); 
    653657                                            break; 
    654658                                        case 129: 
     
    671675                                            break; 
    672676                                        case 134: 
    673                                             pushCode('AsType', cp.getGeneralMultiName(stream.readU32())); 
     677                                            pushCode('AsType', cp.getMultiName(stream.readU32())); 
    674678                                            break; 
    675679                                        case 135: 
     
    755759                                                break; 
    756760                                        case 6: 
    757                                                 pushCode('DefaultXMLNamespace', cp.getGeneralMultiName(stream.readU32())); 
     761                                                pushCode('DefaultXMLNamespace', cp.getMultiName(stream.readU32())); 
    758762                                                break; 
    759763                                        case 7: 
     
    789793                                                break; 
    790794                                        case 94: 
    791                                                 pushCode('FindProperty', cp.getGeneralMultiName(stream.readU32())); 
     795                                                pushCode('FindProperty', cp.getMultiName(stream.readU32())); 
    792796                                                break; 
    793797                                        case 93: 
    794                                                 pushCode('FindPropertyStrict', cp.getGeneralMultiName(stream.readU32())); 
     798                                                pushCode('FindPropertyStrict', cp.getMultiName(stream.readU32())); 
    795799                                                break; 
    796800                                        case 95: 
    797                                                 pushCode('FindDef', cp.getGeneralMultiName(stream.readU32())); 
     801                                                pushCode('FindDef', cp.getMultiName(stream.readU32())); 
    798802                                                break; 
    799803                                        case 96: 
    800                                                 pushCode('GetLex', cp.getGeneralMultiName(stream.readU32())); 
     804                                                pushCode('GetLex', cp.getMultiName(stream.readU32())); 
    801805                                                break; 
    802806                                        case 179: 
     
    804808                                                break; 
    805809                                        case 178: 
    806                                                 pushCode('IsType', cp.getGeneralMultiName(stream.readU32())); 
     810                                                pushCode('IsType', cp.getMultiName(stream.readU32())); 
    807811                                                break; 
    808812                                        case 180: 
     
    836840                                                pushCode('TimeStamp'); 
    837841                                                break; 
     842                                        case 83: 
     843                                                pushCode('ApplyType'); 
     844                                                break; 
    838845                                        default: 
    839846                                                pushCode('Code:' + opCode); 
  • as3/ByteCodeDisassembler/org/libspark/disassemble/abc/ConstantPool.as

    r299 r412  
    124124                                        case 18: 
    125125                                                break; 
     126                                        case 29: 
     127                                                input.readU32(); 
     128                                                var l:uint = input.readU32(); 
     129                                                for (var ti:uint = 0; ti < l; ++ti) { 
     130                                                        input.readU32(); 
     131                                                } 
     132                                                break; 
    126133                                        default: 
    127134                                                throw new VerifyError('Invalid constant type:' + kind); 
     
    182189                } 
    183190                 
    184                 public function getNamespaceName(index:uint):String 
    185                 { 
    186                         if (index == 0) { 
    187                                 return null; 
    188                         } 
    189                         var pos:uint = namespaceIndices[index]; 
    190                         var current:uint = input.position; 
    191                         input.seek(pos); 
    192                         var kind:uint = input.readU8(); 
    193                         var value:String; 
    194                         switch (kind) { 
    195                                 case 5: 
    196                                 case 8: 
    197                                 case 22: 
    198                                 case 23: 
    199                                 case 24: 
    200                                 case 25: 
    201                                 case 26: 
    202                                         value = getString(input.readU32()); 
    203                                         break; 
    204                                 default: 
    205                                         throw new VerifyError('constant pool index ' + index + ' is not a Namespace type.'); 
    206                         } 
    207                         input.seek(current); 
    208                         return value; 
    209                 } 
    210                  
    211                 public function getFixNamespaceName(index:uint):String 
     191                public function getNamespace(index:uint):NS 
    212192                { 
    213193                        if (index == 0) { 
     
    230210                                        break; 
    231211                                case 26: // Static Protected Namespace 
    232                                         value = 'static::protected'; 
     212                                        value = 'static.protected'; 
    233213                                        break; 
    234214                                case 22: // Package Namespace 
     
    243223                        } 
    244224                        var name:String = getString(input.readU32()); 
    245                         if (name != null && name != '') { 
    246                                 if (value.length) { 
    247                                         value = value + '::' + name; 
    248                                 } 
    249                                 else { 
    250                                         value = name; 
    251                                 } 
    252                         } 
    253                         input.seek(current); 
    254                         return value; 
     225                        input.seek(current); 
     226                        return new NS(value, name); 
    255227                } 
    256228                 
     
    266238                        var value:Array = new Array(count); 
    267239                        for (var i:uint = 0; i < count; ++i) { 
    268                                 value[i] = getNamespaceName(input.readU32()); 
    269                         } 
    270                         input.seek(current); 
    271                         return value; 
    272                 } 
    273                  
    274                 public function getQName(index:uint):QName 
    275                 { 
    276                         if (index == 0) { 
    277                                 return null; 
    278                         } 
    279                         var pos:uint = multinameIndices[index]; 
    280                         var current:uint = input.position; 
    281                         input.seek(pos); 
    282                         var kind:uint = input.readU8(); 
    283                         var value:QName; 
    284                         switch (kind) { 
    285                                 case 7:  // QName (hoge) 
    286                                 case 13: // QName Attribute (@hoge) 
    287                                         var namespaceIndex:uint = input.readU32(); 
    288                                         var nameIndex:uint = input.readU32(); 
    289                                         value = createQName(getNamespaceName(namespaceIndex), getString(nameIndex)); 
    290                                         break; 
    291                                 default: 
    292                                         throw new VerifyError('constant pool index ' + index + ' is not a QName type.'); 
    293                         } 
    294                         input.seek(current); 
    295                         return value; 
    296                 } 
    297                  
    298                 public function getFixQName(index:uint):QName 
    299                 { 
    300                         if (index == 0) { 
    301                                 return null; 
    302                         } 
    303                         var pos:uint = multinameIndices[index]; 
    304                         var current:uint = input.position; 
    305                         input.seek(pos); 
    306                         var kind:uint = input.readU8(); 
    307                         var value:QName; 
    308                         switch (kind) { 
    309                                 case 7:  // QName (hoge) 
    310                                 case 13: // QName Attribute (@hoge) 
    311                                         var namespaceIndex:uint = input.readU32(); 
    312                                         var nameIndex:uint = input.readU32(); 
    313                                         value = createQName(getFixNamespaceName(namespaceIndex), getString(nameIndex)); 
    314                                         break; 
    315                                 default: 
    316                                         throw new VerifyError('constant pool index ' + index + ' is not a QName type.'); 
    317                         } 
    318                         input.seek(current); 
    319                         return value; 
    320                 } 
    321                  
    322                 public function getMultiName(index:uint):MultiName 
    323                 { 
    324                         if (index == 0) { 
    325                                 return null; 
    326                         } 
    327                         var pos:uint = multinameIndices[index]; 
    328                         var current:uint = input.position; 
    329                         input.seek(pos); 
    330                         var kind:uint = input.readU8(); 
    331                         var value:MultiName; 
    332                         switch (kind) { 
    333                                 case 9:  // Multiname (hoge) 
    334                                 case 14: // Multiname Attribute (@hoge) 
    335                                         var name:String = getString(input.readU32()); 
    336                                         var namespaces:Array = getNamespaceSet(input.readU32()); 
    337                                         value = createMultiName(name, namespaces); 
    338                                         break; 
    339                                 default: 
    340                                         throw new VerifyError('constant pool index ' + index + ' is not a MultiName type.'); 
    341                         } 
    342                         input.seek(current); 
    343                         return value; 
    344                 } 
    345                  
    346                 public function getGeneralMultiName(index:uint):* 
     240                                value[i] = getNamespace(input.readU32()); 
     241                        } 
     242                        input.seek(current); 
     243                        return value; 
     244                } 
     245                 
     246                public function getMultiName(index:uint):* 
    347247                { 
    348248                        if (index == 0) { 
     
    358258                                        var namespaceIndex:uint = input.readU32(); 
    359259                                        var nameIndex:uint = input.readU32(); 
    360                                         var valueQName:QName = createQName(getNamespaceName(namespaceIndex), getString(nameIndex)); 
     260                                        var valueQName:MultiName = createQName(getNamespace(namespaceIndex), getString(nameIndex)); 
    361261                                        input.seek(current); 
    362262                                        return valueQName; 
     263                                case 29: 
     264                                        var mn:MultiName = getMultiName(input.readU32()); 
     265                                        var l:uint = input.readU32(); 
     266                                        var paramTypes:Array = new Array(l); 
     267                                        for (var ti:uint = 0; ti < l; ++ti) { 
     268                                                paramTypes[ti] = getMultiName(input.readU32()); 
     269                                        } 
     270                                        var mnt:MultiName = createMultiName(mn.name, mn.namespaces, paramTypes); 
     271                                        input.seek(current); 
     272                                        return mnt; 
    363273                                case 9:  // Multiname (hoge) 
    364274                                case 14: // Multiname Attribute (@hoge) 
     
    387297                                default: 
    388298                                        input.seek(current); 
    389                                         throw new VerifyError('constant pool index ' + index + ' is not a QName type.'); 
     299                                        throw new VerifyError('constant pool index ' + index + ' is not a QName type (' + kind + ').'); 
    390300                        } 
    391301                } 
     
    405315                                case 6:  // Constant Double 
    406316                                        return getDouble(index); 
    407                                 case 7:  // QName 
    408                                 case 13: // QName Attribute 
    409                                         return getQName(index); 
    410317                                case 5:  // Private Namespace 
    411318                                case 8:  // Namespace 
     
    415322                                case 25: 
    416323                                case 26: // Static Protected Namespace 
    417                                         return getNamespaceName(index); 
     324                                        return getNamespace(index); 
     325                                case 7:  // QName 
     326                                case 13: // QName Attribute 
     327                                case 29: // TypeName 
    418328                                case 9:  // Multiname 
    419329                                case 14: // Multiname Attribute 
     330                                case 15: // Runtime QName 
     331                                case 16: // Runtime QName Attribute 
    420332                                        return getMultiName(index); 
    421333                                case 10: // Constant False 
     
    425337                                case 12: // Constant Null 
    426338                                        return null; 
    427                                 case 15: // Runtime QName 
    428                                 case 16: // Runtime QName Attribute 
    429                                         return getGeneralMultiName(index); 
    430339                                case 17: // Runtime QName Late 
    431340                                        return 'RuntimeQNameLate'; 
     
    443352                } 
    444353                 
    445                 private function createQName(namespace:String, name:String):QName 
    446                 { 
    447                         return new QName(new Namespace(namespace), name); 
    448                 } 
    449                  
    450                 private function createMultiName(name:String, namespaces:Array):MultiName 
    451                 { 
    452                         return new MultiName(name, namespaces); 
     354                private function createQName(ns:NS, name:String):MultiName 
     355                { 
     356                        return createMultiName(name, [ns]); 
     357                } 
     358                 
     359                private function createMultiName(name:String, namespaces:Array, typeParams:Array = null):MultiName 
     360                { 
     361                        return new MultiName(name, namespaces, typeParams); 
    453362                } 
    454363        } 
  • as3/ByteCodeDisassembler/org/libspark/disassemble/abc/MultiName.as

    r299 r412  
    33    &nb