Files
dmcallis 65a0592776 Initial source code drop
Source code drop for the Actionscript virtual machine in the Adobe
Flash Player for December 2013
2013-12-02 16:04:04 -08:00

449 lines
18 KiB
ActionScript

/* -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*- */
/* vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
package abc
{
import avmplus.File
import flash.utils.ByteArray
import flash.utils.Dictionary
import abc.Constants;
import abc.Types.ABCFile
import abc.Types.Exception
import abc.Types.Pool
import abc.Types.MethodInfo
import abc.Types.MethodBody
import abc.Types.ScriptInfo
import abc.Types.Traits
import abc.Types.Trait
import abc.Types.ConstantMultiname
import abc.Types.ConstantNamespace
import abc.Types.ConstantNamespaceSet
import abc.Types.InstanceInfo
import abc.Types.ClassInfo
import IndentingPrinter;
import ByteArrayPrinter;
import TablePrinter;
import IPrinter;
public final class AbcAPIWriter extends AbcAS3Traversal
{
public function AbcAPIWriter(abcfile:ABCFile)
{
super(abcfile)
dumpedMethods = new Dictionary();
currentQualifier = "";
}
private var printer:IndentingPrinter
private var dumpedMethods : Object;
private var currentQualifier : String;
static private var identifierRegEx : RegExp = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/;
private function isVisibleNamespace(ns : ConstantNamespace) : Boolean
{
return ns.kind != Constants.CONSTANT_PrivateNs;
}
private function qnameToString(ns : ConstantNamespace, n : String) : String
{
return ((ns == null) || (ns.uriString.length == 0) ? "" : ns.uriString + "::") + n;
}
private function nssetToString(nsSet : ConstantNamespaceSet) : String
{
var s:String = ""
try
{
for each (var ns:ConstantNamespace in nsSet.constantNamespaces) {
if (ns.kind != Constants.CONSTANT_PrivateNs)
s += (ns.uriString + ", ")
else
s += "private, "
}
return "{" + s + "}";
}
catch(e : *)
{
for each (var foo : * in nsSet.namespaces) {
trace(foo)
}
throw e;
}
return null;
}
private function nameToString(n : ConstantMultiname) : String
{
if (n.isAny)
return "*"
var nsset : ConstantNamespaceSet;
switch(n.kind) {
case Constants.CONSTANT_Qname:
case Constants.CONSTANT_QnameA:
return qnameToString(abcfile.getNamespace(n.ns_index), abcfile.getString(n.name_index));
break
case Constants.CONSTANT_Multiname:
case Constants.CONSTANT_MultinameA:
nsset = abcfile.getNamespaceSet(n.nsset_index)
if (nsset.namespaces.length == 1)
return qnameToString(abcfile.getNamespace(nsset.namespaces[0]), abcfile.getString(n.name_index))
else
return (nsset == null ? "" : nssetToString(nsset) + "::") + abcfile.getString(n.name_index)
break
case Constants.CONSTANT_RTQname:
case Constants.CONSTANT_RTQnameA:
return "<error> " + n.toString()
break
case Constants.CONSTANT_MultinameL:
return "<error> " + n.toString()
break
case Constants.CONSTANT_TypeName:
var typeStrings : Array = new Array();
for each (var typeId : int in n.types)
typeStrings.push(nameToString(abcfile.getMultiname(typeId)))
return nameToString(abcfile.getMultiname(n.name_index)) + ".<" + typeStrings.join(", ") + ">";
break
}
return "<error> " + n.toString()
}
private function nsQualifierForNamespace(ns : ConstantNamespace) : String
{
switch (ns.kind)
{
case Constants.CONSTANT_PackageNs:
return "public"
case Constants.CONSTANT_ProtectedNs:
case Constants.CONSTANT_StaticProtectedNs:
case Constants.CONSTANT_StaticProtectedNs2:
return "protected"
case Constants.CONSTANT_PackageInternalNs:
return "internal"
}
if (ns.kind == Constants.CONSTANT_Namespace)
{
if (ns.uriString == "http://adobe.com/AS3/2006/builtin")
return "AS3";
}
return ns.uriString
}
public function write(printer : IPrinter):void {
this.printer = new IndentingPrinter(printer, 0, 2);
traverse()
var n:int = abcfile.methodInfos.getNumItems()
for(var i:int=0; i<n; i++) {
var v : MethodInfo = abcfile.methodInfos.get(i) as MethodInfo
writeAnonMethodInfo(v, i)
}
//writeArray(abcfile.methodInfos, writeAnonMethodInfo);
}
protected override function traverseScriptInit(init : MethodInfo, si : ScriptInfo, scriptId : uint) : void
{
dumpedMethods[abcfile.getMethodInfo(si.init_index)] = true
}
private function writeAnonMethodInfo(mi:MethodInfo, id:int) : void
{
if (mi in dumpedMethods)
return
printer.println("// " + id + " " + mi.derivedName);
writeMethodInfo("", "function ", mi, "");
}
protected override function traverseScriptSlotTrait(t : Trait, scriptInfo : ScriptInfo) : void
{
writeSlotTrait("var", t, "");
}
protected override function traverseScriptConstTrait(t : Trait, scriptInfo : ScriptInfo) : void
{
writeSlotTrait("const", t, "");
}
protected override function traverseScriptMethodTrait(t : Trait, scriptInfo : ScriptInfo) : void
{
writeMethodTrait("function", t, "");
}
protected override function traverseScriptGetterTrait(t : Trait, scriptInfo : ScriptInfo) : void
{
writeMethodTrait("function get", t, "");
}
protected override function traverseScriptSetterTrait(t : Trait, scriptInfo : ScriptInfo) : void
{
writeMethodTrait("function set", t, "");
}
protected override function traverseScriptFunctionTrait(t : Trait, scriptInfo : ScriptInfo) : void
{
writeMethodTrait("function", t, "");
}
protected override function traverseScriptClassTrait(classIndex : uint, instanceInfo: InstanceInfo, classInfo : ClassInfo, trait : Trait, scriptInfo : ScriptInfo) : void
{
var initMethodInfo : MethodInfo = abcfile.getMethodInfo(instanceInfo.iinit_index)
var cinitMethodInfo : MethodInfo = abcfile.getMethodInfo(classInfo.init_index)
dumpedMethods[initMethodInfo] = true
dumpedMethods[cinitMethodInfo] = true
var f : Function = function (t : Trait, mi : MethodInfo) : void
{
dumpedMethods[mi] = true;
}
visitMethodTraits(instanceInfo.instance_traits, f);
visitMethodTraits(classInfo.static_traits, f);
if (!isVisibleNamespace(abcfile.getNamespace(trait.multiname.ns_index)))
return;
printer.println("")
var def : String = classDeclarationString(instanceInfo, trait)
printer.println(def + "extends " + nameToString(abcfile.getMultiname(instanceInfo.super_index)));
printer.indent()
if (instanceInfo.interfaces.length > 0)
{
var interfaceNames : Vector.<String> = new Vector.<String>()
for each (var interfaceNameId : int in instanceInfo.interfaces) {
interfaceNames.push(nameToString(abcfile.getMultiname(interfaceNameId)))
}
var implementsStr : String = "implements " + interfaceNames.join(",");
printer.println(implementsStr)
}
printer.println("");
currentQualifier = classDeclarationString(instanceInfo, trait)
super.traverseScriptClassTrait(classIndex, instanceInfo, classInfo, trait, scriptInfo)
printer.unindent() // handles .indent call from traverseInstanceInit
printer.unindent()
}
private function classDeclarationString(instanceInfo : InstanceInfo, classTrait : Trait) : String
{
var def : String;
if (instanceInfo.isInterface)
{
def = "interface";
}
else
{
def = "class";
if (instanceInfo.isDynamic)
def = "dynamic " + def;
if (instanceInfo.isFinal)
def = "final " + def;
}
return def + " " + nameToString(classTrait.multiname) + " ";
}
protected override function traverseInstanceInit(init : MethodInfo, instanceInfo : InstanceInfo, classTrait : Trait, scriptInfo : ScriptInfo) : void
{
writeMethodInfo(nameToString(classTrait.multiname), "function", init, currentQualifier)
printer.indent()
}
protected override function traverseInstanceSlotTrait(trait : Trait, instanceInfo : InstanceInfo, classTrait : Trait, scriptInfo : ScriptInfo) : void
{
writeSlotTrait("var", trait, currentQualifier);
}
protected override function traverseInstanceConstTrait(trait : Trait, instanceInfo : InstanceInfo, classTrait : Trait, scriptInfo : ScriptInfo) : void
{
writeSlotTrait("const", trait, currentQualifier);
}
protected override function traverseInstanceMethodTrait(trait : Trait, instanceInfo : InstanceInfo, classTrait : Trait, scriptInfo : ScriptInfo) : void
{
writeMethodTrait("function", trait, currentQualifier);
}
protected override function traverseInstanceGetterTrait(trait : Trait, instanceInfo : InstanceInfo, classTrait : Trait, scriptInfo : ScriptInfo) : void
{
writeMethodTrait("function get", trait, currentQualifier);
}
protected override function traverseInstanceSetterTrait(trait : Trait, instanceInfo : InstanceInfo, classTrait : Trait, scriptInfo : ScriptInfo) : void
{
writeMethodTrait("function set", trait, currentQualifier);
}
protected override function traverseInstanceFunctionTrait(trait : Trait, instanceInfo : InstanceInfo, classTrait : Trait, scriptInfo : ScriptInfo) : void
{
writeMethodTrait("function", trait, currentQualifier);
}
protected override function traverseClassSlotTrait(trait : Trait, classInfo : ClassInfo, classTrait : Trait, scriptInfo : ScriptInfo) : void
{
writeSlotTrait("var", trait, currentQualifier + "static ");
}
protected override function traverseClassConstTrait(trait : Trait, classInfo : ClassInfo, classTrait : Trait, scriptInfo : ScriptInfo) : void
{
writeSlotTrait("const", trait, currentQualifier + "static ");
}
protected override function traverseClassMethodTrait(trait : Trait, classInfo : ClassInfo, classTrait : Trait, scriptInfo : ScriptInfo) : void
{
writeMethodTrait("function", trait, currentQualifier + "static ");
}
protected override function traverseClassGetterTrait(trait : Trait, classInfo : ClassInfo, classTrait : Trait, scriptInfo : ScriptInfo) : void
{
writeMethodTrait("function get", trait, currentQualifier + "static ");
}
protected override function traverseClassSetterTrait(trait : Trait, classInfo : ClassInfo, classTrait : Trait, scriptInfo : ScriptInfo) : void
{
writeMethodTrait("function set", trait, currentQualifier + "static ");
}
protected override function traverseClassFunctionTrait(trait : Trait, classInfo : ClassInfo, classTrait : Trait, scriptInfo : ScriptInfo) : void
{
writeMethodTrait("function", trait, currentQualifier + "static ");
}
private function writeSlotTrait(kindStr : String, t : Trait, containerQualifier : String) : void
{
if (!isVisibleNamespace(abcfile.getNamespace(t.multiname.ns_index)))
return;
var nameStr : String = nameToString(t.multiname)
var value : Object = t.valueObject
var valueStr : String = "";
if (t.value_kind == Constants.CONSTANT_Utf8)
valueStr = " = \"" + value + "\""
else if (value is ConstantNamespace)
valueStr = " = " + value.uriString
else if (value != null)
valueStr = " = " + value.toString()
else if (t.value_kind == Constants.CONSTANT_Null)
valueStr = " = null"
printer.println(containerQualifier + kindStr + " " + nameStr + ":" + nameToString(abcfile.getMultiname(t.type_index)) + valueStr);
}
private function writeMethodInfo(nameStr : String, kindStr : String, methodInfo : MethodInfo, containerQualifier : String) : void
{
var paramTypeStrings : Vector.<String> = new Vector.<String>();
for each (var paramTypeNameId : int in methodInfo.param_types)
paramTypeStrings.push(nameToString(abcfile.getMultiname(paramTypeNameId)))
printer.println(containerQualifier + kindStr + " " + nameStr + "(" + paramTypeStrings.join(",") + "):" + nameToString(abcfile.getMultiname(methodInfo.ret_type)))
}
private function writeMethodTrait(kindStr : String, t : Trait, containerQualifier : String) : void
{
var methodInfo : MethodInfo = abcfile.getMethodInfo(t.method_info);
dumpedMethods[methodInfo] = true;
if (!isVisibleNamespace(abcfile.getNamespace(t.multiname.ns_index)))
return;
var nameStr : String = nameToString(t.multiname);
printer.println("");
writeMethodInfo(nameStr, kindStr, methodInfo, containerQualifier);
}
private function visitMethodTraits(traits : Traits, f : Function) : void
{
for each (var t : Trait in traits.ts) {
switch(t.kind)
{
case Constants.TRAIT_Slot:
case Constants.TRAIT_Const:
break;
case Constants.TRAIT_Method:
case Constants.TRAIT_Getter:
case Constants.TRAIT_Setter:
case Constants.TRAIT_Function:
f(t, abcfile.getMethodInfo(t.method_info));
break;
case Constants.TRAIT_Class:
break;
}
}
}
private function isIdentifier(s : String) : Boolean
{
return s.match(identifierRegEx) != null;
}
private function isPackageName(s : String) : Boolean
{
var components : Array = s.split(".");
var f : Function = function (s : String, i : int, a : Array) : Boolean
{
return isIdentifier(s);
}
return components.every(f);
}
private function namespaceToString(ns : ConstantNamespace) : String
{
switch (ns.kind)
{
case Constants.CONSTANT_PrivateNs:
return "private";
case Constants.CONSTANT_PackageNs:
if (ns.uriString.length == 0)
return "package";
break;
case Constants.CONSTANT_Namespace:
if (isPackageName(ns.uriString))
return ns.uriString;
/*
case Constants.CONSTANT_PackageInternalNs:
case Constants.CONSTANT_ProtectedNs:
case Constants.CONSTANT_StaticProtectedNs:
case Constants.CONSTANT_StaticProtectedNs2:
*/
}
throw new APIWriterUnsupportedConstructError("abcasm does not support this namespace: " + ns.kind + " " + ns.toString());
return null;
}
private function writeArray(p:Pool, writefunc:Function):void {
printer.println("// "+p.name+" pool count: "+p.items.length+" start "+p.start_pos+", size: "+(p.end_pos - p.start_pos)+" bytes");
var n:int = p.getNumItems()
for(var i:int=0; i<n; i++) {
var v : Object = p.get(i)
writefunc.call(this, v, i)
}
}
public static function writeFile(abcfile:ABCFile, file:String) : void
{
var data : ByteArray = new ByteArray()
var printer : IPrinter = new ByteArrayPrinter(data)
print(abcfile, printer)
File.writeByteArray(file, data)
}
public static function print(abcfile:ABCFile, printer : IPrinter) : void
{
var w:AbcAPIWriter = new AbcAPIWriter(abcfile)
w.write(printer)
}
}
}
class APIWriterUnsupportedConstructError extends Error
{
public function APIWriterUnsupportedConstructError(msg : String)
{
super(msg);
}
}