public OpCodeDescription GetDesc(PapyrusOpCodes code) { lock (descLock) { return(Instructions.FirstOrDefault(i => i.OpCode == code)); } }
public static PapyrusInstructionOpCodeDescription FromOpCode(PapyrusOpCodes opcode) { if (Descriptions.ContainsKey(opcode)) { return(Descriptions[opcode]); } return(null); }
/// <summary> /// Initializes a new instance of the <see cref="PapyrusAsmInstruction" /> class. /// </summary> /// <param name="opcode">The opcode.</param> /// <param name="argumentCount">The argument count.</param> /// <param name="hasOperandArguments">if set to <c>true</c> [has operand arguments].</param> /// <param name="aliases">The aliases.</param> public PapyrusAsmInstruction(PapyrusOpCodes opcode, int argumentCount, bool hasOperandArguments, params string[] aliases) { this.opcode = opcode; this.aliases = aliases; ArgumentCount = argumentCount; HasOperandArguments = hasOperandArguments; For.Do(argumentCount, () => args.Add(new PapyrusAsmValue())); //For.Do(argumentCount, () => opargs.Add(new PapyrusAsmValue())); }
public static string GetDescription(this PapyrusOpCodes code) { switch (code) { case PapyrusOpCodes.Iadd: return ("Integer Add math operator, takes two references or constant values and adds them together and then assigns the result to the destination variable."); case PapyrusOpCodes.Fadd: return ("Float Add math operator, takes two references or constant values and adds them together and then assigns the result to the destination variable."); case PapyrusOpCodes.Return: return ("Terminate the method and returns a value. If the method is a void (none) it should return a ::nonevar."); case PapyrusOpCodes.Callparent: return ("Invokes a parent method from inside a state by its name, using a location reference, set of arguments and assigns the result to the destination variable."); case PapyrusOpCodes.Callstatic: return ("Invokes a static method by its name, using a location reference, set of arguments and assigns the result to the destination variable."); case PapyrusOpCodes.Callmethod: return ("Invokes a instance method by its name, using a location reference, set of arguments and assigns the result to the destination variable."); case PapyrusOpCodes.Cast: return("Casts variable, parameter or reference into the same type as the target reference."); case PapyrusOpCodes.ArrayCreate: return ("Creates a new array instance of a target type and size and then assigns the destination variable with the new array."); case PapyrusOpCodes.ArrayLength: return("Gets the length of the target array and assigns the destination variable with the count."); case PapyrusOpCodes.Assign: return("Assign a field, variable or parameter with the target value."); case PapyrusOpCodes.Jmp: return("Jumps to the target instruction by an offset from the current position."); case PapyrusOpCodes.Jmpf: return ("If the condition is false then jump to the target instruction by an offset from the current position."); case PapyrusOpCodes.Jmpt: return ("If the condition is true then jump to the target instruction by an offset from the current position."); } return("This OpCode has not yet been documented."); }
//public static string GetArgumentsDescription(this PapyrusOpCodes code) //{ // var noArgs = "No arguments expected."; // switch (code) // { // case PapyrusOpCodes.PropSet: // return "[0] Constant String: Property Name\r\n[1] Reference or Constant: Location\r\n[2] Reference or Constant: Value"; // case PapyrusOpCodes.PropGet: // return "[0] Constant String: Property Name\r\n[1] Reference or Constant: Location\r\n[2] Reference: Destination"; // case PapyrusOpCodes.Assign: // return "[0] Reference or Constant: Value\r\n[1] Reference: Destination"; // case PapyrusOpCodes.Callstatic: // return "[0] Reference or Constant: Location/Class\r\n[1] Constant String: Method Name\r\n[2] Reference: Destination"; // case PapyrusOpCodes.Callmethod: // return "[0] Constant String: Method Name\r\n[1] Reference or Constant: Location/Class\r\n[2] Reference: Destination"; // case PapyrusOpCodes.Return: // return "[0] Reference or Constant: value\r\n[1] (Expects ::nonevar if void)"; // case PapyrusOpCodes.CmpEq: // case PapyrusOpCodes.CmpGte: // case PapyrusOpCodes.CmpGt: // case PapyrusOpCodes.CmpLt: // case PapyrusOpCodes.CmpLte: // return "[0] Reference: Destination\r\n[1] Reference or Constant: Value\r\n[2] Reference or Constant: Value"; // case PapyrusOpCodes.Jmp: // return "[0] Constant Integer: offset from current position"; // case PapyrusOpCodes.Jmpf: // return "[0] Reference Bool: Conditional\r\n[1] Constant Integer: offset from current position"; // case PapyrusOpCodes.Jmpt: // return "[0] Reference Bool: Conditional\r\n[1] Constant Integer: offset from current position"; // } // return "This OpCode has no arguments or the arguments has not yet been documented."; //} public static string GetOperandArgumentsDescription(this PapyrusOpCodes code) { var noArgs = "No operand arguments expected."; switch (code) { case PapyrusOpCodes.Callparent: case PapyrusOpCodes.Callstatic: case PapyrusOpCodes.Callmethod: return("Method Parameters can be either Constant or Reference. One parameter per row."); default: return(noArgs); } }
private bool IsJump(PapyrusOpCodes opCode) { return(opCode == PapyrusOpCodes.Jmp || opCode == PapyrusOpCodes.Jmpf || opCode == PapyrusOpCodes.Jmpt); }
/// <summary> /// Sets the op code. /// </summary> /// <param name="opcode">The opcode.</param> public void SetOpCode(PapyrusOpCodes opcode) => this.opcode = opcode;
/// <summary> /// Creates a papyrus call instruction. /// </summary> /// <param name="mainInstructionProcessor">The main instruction processor.</param> /// <param name="callOpCode">The call op code.</param> /// <param name="methodRef">The method reference.</param> /// <param name="callerLocation">The caller location.</param> /// <param name="destinationVariable">The destination variable.</param> /// <param name="parameters">The parameters.</param> /// <param name="structGets">The structure gets.</param> /// <param name="methodName">Name of the method.</param> /// <returns></returns> public PapyrusInstruction CreatePapyrusCallInstruction( IClrInstructionProcessor mainInstructionProcessor, PapyrusOpCodes callOpCode, MethodReference methodRef, string callerLocation, string destinationVariable, List <object> parameters, out List <PapyrusInstruction> structGets, string methodName = null) { structGets = new List <PapyrusInstruction>(); var inst = new PapyrusInstruction { OpCode = callOpCode }; var param = parameters.ToArray(); for (var index = 0; index < param.Length; index++) { var p = param[index]; PapyrusStructFieldReference structRef = null; var evalItem = p as EvaluationStackItem; if (evalItem != null) { structRef = evalItem.Value as PapyrusStructFieldReference; } if (structRef == null) { structRef = p as PapyrusStructFieldReference; } if (structRef != null) { var structSource = structRef.StructSource as PapyrusFieldDefinition; var structField = structRef.StructVariable; var fieldType = GetStructFieldType(papyrusAssemblyCollection, structSource, structField); // 1. Create Temp Var bool isStructAccess; var tempVar = mainInstructionProcessor.GetTargetVariable(currentInstruction, null, out isStructAccess, fieldType, true); param[index] = mainInstructionProcessor.CreateVariableReferenceFromName(tempVar); // 2. StructGet -> tempVar // 3. Assign var <- tempVar structGets.Add(mainInstructionProcessor.CreatePapyrusInstruction( PapyrusOpCodes.StructGet, mainInstructionProcessor.CreateVariableReferenceFromName(tempVar), structSource, structField)); } } methodName = methodName ?? methodRef.Name; if (callOpCode == PapyrusOpCodes.Callstatic) { inst.Arguments.AddRange(mainInstructionProcessor.ParsePapyrusParameters(new object[] { mainInstructionProcessor.CreateVariableReference(PapyrusPrimitiveType.Reference, callerLocation), mainInstructionProcessor.CreateVariableReference(PapyrusPrimitiveType.Reference, methodName), mainInstructionProcessor.CreateVariableReference(PapyrusPrimitiveType.Reference, destinationVariable) })); } else { inst.Arguments.AddRange(mainInstructionProcessor.ParsePapyrusParameters(new object[] { mainInstructionProcessor.CreateVariableReference(PapyrusPrimitiveType.Reference, methodName), mainInstructionProcessor.CreateVariableReference(PapyrusPrimitiveType.Reference, callerLocation), mainInstructionProcessor.CreateVariableReference(PapyrusPrimitiveType.Reference, destinationVariable) })); } inst.OperandArguments.AddRange(EnsureParameterTypes(mainInstructionProcessor, methodRef.Parameters, mainInstructionProcessor.ParsePapyrusParameters(param))); inst.Operand = methodRef; return(inst); }
public PapyrusOpCodes TryInvertJump(PapyrusOpCodes jmpt) { throw new NotImplementedException(); }
public PapyrusInstruction ConditionalJump(PapyrusOpCodes jumpType, PapyrusVariableReference conditionalVar, object destinationInstruction) { throw new NotImplementedException(); }
public PapyrusInstruction CreatePapyrusInstruction(PapyrusOpCodes papyrusOpCode, params object[] values) { throw new NotImplementedException(); }
/// <summary> /// Gets the size of the instruction parameter. /// </summary> /// <param name="opcode">The opcode.</param> /// <returns></returns> public static int GetInstructionParamSize(this PapyrusOpCodes opcode) { return(PapyrusInstructionOpCodeDescription.FromOpCode(opcode).ArgumentCount); }