public UnaryComputationAssignment(IAssignableValue target, IReadableValue operand, UnaryOperatorType @operator, PrimitiveType operandType) { Target = target; Operand = operand; Operator = @operator; OperandType = operandType; }
public BinaryComputationAssignment(IAssignableValue target, IReadableValue lhs, IReadableValue rhs, BinaryOperatorType @operator, PrimitiveType operandType) { Target = target; Lhs = lhs; Rhs = rhs; Operator = @operator; OperandType = operandType; }
public IEnumerable <IInstruction> TransformValue(IValue value, IAssignableValue target) { if (!(value.ReturnType is PrimitiveType type)) { throw new InvalidOperationException("Internal Failure: Binder failed binding high-level locals to primitives"); } yield return(DirectAssignment(target, RequestValue(value), type)); }
Expression IAssignableValue.SetValue(Compiler compiler, Expression rhs) { List <AttributeBaseAst> attributes = this.GetAttributes(); IAssignableValue assignableValue = this.GetActualAssignableAst().GetAssignableValue(); VariableExpressionAst ast = assignableValue as VariableExpressionAst; if (ast == null) { return(assignableValue.SetValue(compiler, Compiler.ConvertValue(rhs, attributes))); } return(Compiler.CallSetVariable(Expression.Constant(ast.VariablePath), rhs, Expression.Constant(attributes.ToArray()))); }
private IEnumerable <IInstruction> GetValue(IExpression expr, out IReadableValue location) { if (expr is IValue val) { location = RequestValue(val); return(Array.Empty <IInstruction>()); } IAssignableValue target = RequestLocal(); location = target; return(TransformExpression(expr, target)); }
private object ExecutePrefixPostFix(Array input, Pipe outputPipe, ExecutionContext context) { if (this._prefix == null && this._postfix == null) { return((object)null); } Token errToken = this._prefix != null ? this._prefix : this._postfix; if (!(this._expression is IAssignableParseTreeNode expression)) { throw InterpreterError.NewInterpreterException((object)errToken.TokenText, typeof(RuntimeException), errToken, "OperatorRequiresVariableOrProperty", (object)errToken.TokenText); } IAssignableValue assignableValue = expression.GetAssignableValue(input, context); object obj1 = PSObject.Base(assignableValue.GetValue(context)) ?? (object)0; Type type = obj1.GetType(); TypeCode typeCode = LanguagePrimitives.GetTypeCode(type); if (!LanguagePrimitives.IsNumeric(typeCode)) { throw InterpreterError.NewInterpreterException(obj1, typeof(RuntimeException), errToken, "OperatorRequiresNumber", (object)errToken, (object)type); } object obj2; if (typeCode == TypeCode.Int32) { try { obj2 = (object)checked ((int)obj1 + this.valueToAdd); } catch { obj2 = ParserOps.PolyAdd(context, this.NodeToken, obj1, (object)this.valueToAdd); } } else { obj2 = ParserOps.PolyAdd(context, this.NodeToken, obj1, (object)this.valueToAdd); } assignableValue.SetValue(obj2, context); return(this._prefix != null ? obj2 : obj1); }
internal override object Execute(Array input, Pipe outputPipe, ExecutionContext context) { this.CheckForInterrupts(context); object obj1 = (object)null; try { obj1 = this._rightHandSide.Execute(input, (Pipe)null, context); if (obj1 == AutomationNull.Value) { obj1 = (object)null; } IAssignableValue assignableValue = this._left.GetAssignableValue(input, context); object obj2 = this._operationDelegate == null ? obj1 : this._operationDelegate(context, this.NodeToken, assignableValue.GetValue(context), obj1); assignableValue.SetValue(obj2, context); return(obj2); } catch (ScriptCallDepthException ex) { throw; } catch (FlowControlException ex) { throw; } catch (RuntimeException ex) { if (ex.ErrorRecord != null && ex.ErrorRecord.InvocationInfo == null) { ex.ErrorRecord.SetInvocationInfo(new InvocationInfo((CommandInfo)null, this.NodeToken, context)); } throw; } catch (Exception ex) { CommandProcessorBase.CheckForSevereException(ex); throw InterpreterError.NewInterpreterException(obj1, typeof(RuntimeException), this.NodeToken, "OperatorFailed", (object)this.NodeToken.TokenText, (object)ex.Message); } }
public CallInstruction(string name, IReadOnlyList <IReadableValue> parameters, IAssignableValue target) { Name = name; Parameters = parameters; Target = target; }
public IEnumerable <IInstruction> TransformExpression(IExpression expression, IAssignableValue target) => expression switch {
public StoreInstruction(uint label, IAssignableValue result, IVariable operand) : base(label) { this.Result = result; this.Operand = operand; }
public ParameterQueryAssignment(int parameterIndex, IAssignableValue target) { ParameterIndex = parameterIndex; Target = target; }
public void VisitMethod(MethodBody mBody, ControlFlowGraph cfg) { VisitLocals(mBody); // Going through the instructions via cfg nodes instead of directly iterating over the instructions // of the methodBody becuase Phi instructions may not have been inserted in the insts of the methodBody. foreach (var node in cfg.Nodes) { foreach (var instruction in node.Instructions) { // System.Console.WriteLine("{0}", instruction.ToString()); // System.Console.WriteLine("{0}", instruction.GetType().FullName()); // System.Console.WriteLine(); if (instruction is LoadInstruction) { LoadInstruction lInst = instruction as LoadInstruction; IValue rhsOperand = lInst.Operand; if (rhsOperand is StaticFieldAccess) { StaticFieldAccess rhsAcc = rhsOperand as StaticFieldAccess; IFieldReference fld = rhsAcc.Field; ITypeDefinition fldType = fld.ContainingType.ResolvedType; Stubber.CheckAndAdd(fldType); } // Note: calls to static methods and instance methods appear as a StaticMethodReference else if (rhsOperand is StaticMethodReference) { StaticMethodReference sMethAddr = rhsOperand as StaticMethodReference; IMethodDefinition tgtMeth = sMethAddr.Method.ResolvedMethod; ITypeDefinition containingTy = tgtMeth.ContainingTypeDefinition; Stubber.CheckAndAdd(containingTy); IMethodDefinition addedMeth = Stubber.CheckAndAdd(tgtMeth); // addrTakenMethods do not contain templates. if (addedMeth != null) { addrTakenMethods.Add(addedMeth); } } //Note: calls to virtual, abstract or interface methods appear as VirtualMethodReference else if (rhsOperand is VirtualMethodReference) { VirtualMethodReference sMethAddr = rhsOperand as VirtualMethodReference; IMethodDefinition tgtMeth = sMethAddr.Method.ResolvedMethod; ITypeDefinition containingTy = tgtMeth.ContainingTypeDefinition; ITypeDefinition addedTy = Stubber.CheckAndAdd(containingTy); IMethodDefinition addedMeth = Stubber.CheckAndAdd(tgtMeth); if (addedTy != null && addedMeth != null) { // addrTakenMethods do not contain templates. addrTakenMethods.Add(addedMeth); ProcessVirtualInvoke(addedMeth, addedTy, true); } } else if (rhsOperand is Reference) { Reference rhsRef = rhsOperand as Reference; IReferenceable refOf = rhsRef.Value; if (refOf is StaticFieldAccess) { StaticFieldAccess refAcc = refOf as StaticFieldAccess; IFieldDefinition fld = refAcc.Field.ResolvedField; ITypeDefinition fldType = fld.ContainingType.ResolvedType; Stubber.CheckAndAdd(fldType); addrTakenStatFlds.Add(fld); } else if (refOf is IVariable) { IVariable refVar = refOf as IVariable; if (!refVar.Type.IsValueType || refVar.Type.ResolvedType.IsStruct) { addrTakenLocals.Add(refVar); } } else if (refOf is InstanceFieldAccess) { InstanceFieldAccess refAcc = refOf as InstanceFieldAccess; IFieldDefinition fld = refAcc.Field.ResolvedField; addrTakenInstFlds.Add(fld); } else if (refOf is ArrayElementAccess) { // All arrays will be added into domX as potential address taken. } } } else if (instruction is StoreInstruction) { StoreInstruction sInst = instruction as StoreInstruction; IAssignableValue lhs = sInst.Result; if (lhs is StaticFieldAccess) { StaticFieldAccess lhsAcc = lhs as StaticFieldAccess; IFieldReference fld = lhsAcc.Field; ITypeDefinition fldType = fld.ContainingType.ResolvedType; Stubber.CheckAndAdd(fldType); } } else if (instruction is CreateObjectInstruction) { CreateObjectInstruction newObjInst = instruction as CreateObjectInstruction; ITypeReference objType = newObjInst.AllocationType; ITypeDefinition objTypeDef = objType.ResolvedType; if (objTypeDef is IGenericTypeInstance) { objTypeDef = objTypeDef.ResolvedType; } ITypeDefinition addedTy = Stubber.CheckAndAdd(objTypeDef); if (addedTy != null && !allocClasses.Contains(addedTy)) { allocClasses.Add(addedTy); } } else if (instruction is CreateArrayInstruction) { CreateArrayInstruction newArrInst = instruction as CreateArrayInstruction; ITypeReference elemType = newArrInst.ElementType; ITypeDefinition elemTypeDef = elemType.ResolvedType; ITypeDefinition addedTy = Stubber.CheckAndAdd(elemTypeDef); if (addedTy != null && !allocClasses.Contains(addedTy)) { allocClasses.Add(addedTy); } } else if (instruction is MethodCallInstruction) { MethodCallInstruction invkInst = instruction as MethodCallInstruction; IMethodReference callTgt = invkInst.Method; ITypeReference containingType = callTgt.ContainingType; ITypeDefinition declType = containingType.ResolvedType; IMethodDefinition callTgtDef = callTgt.ResolvedMethod; ITypeDefinition addedType = Stubber.CheckAndAdd(declType); IMethodDefinition addedMeth = Stubber.CheckAndAdd(callTgtDef); MethodCallOperation callType = invkInst.Operation; if (callType == MethodCallOperation.Virtual && addedType != null && addedMeth != null) { ProcessVirtualInvoke(addedMeth, addedType, false); } } else { // System.Console.WriteLine("{0}", instruction.ToString()); // System.Console.WriteLine("Not currently handled: {0}", instruction.GetType().ToString()); // System.Console.WriteLine(); } } } }