private PapyrusVariableReference ReadValueReference(PapyrusAssemblyDefinition asm, string name = null)
{
var tr = new PapyrusVariableReference(new PapyrusStringRef(asm, name),
(PapyrusPrimitiveType)pexReader.ReadByte());
switch (tr.Type)
{
case PapyrusPrimitiveType.Reference:
tr.Value = pexReader.ReadString();
break;
case PapyrusPrimitiveType.String:
tr.Value = pexReader.ReadString();
break;
case PapyrusPrimitiveType.Boolean:
tr.Value = pexReader.ReadByte();
break;
case PapyrusPrimitiveType.Float:
tr.Value = pexReader.ReadSingle();
break;
case PapyrusPrimitiveType.Integer:
tr.Value = pexReader.ReadInt32();
break;
default:
case PapyrusPrimitiveType.None:
break;
}
return(tr);
}
public PapyrusVariableEditorViewModel(IEnumerable <string> types, PapyrusVariableReference variable = null)
: base(types)
{
this.variable = variable;
if (this.variable != null)
{
Name = this.variable.Name.Value;
if (variable.TypeName.Value.Contains("[]"))
{
IsArray = true;
}
var ft =
variable.TypeName.Value.ToLower();
ft = ft.Replace("[]", "");
SelectedType = TypeReferences.FirstOrDefault(t => t.ToString().ToLower() == ft);
if (SelectedType == null)
{
SelectedType = this.variable.TypeName.Value.ToLower();
}
}
}
private void UpdateSelectedValue()
{
var val = selectedValueType as ComboBoxItem;
var tar = val.Content.ToString().ToLower();
if (tar == "variable" || tar == "parameter" || tar == "field" || tar == "self" || /*tar == "selfref" || */ tar == "none")
{
return;
}
if (tar == "string")
{
if (currentType.Assembly != null)
{
SelectedItem = new PapyrusVariableReference
{
Value = selectedConstantValue.ToString().Ref(currentType.Assembly).Value,
Type = PapyrusPrimitiveType.String
};
}
}
else
{
var type = Utility.GetPapyrusPrimitiveType(Utility.GetPapyrusReturnType(tar));
if (currentType.Assembly != null)
{
SelectedItem = new PapyrusVariableReference
{
Value = selectedConstantValue,
Type = type
};
}
}
}
public PapyrusInstruction CreatePapyrusCastInstruction(string destinationVariable,
PapyrusVariableReference variableToCast)
{
return(new PapyrusInstruction {
OpCode = PapyrusOpCodes.Cast
});
}
private void EditOpArg()
{
var dialog = new PapyrusReferenceAndConstantValueViewModel(loadedAssemblies, currentType, currentMethod,
null, null);
var result = dialogService.ShowDialog(dialog);
if (result == DialogResult.OK)
{
var i = OperandArguments.IndexOf(selectedOperandArgument);
OperandArguments.RemoveAt(i);
var papyrusVariableReference = new PapyrusVariableReference();
UpdateOperandArgument(dialog, ref papyrusVariableReference);
OperandArguments.Insert(i, papyrusVariableReference);
SelectedOperandArgument = papyrusVariableReference;
//// FFS! Just update? But nooo.. ObservableCollection refresh only triggers on remove/add :p
//var dummy = new PapyrusVariableReference();
//OperandArguments.Add(dummy);
//OperandArguments.Remove(dummy);
}
}
private void AddOpArg()
{
var dialog = new PapyrusReferenceAndConstantValueViewModel(loadedAssemblies, currentType, currentMethod,
null, null);
var result = dialogService.ShowDialog(dialog);
if (result == DialogResult.OK)
{
var papyrusVariableReference = new PapyrusVariableReference();
OperandArguments.Add(UpdateOperandArgument(dialog, ref papyrusVariableReference));
}
}
private void WriteValueReference(PapyrusVariableReference fieldVariable)
{
pexWriter.Write((byte)fieldVariable.Type);
switch (fieldVariable.Type)
{
case PapyrusPrimitiveType.Reference:
pexWriter.Write((string)fieldVariable.Value);
break;
case PapyrusPrimitiveType.String:
pexWriter.Write((string)fieldVariable.Value);
break;
case PapyrusPrimitiveType.Boolean:
{
if (fieldVariable.Value is bool)
{
// I think this is Acceptable :p
var value = (byte)((bool)fieldVariable.Value ? 1 : 0);
pexWriter.Write(value);
}
else
{
var val = fieldVariable.Value.ToString().ToLower();
pexWriter.Write((byte)(val == "true" || val == "1" ? 1 : 0));
}
;
}
break;
case PapyrusPrimitiveType.Float:
if (fieldVariable.Value is double)
{
pexWriter.Write((float)(double)fieldVariable.Value);
}
else
{
pexWriter.Write(float.Parse(fieldVariable.Value.ToString()));
}
break;
case PapyrusPrimitiveType.Integer:
#warning TODO: The value to write should NEVER need to be parsed.
pexWriter.Write(int.Parse(fieldVariable.Value.ToString()));
break;
default:
case PapyrusPrimitiveType.None:
break;
}
}
private PapyrusVariableReference UpdateOperandArgument(PapyrusReferenceAndConstantValueViewModel dialog,
ref PapyrusVariableReference papyrusVariableReference)
{
var asm = currentType.Assembly;
var targetType = Utility.GetPapyrusPrimitiveType(Utility.GetPapyrusReturnType(dialog.SelectedTypeName));
if (dialog.SelectedReferenceValue != null)
{
var paramRef = dialog.SelectedReferenceValue as PapyrusParameterDefinition;
var fieldRef = dialog.SelectedReferenceValue as PapyrusFieldDefinition;
var varRef = dialog.SelectedReferenceValue as PapyrusVariableReference;
if (varRef != null)
{
papyrusVariableReference.Value = varRef.Value;
papyrusVariableReference.Name = varRef.Name;
papyrusVariableReference.TypeName = varRef.TypeName;
papyrusVariableReference.Type = PapyrusPrimitiveType.Reference;
}
else if (fieldRef != null)
{
papyrusVariableReference.Value = fieldRef.Name.Value;
papyrusVariableReference.Name = fieldRef.Name;
papyrusVariableReference.TypeName = fieldRef.TypeName.Ref(asm);
papyrusVariableReference.Type = PapyrusPrimitiveType.Reference;
}
else if (paramRef != null)
{
papyrusVariableReference.Value = paramRef.Name.Value;
papyrusVariableReference.Name = paramRef.Name;
papyrusVariableReference.TypeName = paramRef.TypeName;
papyrusVariableReference.Type = PapyrusPrimitiveType.Reference;
}
}
else
{
if (dialog.SelectedConstantValue == null && dialog.SelectedReferenceName != null)
{
return(CreateReferenceFromName(dialog.SelectedReferenceName));
}
var val = dialog.SelectedConstantValue;
if (val is string)
{
val = val.ToString().Ref(asm).Value;
}
papyrusVariableReference.Value = val;
papyrusVariableReference.Type = targetType;
}
return(papyrusVariableReference);
}
private string GetArgumentValue(PapyrusVariableReference arg)
{
if (arg == null)
{
return(null);
}
switch (arg.Type)
{
case PapyrusPrimitiveType.Reference:
return(arg.Value?.ToString());
case PapyrusPrimitiveType.String:
return("\"" + arg.Value + "\"");
case PapyrusPrimitiveType.Boolean:
{
if (arg.Value != null)
{
return(arg.Value.Equals(true) || arg.Value.Equals(1) ? "true" : "false");
}
}
break;
case PapyrusPrimitiveType.Integer:
if (arg.Value != null)
{
return(arg.Value.ToString());
}
break;
case PapyrusPrimitiveType.Float:
if (arg.Value != null)
{
return(arg.Value.ToString().Replace(",", ".") + "f");
}
break;
}
if (arg.Name != null)
{
return((string)arg.Name);
}
return(null);
}
public PapyrusVariableReference GetDefaultValue()
{
if (IsArray)
{
return(new PapyrusVariableReference());
}
var type = Utility.GetPapyrusReturnType(SelectedTypeName);
var primitiveType = Utility.GetPapyrusPrimitiveType(type);
var defVal = fieldToEdit?.DefaultValue;
if (defVal == null)
{
defVal = new PapyrusVariableReference();
}
defVal.Type = primitiveType;
defVal.Value = Utility.ConvertToPapyrusValue(type, DefaultValue);
return(defVal);
}
private string GetStructFieldType(IReadOnlyCollection <PapyrusAssemblyDefinition> papyrusAssemblyCollection,
PapyrusFieldDefinition structSource, PapyrusVariableReference structField)
{
foreach (var a in papyrusAssemblyCollection)
{
foreach (var t in a.Types)
{
foreach (var s in t.NestedTypes)
{
var name = structSource.TypeName.Split('#').LastOrDefault();
if (s.Name.Value.ToLower() == name.ToLower())
{
var targetField = s.Fields.FirstOrDefault(f => f.Name.Value == "::" + structField.Name.Value);
if (targetField != null)
{
return(targetField.TypeName);
}
}
}
}
}
return("none");
}
private void UpdateReferenceCollection(ComboBoxItem value)
{
if (currentMethod == null)
{
return;
}
var tar = value.Content.ToString().ToLower();
ReferenceSelectionVisible = Visibility.Visible;
if (tar == "variable")
{
var papyrusVariableReferences = currentMethod.GetVariables();
papyrusVariableReferences.ForEach(i => i.Type = PapyrusPrimitiveType.Reference);
ReferenceCollection = new ObservableCollection <PapyrusMemberReference>(Filter(papyrusVariableReferences));
}
else if (tar == "parameter")
{
var papyrusParameterDefinitions = currentMethod.Parameters;
ReferenceCollection =
new ObservableCollection <PapyrusMemberReference>(Filter(papyrusParameterDefinitions));
}
else if (tar == "field")
{
var papyrusFieldDefinitions = currentType.Fields.ToList();
ReferenceCollection = new ObservableCollection <PapyrusMemberReference>(Filter(papyrusFieldDefinitions));
}
else if (tar == "none")
{
if (currentType.Assembly != null)
{
SelectedReference = new PapyrusVariableReference
{
Name = "".Ref(currentType.Assembly),
Value = null,
Type = PapyrusPrimitiveType.None
};
}
ReferenceSelectionVisible = Visibility.Collapsed;
}
else if (tar == "self")
{
if (currentType.Assembly != null)
{
SelectedReference = new PapyrusVariableReference
{
Name = "Self".Ref(currentType.Assembly),
Value = "Self",
Type = PapyrusPrimitiveType.Reference
};
}
ReferenceSelectionVisible = Visibility.Collapsed;
}
//else if (tar == "selfref")
//{
// if (currentType.Assembly != null)
// {
// SelectedReference = new PapyrusVariableReference
// {
// Name = "SelfRef".Ref(currentType.Assembly),
// Value = "SelfRef",
// Type = PapyrusPrimitiveType.Reference
// };
// }
// ReferenceSelectionVisible = Visibility.Collapsed;
//}
}
/// <summary>
/// Initializes a new instance of the <see cref="ConstantNode" /> class.
/// </summary>
/// <param name="instructionOffset">The instruction offset.</param>
/// <param name="constant">The value.</param>
public ConstantNode(int instructionOffset, PapyrusVariableReference constant)
: base(0, instructionOffset, 0, null)
{
Constant = constant;
}
public PapyrusInstruction ConditionalJump(PapyrusOpCodes jumpType, PapyrusVariableReference conditionalVar,
object destinationInstruction)
{
throw new NotImplementedException();
}
private void WriteVariable(PapyrusVariableReference variable)
{
pexWriter.Write(variable.Name);
pexWriter.Write(variable.TypeName);
}
/// <summary>
/// Processes the specified instruction.
/// </summary>
/// <param name="mainProcessor">The main instruction 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 output = new List <PapyrusInstruction>();
if (Utility.IsVoid(targetMethod.ReturnType))
{
output.Add(PapyrusReturnNone());
return(output);
}
if (mainProcessor.EvaluationStack.Count >=
Utility.GetStackPopCount(instruction.OpCode.StackBehaviourPop))
{
var topValue = mainProcessor.EvaluationStack.Pop();
if (topValue.Value is PapyrusVariableReference)
{
var variable = topValue.Value as PapyrusVariableReference;
// return "Return " + variable.Name;
output.Add(mainProcessor.CreatePapyrusInstruction(PapyrusOpCodes.Return, variable));
// PapyrusReturnVariable(variable.Name)
return(output);
}
if (topValue.Value is PapyrusFieldDefinition)
{
var variable = topValue.Value as PapyrusFieldDefinition;
// return "Return " + variable.Name;
output.Add(mainProcessor.CreatePapyrusInstruction(PapyrusOpCodes.Return, variable));
return(output);
}
if (Utility.IsConstantValue(topValue.Value))
{
var val = topValue.Value;
var typeName = topValue.TypeName;
var newValue = valueTypeConverter.Convert(typeName, val);
var papyrusVariableReference = new PapyrusVariableReference
{
TypeName = StringExtensions.Ref(typeName, mainProcessor.PapyrusAssembly),
Value = newValue,
Type = Utility.GetPapyrusPrimitiveType(typeName)
};
{
output.Add(mainProcessor.CreatePapyrusInstruction(PapyrusOpCodes.Return,
papyrusVariableReference));
return(output);
}
}
}
else
{
output.Add(PapyrusReturnNone());
return(output);
}
return(output);
}
