public static List <string> AssumedStructPattern(Program.RunData runData, ReadingContext readingContext, out HeuristicaStatus heuristicaStatus)
{
Int32 assumedEndOfStructOffset = readingContext.declaredSizeStartOffset + readingContext.declaredSize;
Int32 assumedSize = readingContext.collectionElementCount > 0 ?
readingContext.declaredSize / readingContext.collectionElementCount :
readingContext.collectionElementCount;
try
{
string assumedLastName = ExportParsingMachine.FullNameString(runData.uexp, assumedEndOfStructOffset - 8);
if (assumedLastName == ExportParsingMachine.endOfStructConfigName)
{
heuristicaStatus = HeuristicaStatus.Success;
return(new List <string>()
{
"NTPL"
});
}
}
catch (Exception)
{
}
heuristicaStatus = HeuristicaStatus.Failure;
return(new List <string>());
}
private static string ExportByIndexFullNameString(byte[] uasset, byte[] uexp, Int32 exportIndex)
{
exportIndex = exportIndex - 1;
Int32 firstExportOffset = BitConverter.ToInt32(uasset, OffsetConstants.exportOffsetOffset);
return(ExportParsingMachine.FullNameString(uasset, firstExportOffset + exportIndex * OffsetConstants.exportDefSize + OffsetConstants.exportNameOffset));
}
private static void MapGeneratorTypesPatternElementProcesser(byte[] uasset, byte[] uexp, ReadingContext readingContext)
{
readingContext.pattern.TakeArg();
string tKey = ExportParsingMachine.FullNameString(uexp, readingContext.currentUexpOffset);
readingContext.currentUexpOffset += 8;
string tVal = ExportParsingMachine.FullNameString(uexp, readingContext.currentUexpOffset);
readingContext.currentUexpOffset += 8;
ExportParsingMachine.ReportExportContents($"<{tKey}, {tVal}>");
if (Program.PatternExists($"{Program.PatternFolders.body}/{tKey}") && Program.PatternExists($"{Program.PatternFolders.body}/{tVal}"))
{
List <string> keyPattern = Program.GetPattern($"{Program.PatternFolders.body}/{tKey}");
List <string> valPattern = Program.GetPattern($"{Program.PatternFolders.body}/{tVal}");
if (keyPattern.TakeArg() == ExportParsingMachine.arrayRepeatPatternElementName &&
valPattern.TakeArg() == ExportParsingMachine.arrayRepeatPatternElementName)
{
readingContext.pattern.Add(ExportParsingMachine.elementCountPatternElementName);
readingContext.pattern.Add(ExportParsingMachine.arrayRepeatPatternElementName);
readingContext.pattern.AddRange(keyPattern);
readingContext.pattern.Add(ExportParsingMachine.arrayRepeatEndPatternElementName);
readingContext.pattern.Add(ExportParsingMachine.elementCountPatternElementName);
readingContext.pattern.Add(ExportParsingMachine.arrayRepeatPatternElementName);
readingContext.pattern.AddRange(keyPattern);
readingContext.pattern.AddRange(valPattern);
}
}
}
private static void StructPropertyArrayTypeContextSearcher(byte[] uasset, byte[] uexp, ReadingContext readingContext)
{
readingContext.pattern.TakeArg();
string typeName = ExportParsingMachine.FullNameString(uexp, readingContext.currentUexpOffset);
readingContext.currentUexpOffset += 8;
if (customRunDara.reportSearchSteps)
{
ExportParsingMachine.ReportExportContents($"Element structure type: {typeName}");
}
if (Program.PatternExists($"{Program.PatternFolders.structure}/{typeName}"))
{
readingContext.pattern.Add(ExportParsingMachine.arrayRepeatPatternElementName);
readingContext.pattern.AddRange(Program.GetPattern($"{Program.PatternFolders.structure}/{typeName}"));
}
// Heuristics not allowed yet for replacement
//else if (Program.config.enablePatternReadingHeuristica && readingContext.collectionElementCount != 0)
//{
// readingContext.pattern.Add(structTypeHeuristicaPatternElementName);
// readingContext.pattern.Add(SkipIfPatternShorterThanPatternElemetnName);
// readingContext.pattern.Add("2");
// readingContext.pattern.Add(ExportParsingMachine.arrayRepeatPatternElementName);
//}
}
private static void NamePatternElementProcesser(byte[] uasset, byte[] uexp, ReadingContext readingContext)
{
readingContext.pattern.TakeArg();
ExportParsingMachine.ReportExportContents($"Name: {ExportParsingMachine.FullNameString(uexp, readingContext.currentUexpOffset)}");
readingContext.currentUexpOffset += 8;
}
private static void NoneTerminatedPropListPatternElementProcesser(byte[] uasset, byte[] uexp, ReadingContext readingContext)
{
string substructName = ExportParsingMachine.FullNameString(uexp, readingContext.currentUexpOffset);
readingContext.currentUexpOffset += 8;
if (substructName == ExportParsingMachine.endOfStructConfigName)
{
readingContext.pattern.TakeArg();
return;
}
string typeName = ExportParsingMachine.FullNameString(uexp, readingContext.currentUexpOffset);
readingContext.currentUexpOffset += 8;
ExportParsingMachine.ReportExportContents("------------------------------");
ExportParsingMachine.ReportExportContents($"{substructName} is {typeName}");
List <string> propertyPattern;
try
{
propertyPattern = Program.GetPattern($"{Program.PatternFolders.property}/{typeName}");
}
catch
{
ExportParsingMachine.ReportExportContents($"Failed to find a pattern for property type {typeName}");
Int32 assumedSize = BitConverter.ToInt32(uexp, readingContext.currentUexpOffset);
readingContext.currentUexpOffset += 8;
ExportParsingMachine.ReportExportContents($"Assumed property size {assumedSize}");
ExportParsingMachine.ReportExportContents($"Assumed property body {BitConverter.ToString(uexp, readingContext.currentUexpOffset + 1, assumedSize)}");
throw;
}
ExportParsingMachine.machineState.Push(new ReadingContext()
{
currentUexpOffset = readingContext.currentUexpOffset,
declaredSize = -1,
declaredSizeStartOffset = -1,
collectionElementCount = -1,
pattern = propertyPattern,
patternAlphabet = readingContext.patternAlphabet,
structCategory = ReadingContext.StructCategory.nonExport
});
ExportParsingMachine.ExecutePushedReadingContext(uasset, uexp, readingContext);
}
private static void ArrayElementTypeNameIndexPatternElementProcesser(byte[] uasset, byte[] uexp, ReadingContext readingContext)
{
readingContext.pattern.TakeArg();
string typeName = ExportParsingMachine.FullNameString(uexp, readingContext.currentUexpOffset);
readingContext.currentUexpOffset += 8;
ExportParsingMachine.ReportExportContents($"Array Element Type: {typeName}");
if (Program.PatternExists($"{Program.PatternFolders.body}/{typeName}"))
{
readingContext.pattern.AddRange(Program.GetPattern($"{Program.PatternFolders.body}/{typeName}"));
}
}
private static void StructTypeNameIndexContextSearcher(byte[] uasset, byte[] uexp, ReadingContext readingContext)
{
readingContext.pattern.TakeArg();
string typeName = ExportParsingMachine.FullNameString(uexp, readingContext.currentUexpOffset);
if (customRunDara.reportSearchSteps)
{
ExportParsingMachine.ReportExportContents($"Structure Type: {typeName}");
}
readingContext.currentUexpOffset += 8;
if (Program.PatternExists($"{Program.PatternFolders.structure}/{typeName}"))
{
readingContext.pattern.AddRange(Program.GetPattern($"{Program.PatternFolders.structure}/{typeName}"));
}
}
public override string ExecuteAndGetOffSetterAgrs(List <string> args, out bool doneSomething, out bool useStandardBackup)
{
useStandardBackup = false;
doneSomething = false;
Int32 exportIndex = GetExportIndex(Program.runData.uasset, args).Value;
Int32 fisrtExportOffset = BitConverter.ToInt32(Program.runData.uasset, OffsetConstants.exportOffsetOffset);
Int32 uexpStructureOffset = BitConverter.ToInt32(Program.runData.uasset, fisrtExportOffset + (exportIndex - 1)
* OffsetConstants.exportDefSize + OffsetConstants.exportSerialOffsetOffset)
- BitConverter.ToInt32(Program.runData.uasset, headerSizeOffset);
Int32 uexpStructureSize = BitConverter.ToInt32(Program.runData.uasset, fisrtExportOffset + (exportIndex - 1) *
OffsetConstants.exportDefSize + OffsetConstants.exportSerialSizeOffset);
string exportObjectName = ExportParsingMachine.FullNameString(Program.runData.uasset, fisrtExportOffset + (exportIndex - 1) *
OffsetConstants.exportDefSize + OffsetConstants.exportNameOffset);
Console.WriteLine("--------------------");
Console.WriteLine($"Export Index: {exportIndex}");
Console.WriteLine($"Export Object Name {exportObjectName}");
Console.WriteLine("--------------------");
ExportParsingMachine.ResetSLIString();
ExportParsingMachine.machineState = new Stack <ReadingContext>();
ExportParsingMachine.machineState.Push(new ReadingContext()
{
currentUexpOffset = uexpStructureOffset,
declaredSize = uexpStructureSize,
declaredSizeStartOffset = uexpStructureOffset,
collectionElementCount = -1,
pattern = new List <string>()
{
ExportParsingMachine.NTPLPatternElementName
},
patternAlphabet = patternElementProcessers,
structCategory = ReadingContext.StructCategory.export
});
ExportParsingMachine.StepsTilEndOfStruct(Program.runData.uasset, Program.runData.uexp);
return("");
}
private static void StructTypeNameIndexPatternElementProcesser(byte[] uasset, byte[] uexp, ReadingContext readingContext)
{
readingContext.pattern.TakeArg();
string typeName = ExportParsingMachine.FullNameString(uexp, readingContext.currentUexpOffset);
ExportParsingMachine.ReportExportContents($"Structure Type: {typeName}");
readingContext.currentUexpOffset += 8;
if (Program.PatternExists($"{Program.PatternFolders.structure}/{typeName}"))
{
readingContext.pattern.AddRange(Program.GetPattern($"{Program.PatternFolders.structure}/{typeName}"));
}
else if (Program.config.enablePatternReadingHeuristica)
{
readingContext.pattern.Add(structTypeHeuristicaPatternElementName);
readingContext.pattern.Add(ExportParsingMachine.skipIfPatternEndsPatternElementName);
}
}
private static void StructPropertyArrayTypePatternElementProcesser(byte[] uasset, byte[] uexp, ReadingContext readingContext)
{
readingContext.pattern.TakeArg();
string typeName = ExportParsingMachine.FullNameString(uexp, readingContext.currentUexpOffset);
readingContext.currentUexpOffset += 8;
ExportParsingMachine.ReportExportContents($"Element structure type: {typeName}");
if (Program.PatternExists($"{Program.PatternFolders.structure}/{typeName}"))
{
readingContext.pattern.Add(ExportParsingMachine.arrayRepeatPatternElementName);
readingContext.pattern.AddRange(Program.GetPattern($"{Program.PatternFolders.structure}/{typeName}"));
}
else if (Program.config.enablePatternReadingHeuristica && readingContext.collectionElementCount != 0)
{
readingContext.pattern.Add(structTypeHeuristicaPatternElementName);
readingContext.pattern.Add(ExportParsingMachine.skipIfPatternShorterThanPatternElemetnName);
readingContext.pattern.Add("2");
readingContext.pattern.Add(ExportParsingMachine.arrayRepeatPatternElementName);
}
}
private static void NTPLContextSearcher(byte[] uasset, byte[] uexp, ReadingContext readingContext)
{
string targetPropertyName = readingContext.targetContext[0];
string substructName = ExportParsingMachine.FullNameString(uexp, readingContext.currentUexpOffset);
readingContext.currentUexpOffset += 8;
if (substructName == ExportParsingMachine.endOfStructConfigName)
{
readingContext.pattern.TakeArg();
return;
}
string typeName = ExportParsingMachine.FullNameString(uexp, readingContext.currentUexpOffset);
readingContext.currentUexpOffset += 8;
if (customRunDara.reportSearchSteps)
{
ExportParsingMachine.ReportExportContents("------------------------------");
ExportParsingMachine.ReportExportContents($"{substructName} is {typeName}");
}
List <string> propertyPattern;
try
{
propertyPattern = Program.GetPattern($"{Program.PatternFolders.property}/{typeName}");
}
catch
{
ExportParsingMachine.ReportExportContents($"Failed to find a pattern for property type {typeName}");
Int32 assumedSize = BitConverter.ToInt32(uexp, readingContext.currentUexpOffset);
readingContext.currentUexpOffset += 8;
ExportParsingMachine.ReportExportContents($"Assumed property size {assumedSize}");
ExportParsingMachine.ReportExportContents($"Assumed property body {BitConverter.ToString(uexp, readingContext.currentUexpOffset + 1, assumedSize)}");
throw;
}
if (substructName != targetPropertyName)
{
propertyPattern.Insert(propertyPattern.IndexOf(ExportParsingMachine.sizeStartPatternElementName) + 1,
skipContextPatternElementName);
}
List <string> targetSubContext = new List <string>(readingContext.targetContext);
targetSubContext.RemoveAt(0);
ExportParsingMachine.machineState.Push(new ReadingContext()
{
currentUexpOffset = readingContext.currentUexpOffset,
declaredSize = -1,
declaredSizeStartOffset = -1,
collectionElementCount = -1,
targetContext = targetSubContext,
pattern = propertyPattern,
patternAlphabet = readingContext.patternAlphabet,
structCategory = ReadingContext.StructCategory.nonExport,
contextReturnProcesser = ContextReturnProcesser
});
ExportParsingMachine.ExecutePushedReadingContext(uasset, uexp, readingContext);
}
