public void DumpTagLayout(MoonfishTagGroup tag, string folder)
{
_definitionsDictionary.Clear();
var info = BeginProcessTagBlockDefinition(tag.Definition);
using (var stream = new FileStream(Path.Combine(folder, info.Name + ".cs"), FileMode.Create,
FileAccess.Write, FileShare.ReadWrite))
{
var size = tag.Definition.CalculateSizeOfFieldSet();
var hasParent = h2Tags.Any(x => x.Class == tag.ParentClass);
if (hasParent)
{
var parentTag = new MoonfishTagGroup(h2Tags.First(x => x.Class == tag.ParentClass));
info.BaseClass = new ClassInfo(TokenDictionary.GenerateValidIdentifier(
ToTypeName(parentTag.Definition.Name)));
// loop through all the parents summing up thier sizes
while (hasParent)
{
size += parentTag.Definition.CalculateSizeOfFieldSet();
hasParent = h2Tags.Any(x => x.Class == parentTag.ParentClass);
if (hasParent)
{
parentTag = new MoonfishTagGroup(h2Tags.First(x => x.Class == parentTag.ParentClass));
}
}
}
else
{
info.BaseClass = new ClassInfo("GuerillaBlock");
}
var alignment = tag.Definition.Alignment;
var property = info.Properties.Single(x => x.Name == "SerializedSize");
property.GetBody = string.Format("return {0};", size);
info.Attributes.Add(new AttributeInfo(typeof(TagClassAttribute))
{
Parameters = { "\"" + tag.Class + "\"" }
});
var streamWriter = new StreamWriter(stream);
info.Generate();
GenerateOutputForClass(info, streamWriter);
}
var localDefinitions = _definitionsDictionary.Select(x => x.Value);
foreach (var item in localDefinitions)
{
using (var stream = new FileStream(Path.Combine(folder, item.Name + ".cs"), FileMode.Create,
FileAccess.Write, FileShare.ReadWrite))
{
item.Generate();
GenerateOutputForClass(item, new StreamWriter(stream));
}
}
}
private ElementArray CompileElementArray(MoonfishTagGroup tag, IEnumerable <MoonfishTagGroup> tags, int offset)
{
ElementArray elementArray;
if (tag.ParentClass != TagClass.Null)
{
var guerillaTagGroups = tags as IList <MoonfishTagGroup> ?? tags.ToList();
var parentClass = guerillaTagGroups.Single(x => x.Class == tag.ParentClass);
if (parentClass.ParentClass != TagClass.Null)
{
var baseClass = guerillaTagGroups.Single(x => x.Class == parentClass.ParentClass);
elementArray = ProcessTagBlockDefinition(baseClass.Definition, ref offset, true);
elementArray.Append(ProcessTagBlockDefinition(parentClass.Definition, ref offset, true));
elementArray.Append(ProcessTagBlockDefinition(tag.Definition, ref offset, true));
}
else
{
elementArray = ProcessTagBlockDefinition(parentClass.Definition, ref offset, true);
elementArray.Append(ProcessTagBlockDefinition(tag.Definition, ref offset, true));
}
}
else
{
elementArray = ProcessTagBlockDefinition(tag.Definition, ref offset, true);
}
return(elementArray);
}
public void Validate(TagDatum datum, Stream dataStream)
{
error = false;
_pointersList = new List <Tuple <BlamPointer, ElementArray> >();
_writeMessage = Console.WriteLine;
var offset = 0;
var definition =
new MoonfishTagGroup(Guerilla.h2Tags.First(x => x.Class == datum.Class));
var definitionPool = Guerilla.h2Tags.Select(x => new MoonfishTagGroup(x));
var elementArray = CompileElementArray(definition, definitionPool, offset);
elementArray.count = 1;
var binaryReader = new BinaryReader(dataStream);
var virtualTagMemory = new VirtualMappedAddress
{
Address = datum.VirtualAddress,
Length = datum.Length
};
_isValidDelegate = virtualTagMemory.Contains;
_isPointerOwnedByTagDelegate = virtualTagMemory.Contains;
offset = (int)dataStream.Seek(datum.VirtualAddress, SeekOrigin.Begin);
elementArray.virtualAddress = datum.VirtualAddress;
ValidateTagBlock(elementArray, elementArray.ToFixedArrayPointer(), binaryReader, ref offset);
if (error)
{
OnWriteMessage(string.Format("Tag ({0}.{1})", datum.Path, datum.Class.ToTokenString()));
}
}
public bool Validate(MoonfishTagGroup validateTag, IEnumerable <MoonfishTagGroup> tagPool, string[] filenames)
{
error = false;
_pointersList = new List <Tuple <BlamPointer, ElementArray> >();
var filename = string.Format(@"{1}\test_analysis\analysis.txt",
validateTag.Class.ToTokenString(), Local.MapsDirectory);
var stringWriter = File.AppendText(filename);
_writeMessage = (stringWriter.WriteLine);
var offset = 0;
var elementArray = CompileElementArray(validateTag, tagPool, offset);
elementArray.count = 1;
foreach (var file in filenames)
{
using (var map = new CacheStream(file))
{
var binaryReader = new BinaryReader(map);
//OnWriteMessage(string.Format("Begin ({0})", map.MapName));
foreach (var tag in map.Index)
{
error = false;
if (!(tag.Class == validateTag.Class))
{
continue;
}
var metaTableMemory = map.DefaultMemoryBlock;
if (tag.Class == (TagClass)"sbsp" || tag.Class == (TagClass)"ltmp")
{
metaTableMemory =
map.StructureMemoryBlocks[map.StructureMemoryBlockBindings[tag.Identifier]];
map.ActiveAllocation(StructureCache.VirtualStructureCache0 +
map.StructureMemoryBlockBindings[tag.Identifier]);
}
var virtualTagMemory = new VirtualMappedAddress
{
Address = tag.VirtualAddress,
Length = tag.Length
};
_isValidDelegate = metaTableMemory.Contains;
_isPointerOwnedByTagDelegate = virtualTagMemory.Contains;
_pointersList.Clear();
offset = (int)map.Seek(tag.Identifier);
elementArray.virtualAddress = map.Index[tag.Identifier].VirtualAddress;
ValidateTagBlock(elementArray, elementArray.ToFixedArrayPointer(), binaryReader, ref offset);
if (error)
{
OnWriteMessage(string.Format("Tag ({0}.{1})", tag.Path, validateTag.Class.ToTokenString()));
}
stringWriter.Flush();
}
Console.WriteLine(@"Parsed ({0})", map.Header.Name);
}
}
stringWriter.Close();
return(error);
}
