private void ProcessCommands(byte[] file)
{
// Local variables.
int numCommands = file.Length / C.CMDLENGTH;
uint cmd;
uint opcode;
// Search file for all instances of a LUI command.
for (int i = 0; i < numCommands; i++)
{
int position = i * 4;
// If LUI command, find pairs and update addresses.
cmd = ASM.GetCommand(file, position);
opcode = ASM.GetOpcode(cmd);
switch (opcode)
{
case C.LUICMD:
UpdateLui(file, cmd, position);
break;
case C.JALCMD:
UpdateJAL(file, cmd, position);
break;
}
}
}
public override void PrintASM(string levelTabulatiion, bool isNewLine = false)
{
bool isConditionBelongToCicle = ASMregisters.isContitionBelongsToCicle;
ASMregisters.isContitionBelongsToCicle = false;
string markerJumpPrevBody = "";
string markerJumpAfterBody = "";
if (bodyCondition != null)
{
bodyCondition.PrintASM(levelTabulatiion);
markerJumpPrevBody = ASMregisters.MarkerJumpPrevBody;
markerJumpAfterBody = ASMregisters.MarkerJumpAfterBody;
}
BinaryExprAST.ClearStaicFlags();
bool isNextNodeElse = IsNextNodeElse(markerJumpPrevBody, markerJumpAfterBody);
ASMregisters.ClearMarkerks();
if (markerJumpPrevBody != null && markerJumpPrevBody != "")
{
ASM.WriteASMCode(levelTabulatiion + markerJumpPrevBody + ":");
}
(body as BodyMethodAST).PrintASM(levelTabulatiion + "\t", isNewLine);
if (!isNextNodeElse)
{
if (markerJumpAfterBody != null && markerJumpAfterBody != "" && !isConditionBelongToCicle)
{
ASM.WriteASMCode(levelTabulatiion + markerJumpAfterBody + ":");
}
}
}
public override string Convert(ASM.ASMBlock theBlock)
{
StringBuilder ASMResult = new StringBuilder();
ASMResult.AppendLine("# Method Table - " + CurrentTypeName);
ASMResult.AppendLine(".globl " + CurrentTypeId + "_MethodTable");
ASMResult.AppendLine(".align 2");
ASMResult.AppendLine(CurrentTypeId + "_MethodTable:");
foreach (Tuple<string, string> aMethodInfo in AllMethodInfos)
{
string MethodID = aMethodInfo.Item1;
string MethodIDValue = aMethodInfo.Item2;
foreach (Tuple<string, int> anEntryFieldInfo in TableEntryFieldInfos)
{
string allocString = ASMUtilities.GetAllocStringForSize(anEntryFieldInfo.Item2);
switch (anEntryFieldInfo.Item1)
{
case "MethodID":
ASMResult.AppendLine(allocString + " " + MethodIDValue);
break;
case "MethodPtr":
ASMResult.AppendLine(allocString + " " + MethodID);
break;
}
}
}
ASMResult.AppendLine("# Method Table End - " + CurrentTypeName);
return ASMResult.ToString();
}
private void UpdateJAL(byte[] file, uint jalCmd, int position)
{
uint jalImmediate = ASM.GetJalImmediate(jalCmd);
uint fullAddress = jalImmediate + 0x80000000;
// Convert to new address.
uint offset = (uint)(fullAddress - _BASERAM);
uint newAddress = (uint)(_baseRam + RomFile.CurrentFileOffset + offset);
uint newJal = ASM.BuildNewJalCommand(newAddress);
byte[] JalArray = BitConverter.GetBytes(newJal);
if (BitConverter.IsLittleEndian)
{
Array.Reverse(JalArray);
}
if ((jalImmediate >= (_BASERAM - 0x80000000)) && (jalImmediate <= (_upperRAM - 0x80000000)))
{
file[position] = JalArray[0];
file[position + 1] = JalArray[1];
file[position + 2] = JalArray[2];
file[position + 3] = JalArray[3];
}
}
public override string Convert(ASM.ASMBlock theBlock)
{
StringBuilder ASMResult = new StringBuilder();
ASMResult.AppendLine("; Field Table - " + CurrentTypeName);
ASMResult.AppendLine("GLOBAL " + CurrentTypeId + "_FieldTable:data");
ASMResult.AppendLine(CurrentTypeId + "_FieldTable:");
foreach(Tuple<string, string, string> aFieldInfo in AllFieldInfos)
{
string fieldOffsetVal = aFieldInfo.Item1;
string fieldSizeVal = aFieldInfo.Item2;
string fieldTypeIdVal = aFieldInfo.Item3;
foreach(Tuple<string, int> anEntryFieldInfo in TableEntryFieldInfos)
{
string allocStr = ASMUtilities.GetAllocStringForSize(anEntryFieldInfo.Item2);
switch (anEntryFieldInfo.Item1)
{
case "Offset":
ASMResult.AppendLine(allocStr + " " + fieldOffsetVal);
break;
case "Size":
ASMResult.AppendLine(allocStr + " " + fieldSizeVal);
break;
case "FieldType":
ASMResult.AppendLine(allocStr + " " + fieldTypeIdVal);
break;
}
}
}
ASMResult.AppendLine("; Field Table End - " + CurrentTypeName);
return ASMResult.ToString();
}
/// <summary>
/// Set the secret code entry message when a player enters a cheat code that is not valid.
/// </summary>
/// <param name="msg"></param>
public static void SetSecretCodeEntryMessage(string msg)
{
var address = (IntPtr)Addrs.UIAddrs.STATIC_UI_INVALID_SECRET_CODE_ENTRY_TEXT;
ASM.Abolish(address, INVALID_SECRET_CODE_ENTRY_TEXT_MAX_LENGTH);
Memory.WriteStringASCII(address, msg.Substring(0, INVALID_SECRET_CODE_ENTRY_TEXT_MAX_LENGTH));
}
private void PrintCondition(string levelTabulatiion, bool isNewLine)
{
bool isConditionBelongToCicle = ASMregisters.isContitionBelongsToCicle;
ASMregisters.isContitionBelongsToCicle = false;
string markerJumpPrevBody = "";
string markerJumpAfterBody = "";
if (condition != null)
{
condition.PrintASM(levelTabulatiion);
markerJumpPrevBody = ASMregisters.MarkerJumpPrevBody;
markerJumpAfterBody = ASMregisters.MarkerJumpAfterBody;
ASMregisters.ClearMarkerks();
}
BinaryExprAST.ClearStaicFlags();
if (markerJumpPrevBody != null && markerJumpPrevBody != "")
{
ASM.WriteASMCode(levelTabulatiion + markerJumpPrevBody + ":");
}
body.PrintASM(levelTabulatiion + "\t", isNewLine);
if (markerJumpAfterBody != null && markerJumpAfterBody != "" && !isConditionBelongToCicle)
{
ASM.WriteASMCode(levelTabulatiion + markerJumpAfterBody + ":");
}
}
/// <summary>
/// Creates a new instance of an offset.
/// </summary>
/// <param name="offset">The raw offset.</param>
/// <param name="rva">The virtual address that is relative to a section.</param>
/// <param name="va">The virtual address.</param>
/// <param name="offsettype">The type of offset.</param>
public Offset(uint offset, uint rva, ulong va, ASM.OperandType offsettype)
{
this.FileOffset = offset;
this.Rva = rva;
this.Va = va;
this.OffsetType = offsettype;
}
public override void PrintASM(string levelTabulatiion, bool isNewLine = false)
{
if (node == null)
{
return;
}
if (node is BinaryExprAST)
{
node.PrintASM(levelTabulatiion);
}
else if (node is ParenthesisExprAST)
{
node.PrintASM(levelTabulatiion);
}
else
{
string elementStorage;
if (node is IEject)
{
elementStorage = (node as IEject).GetValue();
string register = ASMregisters.GetFreeRegister(ASMregisters.Register.DATA);
ASM.WriteASMCode(levelTabulatiion + "mov\t" + register + ", " + elementStorage);
ASM.WriteASMCode(levelTabulatiion + "push\t" + register);
ASMregisters.SetStateRegister(ASMregisters.Register.DATA, register, true);
}
else
{
node.PrintASM(levelTabulatiion);
}
}
}
public override string Convert(ASM.ASMBlock theBlock)
{
StringBuilder LiteralASM = new StringBuilder();
//This is UTF-16 (Unicode)/ASCII text
LiteralASM.AppendLine(string.Format("GLOBAL {0}:data", Id));
LiteralASM.AppendLine(string.Format("{0}:", Id));
//Put in type info as FOS_System.String type
LiteralASM.AppendLine(string.Format("dd {0}", StringTypeId));
//Put in string length bytes
LiteralASM.Append("db ");
for (int i = 0; i < 3; i++)
{
LiteralASM.Append(LengthBytes[i]);
LiteralASM.Append(", ");
}
LiteralASM.Append(LengthBytes[3]);
if (Characters.Length > 0)
{
//Put in string characters (as words)
LiteralASM.Append("\ndw ");
for (int i = 0; i < (Characters.Length - 1); i++)
{
LiteralASM.Append((uint)Characters[i]);
LiteralASM.Append(", ");
}
LiteralASM.Append((uint)Characters.Last());
}
LiteralASM.AppendLine();
return LiteralASM.ToString();
}
/// <summary>
/// Вывод массива
/// </summary>
public void PrintArrayASM(string levelTabulatiion)
{
if (type != "string")
{
string registerIteration = ASMregisters.GetFreeRegister(ASMregisters.Register.DATA);
ASM.WriteASMCode(levelTabulatiion + "mov\t" + registerIteration + ", 0");
PrintArrayIterationASM(levelTabulatiion + "\t", registerIteration, isShowResult: true);
for (int i = 0; i < lengthArray; i++)
{
PrintArrayIterationASM(levelTabulatiion + "\t", registerIteration, isShowResult: true);
}
ASM.WriteASMCode(levelTabulatiion + "push\t" + ASMregisters.NewString);
ASM.WriteASMCode(levelTabulatiion + "call\t[printf]");
ASMregisters.SetStateRegister(ASMregisters.Register.DATA, registerIteration, true);
}
else
{
for (int i = 0; i < lengthArray; i++)
{
PrintStringASM(levelTabulatiion, i);
}
}
}
internal static void _setNetworkLobbyIP(string ip)
{
var address = (IntPtr)Addrs.NetworkAddrs.STATIC_NETWORK_LOBBY_IP;
ASM.Abolish(address, NETWORK_LOBBY_IP_LENGTH);
Memory.WriteStringASCII(address, ip.Substring(0, NETWORK_LOBBY_IP_LENGTH));
}
public SpellAnimEditor()
{
try
{
InitializeComponent();
EntryArrayBox.Load("Spell Animations.txt");
EntryArrayBox.Value = 0;
EntryArrayBox.ValueChanged += EntryArrayBox_ValueChanged;
Commands = new SpellCommands("Spell Commands.txt");
Anim_CodeBox.KeyDown += new KeyEventHandler(TextBox_SelectAll);
Anim_CodeBox.AddSyntax(ASM.GetInstructionsRegex_Thumb(), System.Drawing.Color.Black, FontStyle.Bold | FontStyle.Italic);
Anim_CodeBox.AddSyntax(Commands.GetRegex(), SystemColors.Highlight);
Anim_CodeBox.AddSyntax(@"((\b[0-9]+)|((\b0x|\$)[0-9a-fA-F]+))\b", System.Drawing.Color.SlateBlue);
Anim_CodeBox.AddSyntax("return|label.*", SystemColors.ControlDark);
Anim_CodeBox.AddSyntax("@.*", SystemColors.ControlDark);
}
catch (Exception ex)
{
Program.ShowError("Could not properly open the " + this.Text, ex);
Core_CloseEditor(this, null);
}
}
private void UpdateF37F90(AsmFile fileObj)
{
uint jr = 0x03E00008;
uint cmd;
if (fileObj.Id == (int)_levelID.CC)
{
cmd = ASM.GetCommand(_F37F90, 0x5DA20);
UpdateJAL(_F37F90, cmd, 0x5DA20);
}
for (int j = 0; j < C.AsmGlobalsFuncsOffsets.afo[fileObj.Id].Length; j++)
{
int pos = C.AsmGlobalsFuncsOffsets.afo[fileObj.Id][j];
// Step thru all commands in subroutine and check for JALs.
while (ASM.GetCommand(_F37F90, pos) != jr)
{
cmd = ASM.GetCommand(_F37F90, pos);
if (ASM.GetOpcode(cmd) == C.JALCMD)
{
UpdateJAL(_F37F90, cmd, pos);
}
pos += 4;
}
}
}
public static void Cast(Core core, int skillID)
{
//00492AFA 8B0D D46F9200 mov ecx,dword ptr ds:[926FD4] ; elementc.00927630
//00492B00 8B40 08 mov eax,dword ptr ds:[eax+8]
//00492B03 6A FF push -1
//00492B05 6A 00 push 0
//00492B07 8B51 1C mov edx,dword ptr ds:[ecx+1C]
//00492B0A 6A 00 push 0
//00492B0C 50 push eax
//00492B0D 8B4A 20 mov ecx,dword ptr ds:[edx+20]
//00492B10 E8 BB2EFCFF call elementc.004559D0
var asm = new ASM();
{
asm.Pushad();
asm.Push6A(-1);
asm.Push6A(0);
asm.Push6A(0);
asm.Mov_EDX(skillID);
asm.Push_EDX();
asm.Mov_ECX_DWORD_Ptr(Game.GameBaseAddress);
asm.Mov_ECX_DWORD_Ptr_ECX_Add(0x1C);
asm.Mov_ECX_DWORD_Ptr_ECX_Add(0x20);
asm.Mov_EAX(0x004559D0);
asm.Call_EAX();
asm.Popad();
asm.Ret();
};
asm.Run(core);
}
public override string Convert(ASM.ASMBlock theBlock)
{
int numBytes = (int)Size;
string loadOp = "";
switch(Size)
{
case OperandSize.Byte:
if (SignExtend)
{
loadOp = "lb";
}
else
{
loadOp = "lbu";
}
break;
case OperandSize.Halfword:
if (SignExtend)
{
loadOp = "lh";
}
else
{
loadOp = "lhu";
}
break;
case OperandSize.Word:
loadOp = "lw";
break;
}
return loadOp + " " + Dest + ", 0($sp)\r\n" +
"addi $sp, $sp, " + numBytes;
}
public override void PrintASM(string levelTabulatiion, bool isNewLine = false)
{
IdentificatorAST identificatorRight = (IdentificatorAST)SymTable.symTabls.FindNode((id as IdentificatorAST).GetName());
int startInStack = identificatorRight.GetAddresInStack();
ASM.WriteASMCode(levelTabulatiion + ASMregisters.GetCrement(crement) + "\t" + ASMregisters.GetNameType(identificatorRight.GetTypeId()) + " [ebp-" + startInStack + "], 1");
}
private void PrintExprAST(ASTNode node, string levelTabulatiion)
{
if (ASMregisters.HasFillRegisters(ASMregisters.Register.DATA))
{
ASM.WriteASMCode(levelTabulatiion + "push\t" + ASMregisters.GetFirstFillRegister(ASMregisters.Register.DATA));
}
node.PrintASM(levelTabulatiion);
}
private void PrintValueASM(string levelTabulatiion, string register, string offset = "")
{
ASM.WriteASMCode(levelTabulatiion + "mov\t" + register + ", " + ASMregisters.GetNameType(type) + " [ebp-" + startInStack + offset + "]");
ASM.WriteASMCode(levelTabulatiion + "push\t" + register);
ASM.WriteASMCode(levelTabulatiion + "push\t" + ASMregisters.ShowValue);
ASM.WriteASMCode(levelTabulatiion + "call\t[printf]");
ASM.WriteASMCode(levelTabulatiion + "push\t" + ASMregisters.SpaceString);
ASM.WriteASMCode(levelTabulatiion + "call\t[printf]");
}
/// <summary>
/// Вывод переменной
/// </summary>
public void PrintIdentificatorASM(string levelTabulatiion)
{
string register = ASMregisters.GetFreeRegister(ASMregisters.Register.DATA);
PrintValueASM(levelTabulatiion, register);
ASMregisters.SetStateRegister(ASMregisters.Register.DATA, register, true);
ASM.WriteASMCode(levelTabulatiion + "push\t" + ASMregisters.NewString);
ASM.WriteASMCode(levelTabulatiion + "call\t[printf]");
}
public override string Convert(ASM.ASMBlock theBlock)
{
if (MoveType == MoveTypes.SrcRegToDestMemory)
{
switch (Size)
{
case OperandSize.Byte:
return "sb " + Src + ", " + Dest;
case OperandSize.Halfword:
return "sh " + Src + ", " + Dest;
case OperandSize.Word:
return "sw " + Src + ", " + Dest;
default:
throw new NotSupportedException("MIPS: Unrecognised move operand sizes. (DestIsMemory)");
}
}
else if (MoveType == MoveTypes.SrcMemoryToDestReg)
{
if (SignExtend)
{
switch (Size)
{
case OperandSize.Byte:
return "lb " + Dest + ", " + Src;
case OperandSize.Halfword:
return "lh " + Dest + ", " + Src;
case OperandSize.Word:
return "lw " + Dest + ", " + Src;
default:
throw new NotSupportedException("MIPS: Unrecognised move operand sizes. (SrcIsMemory)");
}
}
else
{
switch (Size)
{
case OperandSize.Byte:
return "lbu " + Dest + ", " + Src;
case OperandSize.Halfword:
return "lhu " + Dest + ", " + Src;
case OperandSize.Word:
return "lw " + Dest + ", " + Src;
default:
throw new NotSupportedException("MIPS: Unrecognised move operand sizes. (SrcIsMemory)");
}
}
}
else if (MoveType == MoveTypes.ImmediateToReg)
{
return "add " + Dest + ", $zero, " + Src;
}
else
{
return "move " + Dest + ", " + Src;
}
}
private void PrintStringASM(string levelTabulatiion, int i)
{
string register = ASMregisters.GetFreeRegister(ASMregisters.Register.DATA);
ASM.WriteASMCode(levelTabulatiion + "mov\t" + register + ", [ebp-" + (startInStack + i * 4) + "]");
ASM.WriteASMCode(levelTabulatiion + "mov\t" + "[" + ASMregisters.BufferString + "], " + register);
ASM.WriteASMCode(levelTabulatiion + "push\t" + ASMregisters.BufferString);
//ASM.WriteASMCode(levelTabulatiion + "push\t" + ASMregisters.ShowString);
ASM.WriteASMCode(levelTabulatiion + "call\t[printf]");
ASMregisters.SetStateRegister(ASMregisters.Register.DATA, register, true);
}
public override string Convert(ASM.ASMBlock theBlock)
{
if (Signed)
{
return "mult " + Src1 + ", " + Src2;
}
else
{
return "multu " + Src1 + ", " + Src2;
}
}
public override string Convert(ASM.ASMBlock theBlock)
{
if (WithBorrow)
{
return "sbb " + Dest + ", " + Src;
}
else
{
return "sub " + Dest + ", " + Src;
}
}
public override string Convert(ASM.ASMBlock theBlock)
{
if (!string.IsNullOrWhiteSpace(Count))
{
return "shld " + Dest + ", " + Src + ", " + Count;
}
else
{
return "shl " + Dest + ", " + Src;
}
}
public override string Convert(ASM.ASMBlock theBlock)
{
if (WithCarry)
{
return "adc " + Dest + ", " + Src;
}
else
{
return "add " + Dest + ", " + Src;
}
}
public override string Convert(ASM.ASMBlock theBlock)
{
if (Signed)
{
return "div " + Arg1 + ", " + Arg2;
}
else
{
return "divu " + Arg1 + ", " + Arg2;
}
}
//public static T Call<T>(IntPtr address, params dynamic[] args)
//{
// return Call<T>(((IntPtr)address, (IntPtr)address + 0x1590, (IntPtr)address), args);
//}
//public static T CallReg<T>(IntPtr address, dynamic[] args,
// dynamic eax = null,
// dynamic ecx = null,
// dynamic edx = null,
// dynamic ebx = null,
// dynamic esp = null,
// dynamic esi = null,
// dynamic edi = null)
//{
// return CallReg<T>(((IntPtr)address, (IntPtr)address + 0x1590, (IntPtr)address), args, eax, ecx, edx, ebx, esp, esi, edi);
//}
public static T Call <T>(Memloc address, params dynamic[] args)
{
if (IntPtr.Size == 4)
{
return(ASM.CallIngameFunc <T>(address, args));
}
else
{
return(ASM.CallIngameFunc64 <T>(address, args));
}
}
public static T CallReg <T>(Memloc address, dynamic[] args,
dynamic eax = null,
dynamic ecx = null,
dynamic edx = null,
dynamic ebx = null,
dynamic esp = null,
dynamic esi = null,
dynamic edi = null)
{
return(ASM.CallIngameFuncReg <T>(address, args, eax, ecx, edx, ebx, esp, esi, edi));
}
public override string Convert(ASM.ASMBlock theBlock)
{
if (Unsigned)
{
return "addu " + Dest + ", " + Src1 + ", " + Src2;
}
else
{
return "add " + Dest + ", " + Src1 + ", " + Src2;
}
}
public void Start(IContainer container)
{
ASM asmInterfaces = ASM.GetAssembly(typeof(ds.IDataSource)),
asmClasses = ASM.GetAssembly(this.GetType());
container.RegisterFromAssembly(
servicesAssembly: asmInterfaces,
implementationsAssembly: asmClasses,
isService: t => t.IsInterface && !t.IsClass && typeof(ds.IDataSource).IsAssignableFrom(t),
isServiceImplementation: t => !t.IsInterface && t.IsClass && t.IsSubclassOf(typeof(DAL.DataSource))
);
}
internal static void _setDebugErrorString(string s)
{
IntPtr address = (IntPtr)UIAddrs.STATIC_DEBUG_ERROR_MSG_ADDRESS;
ASM.Abolish(address, DEBUG_ERROR_STRING_MAX_LENGTH);
string newString = s;
if (newString.Length > DEBUG_ERROR_STRING_MAX_LENGTH)
{
newString = newString.Substring(0, DEBUG_ERROR_STRING_MAX_LENGTH);
}
memory.WriteStringASCII(address, newString);
}
internal static void _setErrorMsgString(string s)
{
var address = (IntPtr)CarbonAddresses.UIAddrs.STATIC_ERROR_ALLOCATED_MSG;
ASM.Abolish(address, ERROR_MSG_MAX_LENGTH);
var newString = s;
if (newString.Length > ERROR_MSG_MAX_LENGTH)
{
newString = newString.Substring(0, ERROR_MSG_MAX_LENGTH);
}
Memory.WriteStringASCII(address, newString);
}
internal static void _setHelloWorldString(string s)
{
IntPtr address = (IntPtr)UIAddrs.STATIC_STRING_HELLO_WORLD_ADDRESS;
ASM.Abolish(address, STRING_MAX_LENGTH);
string newString = s;
if (newString.Length > STRING_MAX_LENGTH)
{
newString = newString.Substring(0, STRING_MAX_LENGTH);
}
memory.WriteStringASCII(address, newString);
}
/// <summary>
/// Set the code entry message when a player enters a cheat code that is not valid.
/// </summary>
/// <param name="msg"></param>
public static void SetCodeEntryMessage(string msg)
{
var addr = Memory.ReadInt32((IntPtr)Memory.getBaseAddress + Addrs.UIAddrs.PNON_STATIC_UI_INVALID_CODE_ENTRY_TEXT);
addr = Memory.ReadInt32((IntPtr)addr + Addrs.UIAddrs.POINTER_UI_INVALID_CODE_ENTRY_TEXT_1);
addr = Memory.ReadInt32((IntPtr)addr + Addrs.UIAddrs.POINTER_UI_INVALID_CODE_ENTRY_TEXT_2);
addr = Memory.ReadInt32((IntPtr)addr + Addrs.UIAddrs.POINTER_UI_INVALID_CODE_ENTRY_TEXT_3);
addr = Memory.ReadInt32((IntPtr)addr + Addrs.UIAddrs.POINTER_UI_INVALID_CODE_ENTRY_TEXT_4);
var final = (IntPtr)addr + Addrs.UIAddrs.POINTER_UI_INVALID_CODE_ENTRY_TEXT_5;
ASM.Abolish(final, INVALID_CODE_ENTRY_TEXT_MAX_LENGTH);
Memory.WriteStringASCII(final, msg.Substring(0, INVALID_CODE_ENTRY_TEXT_MAX_LENGTH));
}
public override void PrintASM(string levelTabulatiion, bool isNewLine = false)
{
ASM.WriteASMCode(levelTabulatiion + "jmp\t" + markerPrevBody);
ASM.WriteASMCode(levelTabulatiion + markerAfterBody + ":");
(expr as BodyMethodAST).PrintASM(levelTabulatiion, isNewLine);
ASM.WriteASMCode(levelTabulatiion + markerPrevBody + ":");
//ASM.WriteASMCode(levelTabulatiion + "jmp\t" + markerAfterBody);
//ASM.WriteASMCode(levelTabulatiion + markerPrevBody + ":");
//(expr as BodyMethodAST).PrintASM(levelTabulatiion, isNewLine);
//ASM.WriteASMCode(levelTabulatiion + markerAfterBody + ":");
}
public void PrintSringArray(string levelTabulatiion, int locateStack)
{
int startInStack = locateStack;
string type = "string";
string cutsSting = GetString();
ASM.WriteASMCode(levelTabulatiion + "mov\t" + ASMregisters.GetNameType(type) + " [ebp-" + locateStack + "], '" + cutsSting[0] + "'");
for (int i = 1; i < cutsSting.Length; i++)
{
locateStack = startInStack + (ASMregisters.GetSizeStep(type) * i);
ASMregisters.stepByte += ASMregisters.GetSizeStep(type);
ASM.WriteASMCode(levelTabulatiion + "mov\t" + ASMregisters.GetNameType(type) + " [ebp-" + locateStack + "], '" + cutsSting[i] + "'");
}
}
public override string Convert(ASM.ASMBlock theBlock)
{
StringBuilder ASMResult = new StringBuilder();
ASMResult.AppendLine(".globl " + TypeId);
ASMResult.AppendLine(".align 2");
ASMResult.AppendLine(TypeId + ":");
foreach (Tuple<string, Types.TypeInfo> aFieldInfo in FieldInformation)
{
string allocStr = ASMUtilities.GetAllocStringForSize(
aFieldInfo.Item2.IsValueType ? aFieldInfo.Item2.SizeOnHeapInBytes : aFieldInfo.Item2.SizeOnStackInBytes);
switch (aFieldInfo.Item1)
{
case "Size":
ASMResult.AppendLine(allocStr + " " + SizeVal);
break;
case "Id":
ASMResult.AppendLine(allocStr + " " + IdVal);
break;
case "StackSize":
ASMResult.AppendLine(allocStr + " " + StackSizeVal);
break;
case "IsValueType":
ASMResult.AppendLine(allocStr + " " + IsValueTypeVal);
break;
case "MethodTablePtr":
ASMResult.AppendLine(allocStr + " " + MethodTablePointer);
break;
case "IsPointer":
ASMResult.AppendLine(allocStr + " " + IsPointerTypeVal);
break;
case "TheBaseType":
ASMResult.AppendLine(allocStr + " " + BaseTypeIdVal);
break;
case "FieldTablePtr":
ASMResult.AppendLine(allocStr + " " + FieldTablePointer);
break;
case "Signature":
ASMResult.AppendLine(allocStr + " " + TypeSignatureLiteralLabel);
break;
case "IdString":
ASMResult.AppendLine(allocStr + " " + TypeIdLiteralLabel);
break;
}
}
ASMResult.AppendLine();
return ASMResult.ToString();
}
public ASMViewModel GetDetail(int id)
{
IRepository <ASM> repo = _unitOfWork.GetRepository <ASM>();
repo.Condition = PredicateBuilder.True <ASM>().And(x => x.NIK == id);
ASM item = repo.Find().FirstOrDefault();
if (item == null)
{
return(null);
}
return(GetASMViewModel(item));
}
public static void Attack(this Character character)
{
var asm = new ASM();
{
asm.Pushad();
asm.Mov_EAX(0x5A80C0);
asm.Call_EAX();
asm.Popad();
asm.Ret();
}
asm.Run(character.CharacterBase.Core);
}
public override void PrintASM(string levelTabulatiion, bool isNewLine = false)
{
markerJumpPrevBody = ASMregisters.GetNewMarkerJumpPrevBody();
markerJumpAfterBody = ASMregisters.GetNewMarkerJumpAfterBody();
ASMregisters.ClearMarkerPrevBody();
ASM.WriteASMCode(levelTabulatiion + markerJumpPrevBody + ":");
ASMregisters.isContitionBelongsToCicle = true;
PrintCondition(levelTabulatiion + "\t", false);
ASM.WriteASMCode(levelTabulatiion + "\t" + "jmp" + "\t" + markerJumpPrevBody);
ASM.WriteASMCode(levelTabulatiion + markerJumpAfterBody + ":");
}
public static void MoveBackgroundRAM(byte[] F37F90, byte[] F9CAE0, uint decompressedRam, uint compressedRam)
{
uint upperCompressed = compressedRam >> 16;
uint lowerCompressed = (compressedRam & 0x0000FFFF);
uint upperDecompressed = decompressedRam >> 16;
uint lowerDecompressed = (decompressedRam & 0x0000FFFF);
int fileOffset = 0x7520;
// Hook to Background loading routine.
ASM.WriteCommand(F37F90, 0x83124, 0x0C0DAAAC); // JAL 8036AAB0
// Custom Background Loader Subroutine.
ASM.WriteCommand(F9CAE0, fileOffset, 0x3C088038); // LUI T0, 0x8038
ASM.WriteCommand(F9CAE0, fileOffset += 4, 0x25083CC4); // AddIU T0, T0, 0x3CC4
ASM.WriteCommand(F9CAE0, fileOffset += 4, 0x8D080000); // LW T0, 0x0000(T0) ; RAM Offset of File Lookup Table
ASM.WriteCommand(F9CAE0, fileOffset += 4, 0x000448C0); // SLL T1, A0, 3 ; Multiply Background Id by 8 to get position in lookup table
ASM.WriteCommand(F9CAE0, fileOffset += 4, 0x01285021); // ADDU T2, T1, T0 ; Ram Pointer to Background ID ROM Offset (from 101C50)
ASM.WriteCommand(F9CAE0, fileOffset += 4, 0x8D490000); // LW T1, 0x0000 (T2) ; Address from 101C50 of Background
ASM.WriteCommand(F9CAE0, fileOffset += 4, 0x8D480008); // LW T0, 0x0008 (T2) ; Address from 101C50 of next file
ASM.WriteCommand(F9CAE0, fileOffset += 4, 0x01093022); // SUB A2, T0, T1 ; Compressed Size
ASM.WriteCommand(F9CAE0, fileOffset += 4, 0x3C0A8038); // LUI T2, 0x8038
ASM.WriteCommand(F9CAE0, fileOffset += 4, 0x354A3CCC); // ORI T2, T2, 0x3CCC
ASM.WriteCommand(F9CAE0, fileOffset += 4, 0x8D4A0000); // LW T2, 0x0000 (T2) ; Store 0x101C50 to REG T2
ASM.WriteCommand(F9CAE0, fileOffset += 4, 0x3C040000 + upperCompressed); // LUI A0, upperCompressed
ASM.WriteCommand(F9CAE0, fileOffset += 4, 0x34840000 + lowerCompressed); // ORI A0, A0, lowerCompressed ; Where to store compressed data in RAM
ASM.WriteCommand(F9CAE0, fileOffset += 4, 0x0C09017C); // JAL 0x802405F0 ; Subroutine call: Load compressed data
ASM.WriteCommand(F9CAE0, fileOffset += 4, 0x012A2821); // ADDU A1, T1, T2 ; Finally get ROM address
ASM.WriteCommand(F9CAE0, fileOffset += 4, 0x3C040000 + upperCompressed); // LUI A0, upperCompressed
ASM.WriteCommand(F9CAE0, fileOffset += 4, 0x34840000 + lowerCompressed); // ORI A0, A0, lowerCompressed ; Where compressed data is stored (RAM)
ASM.WriteCommand(F9CAE0, fileOffset += 4, 0x3C050000 + upperDecompressed); // LUI A1, upperDecompressed
ASM.WriteCommand(F9CAE0, fileOffset += 4, 0x0C08F828); // JAL 0x8023E0A0 ; Subroutine Call: Decompress data
ASM.WriteCommand(F9CAE0, fileOffset += 4, 0x34A50000 + lowerDecompressed); // ORI A1, A1, lowerDecompressed ; Write decompressed data to decompressedRam address
ASM.WriteCommand(F9CAE0, fileOffset += 4, 0x3C020000 + upperDecompressed); // LUI V0, upperDecompressed
ASM.WriteCommand(F9CAE0, fileOffset += 4, 0x34420000 + lowerDecompressed); // ORI V0, V0, lowerDecompressed ; Pointer to the decompressed data
ASM.WriteCommand(F9CAE0, fileOffset += 4, 0x080C282F); // J 0x8030A0BC ; Return to caller
ASM.WriteCommand(F9CAE0, fileOffset += 4, 0x00000000); // NOP
}
void ReadFromFile(string filePath)
{
XElement xd = XElement.Load(filePath);
foreach (XElement xel in xd.Elements())
{
ASM asm = new ASM();
asm.name = xel.Attribute("name").Value;
foreach (XElement childxel in xel.Elements())
{
CHILD child = new CHILD();
child.name = childxel.Attribute("name").Value;
foreach (XElement chprop in childxel.Elements())
{
switch (chprop.Name.ToString())
{
case "translateFrom":
string[] transtring = chprop.Value.Split(' ');
child.translateFrom = new Vector3(ConvertToFloat(transtring[0]), ConvertToFloat(transtring[1]), ConvertToFloat(transtring[2]));
//Console.WriteLine("\t\tT " + chprop.Value);
break;
case "alphaFromTo":
string[] astring = chprop.Value.Split(' ');
child.alphaFromTo = new Vector2(ConvertToFloat(astring[0]), ConvertToFloat(astring[1]));
//Console.WriteLine("\t\tA " + chprop.Value);
break;
case "durationFrames":
child.durationFrames = ConvertToInt(chprop.Value);
//Console.WriteLine("\t\tD " + chprop.Value);
break;
case "extraInstruction":
child.extraInstruction = chprop.Value;
//Console.WriteLine("\t\tE " + chprop.Value);
break;
default:
Debug.LogError("error!");
break;
}
}
asm.childList.Add(child);
}
asmDict.Add(asm.name, asm);
}
}
public override string Convert(ASM.ASMBlock theBlock)
{
int numBytes = -(int)Size;
string storeOp = "";
switch (Size)
{
case OperandSize.Byte:
storeOp = "sb";
break;
case OperandSize.Halfword:
storeOp = "sh";
break;
case OperandSize.Word:
storeOp = "sw";
break;
}
return @"addi $sp, $sp, " + numBytes + "\r\n" +
storeOp + " " + Src + @", 0($sp)";
}
public override string Convert(ASM.ASMBlock theBlock)
{
if (Signed)
{
if (!string.IsNullOrWhiteSpace(Aux))
{
return "imul " + Arg + ", " + Src + ", " + Aux;
}
else if (!string.IsNullOrWhiteSpace(Src))
{
return "imul " + Arg + ", " + Src;
}
else
{
return "imul " + Arg;
}
}
else
{
return "mul " + Arg;
}
}
public override void CleanUpAssemblyCode(ASM.ASMBlock TheBlock, ref string ASMText)
{
// Create lists of extern and global labels
TheBlock.ExternalLabels.Clear();
List<string> ExternLines = ASMText.Replace("\r", "")
.Split('\n')
.Where(x => x.ToLower().Contains("extern "))
.Select(x => x.Split(' ')[1].Split(':')[0])
.ToList();
TheBlock.ExternalLabels.AddRange(ExternLines);
TheBlock.GlobalLabels.Clear();
List<string> GlobalLines = ASMText.Replace("\r", "")
.Split('\n')
.Where(x => x.ToLower().Contains("global "))
.Select(x => x.Split(' ')[1].Split(':')[0])
.ToList();
TheBlock.GlobalLabels.AddRange(GlobalLines);
ASMText = ASMText.Replace("GLOBAL ", "global ");
ASMText = ASMText.Replace("EXTERN ", "extern ");
}
/// <summary>
/// Scans the specified type's methods.
/// </summary>
/// <param name="TheLibrary">The library currently being compiled.</param>
/// <param name="TheTypeInfo">The type to scan the methods of.</param>
/// <param name="MethodTablesBlock">The ASM block for the methods table for the library currently being compiled.</param>
private static void ScanMethods(ILLibrary TheLibrary, Types.TypeInfo TheTypeInfo, ASM.ASMBlock MethodTablesBlock)
{
string currentTypeId = TheTypeInfo.ID;
string currentTypeName = TheTypeInfo.UnderlyingType.FullName;
List<Tuple<string, string>> AllMethodInfo = new List<Tuple<string, string>>();
if (TheTypeInfo.UnderlyingType.BaseType == null || TheTypeInfo.UnderlyingType.BaseType.FullName != "System.Array")
{
foreach (Types.MethodInfo aMethodInfo in TheTypeInfo.MethodInfos)
{
if (!aMethodInfo.IsStatic && !aMethodInfo.UnderlyingInfo.IsAbstract)
{
string methodID = aMethodInfo.ID;
string methodIDValue = aMethodInfo.IDValue.ToString();
MethodTablesBlock.AddExternalLabel(methodID);
AllMethodInfo.Add(new Tuple<string, string>(methodID, methodIDValue));
}
}
}
string parentTypeMethodTablePtr = "0";
bool parentPtrIsExternal = false;
if (TheTypeInfo.UnderlyingType.BaseType != null)
{
if (!TheTypeInfo.UnderlyingType.BaseType.AssemblyQualifiedName.Contains("mscorlib"))
{
Types.TypeInfo baseTypeInfo = TheLibrary.GetTypeInfo(TheTypeInfo.UnderlyingType.BaseType);
parentPtrIsExternal = (ScannedTypes.ContainsKey(baseTypeInfo.ID) && ScannedTypes[baseTypeInfo.ID] != TheLibrary)
|| !TheLibrary.TypeInfos.Contains(baseTypeInfo);
parentTypeMethodTablePtr = baseTypeInfo.ID + "_MethodTable";
}
}
{
string methodID = parentTypeMethodTablePtr;
string methodIDValue = "0";
if (parentPtrIsExternal)
{
MethodTablesBlock.AddExternalLabel(methodID);
}
AllMethodInfo.Add(new Tuple<string,string>(methodID, methodIDValue));
}
List<Tuple<string, int>> TableEntryFieldInfos = GetSpecialClassFieldInfo(TheLibrary, typeof(Attributes.MethodInfoStructAttribute));
ASM.ASMOp newMethodTableOp = TargetArchitecture.CreateASMOp(ASM.OpCodes.MethodTable,
currentTypeId, currentTypeName, AllMethodInfo, TableEntryFieldInfos);
MethodTablesBlock.Append(newMethodTableOp);
}
public override string Convert(ASM.ASMBlock theBlock)
{
return "int" + IntNum;
}
public override string Convert(ASM.ASMBlock theBlock)
{
return "jal " + Target + "\r\nnop";
}
/// <summary>
/// Scans the specified type (excludes fields and methods).
/// </summary>
/// <param name="TheLibrary">The library currently being compiled.</param>
/// <param name="TheTypeInfo">The type to scan.</param>
/// <param name="TypesTableBlock">The ASM block for the types table for the library currently being compiled.</param>
private static void ScanType(ILLibrary TheLibrary, Types.TypeInfo TheTypeInfo, ASM.ASMBlock TypesTableBlock)
{
string TypeId = TheTypeInfo.ID;
string SizeVal = TheTypeInfo.SizeOnHeapInBytes.ToString();
string IdVal = (TypesScanned++).ToString();
string StackSizeVal = TheTypeInfo.SizeOnStackInBytes.ToString();
string IsValueTypeVal = (TheTypeInfo.IsValueType ? "1" : "0");
string MethodTablePointer = TypeId + "_MethodTable";
string IsPointerTypeVal = (TheTypeInfo.IsPointer ? "1" : "0");
string BaseTypeIdVal = "0";
if (TheTypeInfo.UnderlyingType.BaseType != null)
{
if (!TheTypeInfo.UnderlyingType.BaseType.AssemblyQualifiedName.Contains("mscorlib"))
{
Types.TypeInfo baseTypeInfo = TheLibrary.GetTypeInfo(TheTypeInfo.UnderlyingType.BaseType);
BaseTypeIdVal = baseTypeInfo.ID;
//Declared external to this library, so won't appear in this library's type tables
if ((ScannedTypes.ContainsKey(baseTypeInfo.ID) &&
ScannedTypes[baseTypeInfo.ID] != TheLibrary) ||
!TheLibrary.TypeInfos.Contains(baseTypeInfo))
{
TypesTableBlock.AddExternalLabel(BaseTypeIdVal);
}
}
}
string FieldTablePointer = TypeId + "_FieldTable";
string TypeSignatureLiteralLabel = TheLibrary.AddStringLiteral(TheTypeInfo.UnderlyingType.FullName); // Legacy
string TypeIdLiteralLabel = TheLibrary.AddStringLiteral(TheTypeInfo.ID);
Types.TypeInfo typeTypeInfo = ILLibrary.SpecialClasses[typeof(Attributes.TypeClassAttribute)].First();
List<Types.FieldInfo> OrderedFields = typeTypeInfo.FieldInfos.Where(x => !x.IsStatic).OrderBy(x => x.OffsetInBytes).ToList();
List<Tuple<string, Types.TypeInfo>> FieldInformation = new List<Tuple<string, Types.TypeInfo>>();
foreach (Types.FieldInfo aTypeField in OrderedFields)
{
Types.TypeInfo FieldTypeInfo = TheLibrary.GetTypeInfo(aTypeField.FieldType);
FieldInformation.Add(new Tuple<string, Types.TypeInfo>(aTypeField.Name, FieldTypeInfo));
}
ASM.ASMOp newTypeTableOp = TargetArchitecture.CreateASMOp(ASM.OpCodes.TypeTable,
TypeId, SizeVal, IdVal, StackSizeVal, IsValueTypeVal, MethodTablePointer, IsPointerTypeVal,
BaseTypeIdVal, FieldTablePointer, TypeSignatureLiteralLabel, TypeIdLiteralLabel, FieldInformation);
TypesTableBlock.Append(newTypeTableOp);
TypesTableBlock.AddExternalLabel(MethodTablePointer);
TypesTableBlock.AddExternalLabel(FieldTablePointer);
TypesTableBlock.AddExternalLabel(TypeSignatureLiteralLabel);
TypesTableBlock.AddExternalLabel(TypeIdLiteralLabel);
}
public override string Convert(ASM.ASMBlock theBlock)
{
return "push " + ASMUtilities.GetOpSizeStr(Size) + " " + Src;
}
public override void CleanUpAssemblyCode(ASM.ASMBlock TheBlock, ref string ASMText)
{
}
public override string Convert(ASM.ASMBlock theBlock)
{
return "and " + Dest + ", " + Src;
}
public override string Convert(ASM.ASMBlock theBlock)
{
return "sll " + Dest + ", " + Src + ", " + Bits;
}
public override string Convert(ASM.ASMBlock theBlock)
{
return "call " + Target;
}
public override string Convert(ASM.ASMBlock theBlock)
{
return "nop";
}
/// <summary>
/// Scans the specified type's static fields.
/// </summary>
/// <param name="TheLibrary">The library currently being compiled.</param>
/// <param name="TheTypeInfo">The type to scan the static fields of.</param>
/// <param name="StaticFieldsBlock">The ASM block for the static fields for the library currently being compiled.</param>
private static void ScanStaticFields(ILLibrary TheLibrary, Types.TypeInfo TheTypeInfo, ASM.ASMBlock StaticFieldsBlock)
{
foreach (Types.FieldInfo aFieldInfo in TheTypeInfo.FieldInfos)
{
if (aFieldInfo.IsStatic)
{
Types.TypeInfo fieldTypeInfo = TheLibrary.GetTypeInfo(aFieldInfo.FieldType);
string FieldID = aFieldInfo.ID;
string Size = fieldTypeInfo.SizeOnStackInBytes.ToString();
ASM.ASMOp newStaticFieldOp = TargetArchitecture.CreateASMOp(ASM.OpCodes.StaticField, FieldID, Size);
StaticFieldsBlock.Append(newStaticFieldOp);
}
}
}
/// <summary>
/// Scans the specified type's non-static fields.
/// </summary>
/// <param name="TheLibrary">The library currently being compiled.</param>
/// <param name="TheTypeInfo">The type to scan the non-static fields of.</param>
/// <param name="FieldTablesBlock">The ASM block for the fields table for the library currently being compiled.</param>
private static void ScanFields(ILLibrary TheLibrary, Types.TypeInfo TheTypeInfo, ASM.ASMBlock FieldTablesBlock)
{
string currentTypeId = TheTypeInfo.ID;
string currentTypeName = TheTypeInfo.UnderlyingType.FullName;
List<Tuple<string, string, string>> AllFieldInfo = new List<Tuple<string, string, string>>();
if (TheTypeInfo.UnderlyingType.BaseType == null || (TheTypeInfo.UnderlyingType.BaseType.FullName != "System.Array" &&
TheTypeInfo.UnderlyingType.BaseType.FullName != "System.MulticastDelegate"))
{
foreach (Types.FieldInfo anOwnField in TheTypeInfo.FieldInfos)
{
if (!anOwnField.IsStatic)
{
Types.TypeInfo FieldTypeInfo = TheLibrary.GetTypeInfo(anOwnField.FieldType);
string fieldOffsetVal = anOwnField.OffsetInBytes.ToString();
string fieldSizeVal = (FieldTypeInfo.IsValueType ? FieldTypeInfo.SizeOnHeapInBytes : FieldTypeInfo.SizeOnStackInBytes).ToString();
string fieldTypeIdVal = FieldTypeInfo.ID;
FieldTablesBlock.AddExternalLabel(fieldTypeIdVal);
AllFieldInfo.Add(new Tuple<string, string, string>(fieldOffsetVal, fieldSizeVal, fieldTypeIdVal));
}
}
}
string parentTypeFieldTablePtr = "0";
bool parentPtrIsExternal = false;
if (TheTypeInfo.UnderlyingType.BaseType != null)
{
if (!TheTypeInfo.UnderlyingType.BaseType.AssemblyQualifiedName.Contains("mscorlib"))
{
Types.TypeInfo baseTypeInfo = TheLibrary.GetTypeInfo(TheTypeInfo.UnderlyingType.BaseType);
parentPtrIsExternal = (ScannedTypes.ContainsKey(baseTypeInfo.ID) &&
ScannedTypes[baseTypeInfo.ID] != TheLibrary) || !TheLibrary.TypeInfos.Contains(baseTypeInfo);
parentTypeFieldTablePtr = baseTypeInfo.ID + "_FieldTable";
}
}
{
string fieldOffsetVal = "0";
string fieldSizeVal = "0";
string fieldTypeIdVal = parentTypeFieldTablePtr;
if (parentPtrIsExternal)
{
FieldTablesBlock.AddExternalLabel(fieldTypeIdVal);
}
AllFieldInfo.Add(new Tuple<string, string, string>(fieldOffsetVal, fieldSizeVal, fieldTypeIdVal));
}
List<Tuple<string, int>> TableEntryFieldInfos = GetSpecialClassFieldInfo(TheLibrary, typeof(Attributes.FieldInfoStructAttribute));
ASM.ASMOp newFieldTableOp = TargetArchitecture.CreateASMOp(ASM.OpCodes.FieldTable,
currentTypeId, currentTypeName, AllFieldInfo, TableEntryFieldInfos);
FieldTablesBlock.Append(newFieldTableOp);
}
/// <summary>
/// Gets the order of two ASM blocks based on their priorities.
/// </summary>
/// <param name="a">First block to order.</param>
/// <param name="b">Second block to order.</param>
/// <returns>/// -1 = a before b, 0 = a or b in either order, +1 = a after b.</returns>
public static int GetOrder(ASM.ASMBlock a, ASM.ASMBlock b)
{
return a.Priority.CompareTo(b.Priority);
}
public override string Convert(ASM.ASMBlock theBlock)
{
return string.Format("GLOBAL {0}:data\r\n{0}: times {1} db 0", FieldID, Size);
}
