public void Write(SwfWriter writer)
{
writer.ABC = this;
var ver = Version;
writer.WriteUInt16((ushort)ver.Minor);
writer.WriteUInt16((ushort)ver.Major);
if (ver.Major == CurrentMajor && ver.Minor == CurrentMinor)
{
IntPool.Write(writer);
UIntPool.Write(writer);
DoublePool.Write(writer);
StringPool.Write(writer);
Namespaces.Write(writer);
NamespaceSets.Write(writer);
Multinames.Write(writer);
Methods.Write(writer);
Metadata.Write(writer);
int n = Instances.Count;
writer.WriteUIntEncoded((uint)n);
Instances.Write(writer);
Classes.Write(writer);
Scripts.Write(writer);
MethodBodies.Write(writer);
}
else
{
throw new NotImplementedException();
}
}
public void AddMethod(AbcMethod method)
{
if (method == null)
{
throw new ArgumentNullException("method");
}
Methods.Add(method);
var body = method.Body;
if (body != null)
{
MethodBodies.Add(body);
}
}
public void Read(SwfReader reader)
{
reader.ABC = this;
int minor = reader.ReadUInt16();
int major = reader.ReadUInt16();
_version = new Version(major, minor);
if (minor == CurrentMinor && major == CurrentMajor)
{
//NOTE: The "0" entry of each constant pool is not used. If the count for a given pool says there are
//NOTE: "n" entries in the pool, there are "n-1" entries in the file, corresponding to indices 1..(n-1).
IntPool.Read(reader);
UIntPool.Read(reader);
SwfReader.CheckU30 = true;
DoublePool.Read(reader);
StringPool.Read(reader);
Namespaces.Read(reader);
NamespaceSets.Read(reader);
Multinames.Read(reader);
Methods.Read(reader);
Metadata.Read(reader);
int n = (int)reader.ReadUIntEncoded();
Instances.Read(n, reader);
Classes.Read(n, reader);
for (int i = 0; i < n; ++i)
{
var klass = Classes[i];
var instance = Instances[i];
instance.Class = klass;
klass.Instance = instance;
klass.Initializer.Instance = instance;
}
Scripts.Read(reader);
MethodBodies.Read(reader);
SwfReader.CheckU30 = false;
}
else
{
throw new NotImplementedException();
}
}
public IEnumerable <AbcTrait> GetTraits(AbcTraitOwner owners)
{
var allTraits = Enumerable.Empty <AbcTrait>();
if ((owners & AbcTraitOwner.Instance) != 0)
{
var traits = Instances.SelectMany(x => x.Traits.Concat(x.Class.Traits));
allTraits = allTraits.Concat(traits);
}
if ((owners & AbcTraitOwner.Script) != 0)
{
var traits = Scripts.SelectMany(x => x.Traits);
allTraits = allTraits.Concat(traits);
}
if ((owners & AbcTraitOwner.MethodBody) != 0)
{
var traits = MethodBodies.SelectMany(x => x.Traits);
allTraits = allTraits.Concat(traits);
}
return(allTraits);
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
_input.Dispose();
_classesCache.Clear();
Methods.Clear();
Metadata.Clear();
Instances.Clear();
Classes.Clear();
Scripts.Clear();
MethodBodies.Clear();
Pool.Integers.Clear();
Pool.UIntegers.Clear();
Pool.Doubles.Clear();
Pool.Strings.Clear();
Pool.Namespaces.Clear();
Pool.NamespaceSets.Clear();
Pool.Multinames.Clear();
}
}
private AbcMethodBody ImportMethodBody(AbcMethodBody from, AbcMethod method)
{
if (from.ImportedBody != null)
{
return(from.ImportedBody);
}
var body = new AbcMethodBody(method);
from.ImportedBody = body;
body.MaxStackDepth = from.MaxStackDepth;
body.LocalCount = from.LocalCount;
body.MinScopeDepth = from.MinScopeDepth;
body.MaxScopeDepth = from.MaxScopeDepth;
MethodBodies.Add(body);
ImportTraits(from, body);
ImportExceptions(body, from);
ImportIL(body, from);
body.TranslateIndices();
body.ResolveExceptionOffsets(this);
return(body);
}
private void BuildMethod(IMethodSymbol method, CCodeUnit unit)
{
if (method.MethodKind == MethodKind.Ordinary && method.IsStatic && method.Name == "Main")
{
unit.MainMethod = method;
}
var key = ((MethodSymbol)method).ToKeyString();
SourceMethodSymbol sourceMethod;
var sourceMethodFound = this.SourceMethodByMethodSymbol.TryGetValue(key, out sourceMethod);
BoundStatement boundStatement;
var boundStatementFound = this.BoundBodyByMethodSymbol.TryGetValue(key, out boundStatement);
if (!sourceMethodFound && !boundStatementFound && method.MethodKind == MethodKind.Constructor)
{
// ignore empty constructor as they should call Object.ctor() only which is empty
unit.Declarations.Add(new CCodeMethodDeclaration(unit.Type, method));
unit.Definitions.Add(new CCodeMethodDefinition(method));
return;
}
Debug.Assert(sourceMethodFound || boundStatementFound, "MethodBodyOpt information can't be found");
unit.Declarations.Add(new CCodeMethodDeclaration(unit.Type, method));
var methodSymbol = sourceMethodFound ? sourceMethod : method;
var requiresCompletion = sourceMethod != null && sourceMethod.RequiresCompletion;
// so in case of Delegates you need to complete methods yourself
if (boundStatement != null && !ExcludeBodies(method))
{
unit.Definitions.Add(new CCodeMethodDefinition(method)
{
BoundBody = boundStatement
});
}
else if (requiresCompletion && methodSymbol.ContainingType.TypeKind == TypeKind.Delegate && !methodSymbol.IsAbstract)
{
MethodBody body;
switch (methodSymbol.Name)
{
case "BeginInvoke":
body = MethodBodies.ReturnNull(method);
break;
case "Invoke":
body = MethodBodies.ReturnDefault(method);
break;
case "EndInvoke":
body = MethodBodies.ReturnDefault(method);
break;
default:
body = MethodBodies.Throw(method);
break;
}
unit.Definitions.Add(
new CCodeMethodDefinition(method)
{
MethodBodyOpt = body
});
}
else
{
#if GENERATE_STUBS
if (methodSymbol.ContainingType.TypeKind != TypeKind.Interface &&
!methodSymbol.IsAbstract &&
!methodSymbol.IsExternDeclaration())
{
unit.Definitions.Add(
new CCodeMethodDefinition(method)
{
IsStub = true,
MethodBodyOpt = MethodBodies.Throw(method)
});
}
#endif
}
}