コード例 #1
0
        /// <summary>
        /// Parses the instruction.
        /// </summary>
        /// <param name="mainProcessor">The main processor.</param>
        /// <param name="asmCollection">The papyrus assembly collection.</param>
        /// <param name="instruction">The instruction.</param>
        /// <param name="targetMethod">The target method.</param>
        /// <param name="type">The type.</param>
        /// <returns></returns>
        public IEnumerable <PapyrusInstruction> Process(
            IClrInstructionProcessor mainProcessor,
            IReadOnlyCollection <PapyrusAssemblyDefinition> asmCollection,
            Instruction instruction,
            MethodDefinition targetMethod,
            TypeDefinition type)
        {
            var allVariables = mainProcessor.PapyrusMethod.GetVariables();

            if (InstructionHelper.IsStoreElement(instruction.OpCode.Code))
            {
                var popCount = Utility.GetStackPopCount(instruction.OpCode.StackBehaviourPop);
                if (mainProcessor.EvaluationStack.Count >= popCount)
                {
                    var newValue  = mainProcessor.EvaluationStack.Pop();
                    var itemIndex = mainProcessor.EvaluationStack.Pop();
                    var itemArray = mainProcessor.EvaluationStack.Pop();

                    object targetItemIndex = null;
                    object targetItemArray = null;
                    object targetItemValue = null;

                    if (itemIndex.Value is PapyrusVariableReference)
                    {
                        targetItemIndex = itemIndex.Value as PapyrusVariableReference;
                    }
                    else if (itemIndex.Value != null)
                    {
                        targetItemIndex = itemIndex.Value;
                    }

                    if (mainProcessor.PapyrusAssembly.VersionTarget == PapyrusVersionTargets.Skyrim)
                    {
                        if ((targetItemIndex as int?) > 128)
                        {
                            targetItemIndex = 128;
                        }
                    }

                    if (itemArray.Value is PapyrusVariableReference)
                    {
                        targetItemArray = itemArray.Value as PapyrusVariableReference;
                    }

                    if (newValue.Value is PapyrusVariableReference)
                    {
                        targetItemValue = newValue.Value as PapyrusVariableReference;
                    }
                    else if (newValue.Value != null)
                    {
                        targetItemValue = newValue.Value;
                    }


                    return
                        (ArrayUtility.ArrayOf(
                             mainProcessor.CreatePapyrusInstruction(PapyrusOpCodes.ArraySetElement,
                                                                    targetItemArray, targetItemIndex,
                                                                    targetItemValue)));
                    //return "ArraySetElement " + tar + " " + oidx + " " + val;
                }
            }

            if (InstructionHelper.IsStoreLocalVariable(instruction.OpCode.Code) ||
                InstructionHelper.IsStoreFieldObject(instruction.OpCode.Code))
            {
                if (instruction.Operand is FieldReference)
                {
                    var fref = instruction.Operand as FieldReference;
                    // if the EvaluationStack.Count == 0
                    // The previous instruction might have been a call that returned a value
                    // Something we did not store...

                    if (mainProcessor.EvaluationStack.Count == 0 &&
                        InstructionHelper.IsCallMethod(instruction.Previous.OpCode.Code))
                    {
                        // If previous was a call, then we should have the evaluation stack with at least one item.
                        // But it seem like we don't... Inject tempvar?
                    }

                    if (mainProcessor.EvaluationStack.Count > 0)
                    {
                        var obj = mainProcessor.EvaluationStack.Pop();

                        var definedField = mainProcessor.PapyrusType.Fields.FirstOrDefault(
                            f => f.Name.Value == "::" + fref.Name.Replace('<', '_').Replace('>', '_'));

                        if (definedField == null)
                        {
                            definedField = mainProcessor.GetDelegateField(fref);
                        }

                        if (mainProcessor.EvaluationStack.Count > 0)
                        {
                            var nextObj = mainProcessor.EvaluationStack.Peek();

                            if (nextObj != null && nextObj.TypeName != null && nextObj.TypeName.Contains("#"))
                            {
                                // Store into Struct field.
                                definedField = nextObj.Value as PapyrusFieldDefinition;
                                var structPropName = fref.Name;
                                mainProcessor.EvaluationStack.Pop();
                                // Just pop it so it does not interfere with any other instructions
                                return
                                    (ArrayUtility.ArrayOf(
                                         mainProcessor.CreatePapyrusInstruction(PapyrusOpCodes.StructSet,
                                                                                definedField, // location
                                                                                mainProcessor.CreateVariableReferenceFromName(structPropName),
                                                                                              // Struct Property/Field Name
                                                                                obj.Value     // value
                                                                                )));
                            }
                        }


                        if (definedField != null)
                        {
                            var structRef = obj.Value as PapyrusStructFieldReference;
                            if (structRef != null)
                            {
                                // StructGet -> TempVar
                                // Var <- TempVar

                                var structSource = structRef.StructSource as PapyrusFieldDefinition;
                                var structField  = structRef.StructVariable;

                                var fieldType = GetStructFieldType(asmCollection, structSource, structField);

                                // 1. Create Temp Var
                                bool isStructAccess;
                                var  tempVar = mainProcessor.GetTargetVariable(instruction, null,
                                                                               out isStructAccess,
                                                                               fieldType, true);

                                // 2. StructGet -> tempVar
                                // 3. Assign var <- tempVar
                                return(ArrayUtility.ArrayOf(
                                           mainProcessor.CreatePapyrusInstruction(PapyrusOpCodes.StructGet,
                                                                                  mainProcessor.CreateVariableReferenceFromName(tempVar), structSource,
                                                                                  structField),
                                           mainProcessor.CreatePapyrusInstruction(PapyrusOpCodes.Assign,
                                                                                  definedField, mainProcessor.CreateVariableReferenceFromName(tempVar))));
                            }
                            if (obj.Value is PapyrusParameterDefinition)
                            {
                                var varRef = obj.Value as PapyrusParameterDefinition;
                                // definedField.FieldVariable = varRef.;

                                // CreatePapyrusInstruction(PapyrusOpCode.Assign, definedField.Name.Value, varRef.Name.Value)
                                return
                                    (ArrayUtility.ArrayOf(
                                         mainProcessor.CreatePapyrusInstruction(PapyrusOpCodes.Assign,
                                                                                definedField, varRef)));
                            }
                            if (obj.Value is PapyrusVariableReference)
                            {
                                var varRef = obj.Value as PapyrusVariableReference;
                                // definedField.Value = varRef.Value;
                                definedField.DefaultValue      = varRef;
                                definedField.DefaultValue.Type = PapyrusPrimitiveType.Reference;
                                // CreatePapyrusInstruction(PapyrusOpCode.Assign, definedField.Name.Value, varRef.Name.Value)
                                if (varRef.IsDelegateReference)
                                {
                                    return(new PapyrusInstruction[0]);
                                }
                                return
                                    (ArrayUtility.ArrayOf(
                                         mainProcessor.CreatePapyrusInstruction(PapyrusOpCodes.Assign,
                                                                                definedField, varRef)));
                            }
                            //definedField.FieldVariable.Value =
                            //    Utility.TypeValueConvert(definedField.FieldVariable.TypeName.Value, obj.Value);
                            var targetValue = valueTypeConverter.Convert(definedField.DefaultValue.TypeName.Value,
                                                                         obj.Value);

                            return
                                (ArrayUtility.ArrayOf(
                                     mainProcessor.CreatePapyrusInstruction(PapyrusOpCodes.Assign,
                                                                            definedField, targetValue)));
                            // definedField.FieldVariable.Value
                            // "Assign " + definedField.Name + " " + definedField.Value;
                        }
                    }
                }
                var    index  = (int)mainProcessor.GetNumericValue(instruction);
                object outVal = null;
                if (index < allVariables.Count)
                {
                    if (mainProcessor.EvaluationStack.Count > 0)
                    {
                        var heapObj = mainProcessor.EvaluationStack.Pop();

                        var structRef = heapObj.Value as PapyrusStructFieldReference;
                        if (structRef != null)
                        {
                            // Grabbing value from struct

                            var structSource = structRef.StructSource as PapyrusFieldDefinition;
                            var structField  = structRef.StructVariable;

                            var fieldType = GetStructFieldType(asmCollection, structSource, structField);

                            // 1. Create Temp Var
                            bool isStructAccess;
                            var  tempVar = mainProcessor.GetTargetVariable(instruction, null,
                                                                           out isStructAccess,
                                                                           fieldType, true);

                            // 2. StructGet -> tempVar
                            // 3. Assign var <- tempVar
                            return(ArrayUtility.ArrayOf(
                                       mainProcessor.CreatePapyrusInstruction(PapyrusOpCodes.StructGet,
                                                                              mainProcessor.CreateVariableReferenceFromName(tempVar), structSource,
                                                                              structField),
                                       mainProcessor.CreatePapyrusInstruction(PapyrusOpCodes.Assign,
                                                                              allVariables[index],
                                                                              mainProcessor.CreateVariableReferenceFromName(tempVar))));
                        }

                        if (heapObj.Value is PapyrusFieldDefinition)
                        {
                            heapObj.Value = (heapObj.Value as PapyrusFieldDefinition).DefaultValue;
                        }
                        if (heapObj.Value is PapyrusVariableReference)
                        {
                            var varRef = heapObj.Value as PapyrusVariableReference;
                            allVariables[index].Value = allVariables[index].Name.Value;
                            //varRef.Name.Value;
                            // "Assign " + allVariables[(int)index].Name.Value + " " + varRef.Name.Value;
                            return
                                (ArrayUtility.ArrayOf(
                                     mainProcessor.CreatePapyrusInstruction(PapyrusOpCodes.Assign,
                                                                            allVariables[index], varRef)));
                        }
                        // allVariables[index].Value
                        outVal = valueTypeConverter.Convert(allVariables[index].TypeName.Value, heapObj.Value);
                    }
                    var valout = outVal; //allVariables[index].Value;


                    //if (valout is string)
                    //{
                    //    stringValue = valout.ToString();
                    //}

                    if (valout is PapyrusFieldDefinition)
                    {
                        return
                            (ArrayUtility.ArrayOf(mainProcessor.CreatePapyrusInstruction(
                                                      PapyrusOpCodes.Assign, allVariables[index], valout as PapyrusFieldDefinition)));
                    }

                    if (valout is PapyrusVariableReference)
                    {
                        return
                            (ArrayUtility.ArrayOf(mainProcessor.CreatePapyrusInstruction(
                                                      PapyrusOpCodes.Assign, allVariables[index], valout as PapyrusVariableReference)));
                    }

                    if (valout is PapyrusParameterDefinition)
                    {
                        return
                            (ArrayUtility.ArrayOf(mainProcessor.CreatePapyrusInstruction(
                                                      PapyrusOpCodes.Assign, allVariables[index], valout as PapyrusParameterDefinition)));
                    }


                    // "Assign " + allVariables[(int)index].Name.Value + " " + valoutStr;

                    if (valout == null)
                    {
                        valout = "None";
                    }

                    if (allVariables[index].IsDelegateReference)
                    {
                        // If this is a delegate reference, then we do not want to assign this value to anything.
                        return(new PapyrusInstruction[0]);
                    }

                    return
                        (ArrayUtility.ArrayOf(mainProcessor.CreatePapyrusInstruction(PapyrusOpCodes.Assign,
                                                                                     allVariables[index], valout)));
                }
            }
            return(new PapyrusInstruction[0]);
        }