private void ProcessVariableReference(VariableReference VarRef, string VarName) { var VarAssignment = new VarAssignment(); VarAssignment.SrcName = VarRef.Name; VarAssignment.VarName = VarName; _smells.AssignmentList.Add(VarAssignment); }
public void visit(VariableReference node) { Symbol var = symboltable.resolve(node.Name); if (var == null) throw new SemanticError("Reference to undefined identifier " + node.Name + " on row " + node.Row + "."); else operandtypes.Push(var.Type); }
public void It_renders_the_named_value_from_the_context() { var a = new VariableReference("a"); var writer = new StringWriter(); var context = new RenderContext(null, new { a = "b" }, writer, null); a.Render(context); Assert.AreEqual("b", writer.GetStringBuilder().ToString()); }
public void It_supports_accessing_members_of_child_objects() { var a = new VariableReference("a.b"); var writer = new StringWriter(); var context = new RenderContext(null, new { a = new { b = "c" } }, writer, null); a.Render(context); Assert.AreEqual("c", writer.GetStringBuilder().ToString()); }
public void It_checks_for_keys_containing_dots_before_splitting() { var a = new VariableReference("a.b"); var writer = new StringWriter(); var context = new RenderContext(null, new Dictionary<string, string> { { "a.b", "c" } }, writer, null); a.Render(context); Assert.AreEqual("c", writer.GetStringBuilder().ToString()); }
public void InvalidRange() { var stringlit = new StringLiteral("foo", 0); var range = new Range(stringlit, stringlit, 0); var variabledecl = new VariableDeclaration("foo", "int", 0); var variable = new VariableReference("foo", 0); var loop = new Loop(variable, range, new List<Statement>(), 0); statementlist.Add(variabledecl); statementlist.Add(loop); var parsetree = new Program(statementlist); Assert.Throws<SemanticError>(() => symbolTableBuilder.BuildSymbolTableAndTypeCheck(parsetree)); }
public void NonIntegerLoopVariable(string type) { var variabledecl = new VariableDeclaration("foo", type, 0); statementlist.Add(variabledecl); var variable = new VariableReference("foo", 0); var integer = new IntegerLiteral("5", 0); var range = new Range(integer, integer, 0); var variabledecl2 = new VariableDeclaration("bar", "int", 0); var loopbody = new List<Statement>(); loopbody.Add(variabledecl2); var loop = new Loop(variable, range, loopbody, 0); statementlist.Add(loop); var parsetree = new Program(statementlist); Assert.Throws<SemanticError>(() => symbolTableBuilder.BuildSymbolTableAndTypeCheck(parsetree)); }
private bool IsOnlyUsedOnce(VariableReference variable, out TypeReference type) { type = null; StackVariableDefineUseInfo defineUseInfo; if (!context.MethodContext.StackData.VariableToDefineUseInfo.TryGetValue(variable.Resolve(), out defineUseInfo)) { throw new Exception("Define/use info not found."); } if (defineUseInfo.UsedAt.Count != 1) { return(false); } int instructionOffset = First(defineUseInfo.UsedAt); UsedAsTypeHelper uath = new UsedAsTypeHelper(context.MethodContext); Instruction instruction = context.MethodContext.ControlFlowGraph.OffsetToInstruction[instructionOffset]; type = uath.GetUseExpressionTypeNode(instruction, offsetToExpression[instructionOffset], variable); return(true); }
protected override void RenderDictionary(StringBuilder builder, VariableReference variable, IDictionary variableValue, bool first) { bool firstElement = true; foreach (DictionaryEntry entry in variableValue) { if (variable.Composite) { builder.Append('.'); AppendText(builder, variable, entry.Key.ToString(), true); builder.Append('='); AppendText(builder, variable, entry.Value.ToString(), true); } else { RenderElement(builder, variable, entry.Key, first, firstElement); RenderElement(builder, variable, entry.Value, first, false); } firstElement = false; } }
private void VisitAssignExpression(BinaryExpression node) { this.currentVariable = null; this.states.Push(1); this.Visit(node.get_Left()); dummyVar0 = this.states.Pop(); if (this.processStep == RemoveConditionOnlyVariables.ProcessStep.Search) { this.SetVariableAssignmentExpression(node.get_Right()); } if (node.get_Right().get_CodeNodeType() == 22 && this.currentVariable != null) { V_0 = this.GetValue(this.currentVariable); if (V_0 != null && V_0.get_VariableState() != RemoveConditionOnlyVariables.VariableState.Declaration) { stackVariable29 = V_0; stackVariable29.set_NumberOfTimesAssigned(stackVariable29.get_NumberOfTimesAssigned() + 1); } } this.Visit(node.get_Right()); return; }
bool VisitVariableReferenceExpression(Expression node) { var variable_reference_expression = node as VariableReferenceExpression; if (variable_reference_expression == null) { return(false); } switch (state) { case State.Begin: this.enumerator = variable_reference_expression.Variable; break; case State.WhileBody: this.variable = variable_reference_expression.Variable as VariableDefinition; break; } return(true); }
private IStatement CallRead() { if (Accept(Symbol.ReadProcedure)) { Require(Symbol.ClosureOpen); Read read = new Read(); do { Identifier ident = Identifier(); if (ident == null) { throw new SyntaxException(expIdentifier, current); } VariableReference varRef = ReadVariableReference(ident); AssigmentStatement assigment = new AssigmentStatement(varRef, new Reading(ident)); read.Add(assigment); } while (Accept(Symbol.Comma)); Require(Symbol.ClosureClose); return(read); } return(null); }
private void RenderElement(StringBuilder builder, VariableReference variable, object variableValue, bool firstVariable, bool firstElement) { if (builder == null) { throw new ArgumentNullException("builder"); } if (variableValue == null) { throw new ArgumentNullException("variableValue"); } if (firstElement || variable.Composite) { builder.Append('.'); } else if (!firstElement) { builder.Append(','); } AppendText(builder, variable, variableValue.ToString(), true); }
public VSCodeVariable[] EnumChildren(int dwTimeout) { var thread = frame.Thread; var c = thread.Engine.EnumChildren(GetVariableReference(), thread.ThreadID, frame.Index, (uint)Math.Max(dwTimeout, 5000)); var children = new VSCodeVariable[c.Length]; for (int i = 0; i < c.Length; i++) { var vi = c[i]; VSCodeVariable v = new VSCodeVariable(frame, vi); if (vi.Type == VariableTypes.IndexAccess) { v.Parameters = new VariableReference[] { VariableReference.GetInteger(vi.Offset) } } ; v.Parent = this; frame.RegisterVariable(v); children[i] = v; } return(children); }
public VariableReference GetVariableReference() { if (info != null) { VariableReference res = new VariableReference(); res.Address = info.Address; res.Name = info.Name; res.Type = info.Type; res.Offset = info.Offset; if (Parent != null) { res.Parent = Parent.GetVariableReference(); } res.Parameters = Parameters; return(res); } else { return(null); } }
protected override void RenderElement(StringBuilder builder, VariableReference variable, object variableValue, bool first) { if (builder == null) { throw new ArgumentNullException("builder"); } if (variableValue == null) { throw new ArgumentNullException("variableValue"); } if (first) { builder.Append('#'); } if (!first) { builder.Append(','); } AppendText(builder, variable, variableValue.ToString(), false); }
public bool VisitDropNode(DropNode dropNode) { VariableReference input = dropNode.InputTerminals[0].GetTrueVariable(); var inputAllocation = (LocalAllocationValueSource)_variableValues[input]; NIType inputType = input.Type; if (inputType.TypeHasDropTrait()) { CreateDropCall(inputType, inputAllocation.AllocationPointer); return(true); } NIType innerType; if (inputType.TryDestructureVectorType(out innerType)) { // TODO return(true); } if (inputType.TryDestructureOptionType(out innerType) && innerType.TypeHasDropTrait()) { // TODO: turn this into a monomorphized generic function call LLVMValueRef isSomePtr = _builder.CreateStructGEP(inputAllocation.AllocationPointer, 0u, "isSomePtr"), isSome = _builder.CreateLoad(isSomePtr, "isSome"); LLVMBasicBlockRef optionDropIsSomeBlock = _topLevelFunction.AppendBasicBlock("optionDropIsSome"), optionDropEndBlock = _topLevelFunction.AppendBasicBlock("optionDropEnd"); _builder.CreateCondBr(isSome, optionDropIsSomeBlock, optionDropEndBlock); _builder.PositionBuilderAtEnd(optionDropIsSomeBlock); LLVMValueRef innerValuePtr = _builder.CreateStructGEP(inputAllocation.AllocationPointer, 1u, "innerValuePtr"); CreateDropCall(innerType, innerValuePtr); _builder.CreateBr(optionDropEndBlock); _builder.PositionBuilderAtEnd(optionDropEndBlock); return(true); } return(true); }
public override void VisitThrowStatement(IThrowStatement stmt, IList <IStatement> body) { if (IsTargetMatch(stmt, CompletionCase.EmptyCompletionBefore)) { body.Add(EmptyCompletionExpression); } IVariableReference varRef = new VariableReference(); if (stmt.Semicolon == null && IsTargetMatch(stmt, CompletionCase.EmptyCompletionAfter)) { varRef = new VariableReference { Identifier = _nameGen.GetNextVariableName() }; body.Add( new VariableDeclaration { Type = Names.Type("System.Exception, mscorlib, 4.0.0.0"), Reference = varRef }); body.Add(new Assignment { Reference = varRef, Expression = new CompletionExpression() }); } else if (stmt.Exception != null) { varRef = _exprVisitor.ToVariableRef(stmt.Exception, body); } body.Add(new ThrowStatement { Reference = varRef }); if (IsTargetMatch(stmt, CompletionCase.EmptyCompletionAfter)) { body.Add(EmptyCompletionExpression); } }
/// <summary> /// Create the foreach statement syntax for a foreach loop with a reference as enumerable. /// </summary> /// <param name="variableName">Name of the variable.</param> /// <param name="varialeType">The variable type.</param> /// <param name="enumerableReference">Reference to the enumerable.</param> /// <param name="body">Body of the foreach loop.</param> /// <param name="useVar">If we should use the var keyword instead of the type.</param> /// <returns>The declared foreach statement syntax.</returns> public ForEachStatementSyntax ForEach(string variableName, Type varialeType, VariableReference enumerableReference, BlockSyntax body, bool useVar = true) { if (string.IsNullOrEmpty(variableName)) { throw new ArgumentException("Value cannot be null or empty.", nameof(variableName)); } if (varialeType == null) { throw new ArgumentNullException(nameof(varialeType)); } if (enumerableReference == null) { throw new ArgumentNullException(nameof(enumerableReference)); } return(ForEachStatement( useVar ? IdentifierName("var") : TypeGenerator.Create(varialeType), Identifier(variableName), ReferenceGenerator.Create(enumerableReference), body)); }
public void BranchedMutableWire_SetVariableTypes_AllSinkVariablesAreMutable() { NIType signatureType = Signatures.MutablePassthroughType; DfirRoot dfirRoot = DfirRoot.Create(); FunctionalNode firstSink = new FunctionalNode(dfirRoot.BlockDiagram, signatureType), secondSink = new FunctionalNode(dfirRoot.BlockDiagram, signatureType); Constant constant = Constant.Create(dfirRoot.BlockDiagram, 0, NITypes.Int32); constant.OutputTerminal.WireTogether(firstSink.InputTerminals[0], SourceModelIdSource.NoSourceModelId); constant.OutputTerminal.WireTogether(secondSink.InputTerminals[0], SourceModelIdSource.NoSourceModelId); Wire branchedWire = (Wire)constant.OutputTerminal.ConnectedTerminal.ParentNode; branchedWire.SetWireBeginsMutableVariable(true); RunSemanticAnalysisUpToSetVariableTypes(dfirRoot); VariableReference firstSinkVariable = firstSink.InputTerminals[0].GetFacadeVariable(); Assert.IsTrue(firstSinkVariable.Mutable); VariableReference secondSinkVariable = secondSink.InputTerminals[0].GetFacadeVariable(); Assert.IsTrue(secondSinkVariable.Mutable); }
/// <summary> /// Check if the local variable has a name which was generated by the compiler. /// Note that this will return true for all variables if debugging information is not present. /// </summary> /// <param name="self">The VariableReference on which the extension method can be called.</param> /// <returns>True if the field name was generated by the compiler, False otherwise</returns> public static bool IsGeneratedName(this VariableReference self, MethodBody body) { if (self == null) { return(false); } var def = self.Resolve(); if (def == null) { return(false); } string name = GetVariableName(def, body); if (String.IsNullOrEmpty(name)) { return(true); } return((name [0] == '<') || (name.IndexOf('$') != -1)); }
private static WireRenderInfoEnumerable CreateVariableIdentityRenderInfo(VariableReference variable, StockDiagramUIResources stockResources) { NIType innerType = variable.Type.IsRebarReferenceType() ? variable.Type.GetUnderlyingTypeFromRebarType() : variable.Type; int id = variable.Id; ITypeAssetProvider innerTypeAssetProvider = new VariableIdentityTypeAssetProvider( stockResources.GetTypeAssets((Element)null, variable.Type).GetShortName(innerType), VariableIdentityTypeAssetProvider.GetColor(id)); ITypeAssetProvider outerTypeAssetProvider; if (variable.Type.IsMutableReferenceType()) { outerTypeAssetProvider = new MutableReferenceTypeAssetProvider( innerTypeAssetProvider, 0); } else if (variable.Type.IsImmutableReferenceType()) { outerTypeAssetProvider = new ImmutableReferenceTypeAssetProvider( innerTypeAssetProvider, 0); } else if (variable.Mutable) { outerTypeAssetProvider = new MutableValueTypeAssetProvider( innerTypeAssetProvider, 0); } else { outerTypeAssetProvider = new ImmutableValueTypeAssetProvider( innerTypeAssetProvider, 0); } return(outerTypeAssetProvider.GetWireRenderInfo(0)); }
/** * Resolve a reference to a variable * * @param {Object} env * Resolver environment object. * @param {Object} expr * An expression to be resolved. * @param {String} expr.name * Name of an argument to be returned. * @returns {FluentType} * @private */ static IFluentType VariableReference(ResolverEnvironment env, VariableReference varReference) { object arg; if (env.Arguments == null || !env.Arguments.TryGetValue(varReference.Name, out arg)) { env.Errors?.Add(new ReferenceError($"Unknown variable: ${varReference.Name}")); return(new FluentNone(varReference.Name)); } // Return early if the argument already is an instance of IFluentType. if (arg is IFluentType ft) { return(ft); } // Convert the argument to a Fluent type. if (arg is string str) { return(new FluentString(str)); } if (arg is sbyte || arg is short || arg is int || arg is long || arg is byte || arg is ushort || arg is uint || arg is ulong || arg is float || arg is double || arg is decimal) { return(new FluentNumber(arg.ToString())); } if (arg is DateTime dt) { return(new FluentDateTime(dt)); } env.Errors?.Add(new TypeError( $"Unsupported variable type: {varReference.Name}, {arg?.GetType()?.ToString() ?? "null"}")); return(new FluentNone(varReference.Name)); }
/// <summary> /// Create the expression statement syntax to assign a reference to another expression. /// </summary> /// <param name="reference">Reference that should be assigned.</param> /// <param name="expressionSyntax">Expression that we should assign to reference.</param> /// <param name="castTo">If we should do a cast while assign the variable.</param> /// <returns>The generated assign declaration syntax.</returns> public ExpressionStatementSyntax Assign(VariableReference reference, ExpressionSyntax expressionSyntax, Type castTo = null) { if (reference == null) { throw new ArgumentNullException(nameof(reference)); } if (expressionSyntax == null) { throw new ArgumentNullException(nameof(expressionSyntax)); } if (castTo != null && castTo != typeof(void)) { expressionSyntax = CastExpression(TypeGenerator.Create(castTo), expressionSyntax); } return (ExpressionStatement( AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, ReferenceGenerator.Create(reference), expressionSyntax))); }
/// <summary> /// Create the for statement syntax for a for loop with a reference for start and stop. /// </summary> /// <param name="start">Reference for start.</param> /// <param name="end">Reference for end.</param> /// <param name="variableName">Variable name in loop.</param> /// <param name="body">Body inside loop.</param> /// <returns>The declared for statement syntax.</returns> public ForStatementSyntax For(VariableReference start, VariableReference end, string variableName, BlockSyntax body) { if (start == null) { throw new ArgumentNullException(nameof(start)); } if (end == null) { throw new ArgumentNullException(nameof(end)); } if (string.IsNullOrEmpty(variableName)) { throw new ArgumentException("Value cannot be null or empty.", nameof(variableName)); } return(ForStatement( VariableDeclaration( PredefinedType(Token(SyntaxKind.IntKeyword)), SeparatedList(new[] { VariableDeclarator( Identifier(variableName), null, EqualsValueClause(ReferenceGenerator.Create(start))) })), SeparatedList <ExpressionSyntax>(), BinaryExpression( SyntaxKind.LessThanExpression, IdentifierName(variableName), ReferenceGenerator.Create(end)), SeparatedList <ExpressionSyntax>(new[] { PostfixUnaryExpression(SyntaxKind.PostIncrementExpression, IdentifierName(variableName)) }), body)); }
private int CheckNewArrayInitializationAndSize(Statement statement, VariableReference arrayVariable) { if (!statement.IsAssignmentStatement()) { throw new Exception(InvalidStatementExceptionString); } BinaryExpression arrayInitialization = (statement as ExpressionStatement).Expression as BinaryExpression; if (arrayInitialization.Left.CodeNodeType != CodeNodeType.VariableReferenceExpression || (arrayInitialization.Left as VariableReferenceExpression).Variable != arrayVariable) { throw new Exception(InvalidStatementExceptionString); } if (arrayInitialization.Right.CodeNodeType != CodeNodeType.ArrayCreationExpression || (arrayInitialization.Right as ArrayCreationExpression).Dimensions.Count != 1 || (arrayInitialization.Right as ArrayCreationExpression).Dimensions[0].CodeNodeType != CodeNodeType.LiteralExpression) { throw new Exception(InvalidStatementExceptionString); } return(Convert.ToInt32(((arrayInitialization.Right as ArrayCreationExpression).Dimensions[0] as LiteralExpression).Value)); }
private LinqQueryExpression ProcessExtensionMethodChain(IEnumerable <MethodInvocationExpression> methodInvocations, MethodInvocationExpression topInvoke, bool queryable) { this.currentIdentifier = null; this.clauses.Clear(); foreach (MethodInvocationExpression methodInvoke in methodInvocations) { bool success = true; switch (methodInvoke.MethodExpression.MethodDefinition.Name) { case "Select": success = TryProcessSelectMethod(methodInvoke, queryable); break; case "SelectMany": success = TryProcessSelectManyMethod(methodInvoke, queryable); break; case "Where": success = TryProcessWhereMethod(methodInvoke, queryable); break; case "OrderBy": success = TryProcessOrderByMethod(methodInvoke, true, queryable); break; case "OrderByDescending": success = TryProcessOrderByMethod(methodInvoke, false, queryable); break; case "ThenBy": success = TryProcessThenByMethod(methodInvoke, true, queryable); break; case "ThenByDescending": success = TryProcessThenByMethod(methodInvoke, false, queryable); break; case "Join": success = TryProcessJoinMethod(methodInvoke, false, queryable); break; case "GroupJoin": success = TryProcessJoinMethod(methodInvoke, true, queryable); break; case "GroupBy": success = TryProcessGroupByMethod(methodInvoke, queryable); break; default: return(null); } if (!success) { return(null); } } if (this.clauses.Count == 0) { return(null); } if (this.currentIdentifier != null) { clauses.Add(new SelectClause(new VariableReferenceExpression(this.currentIdentifier, null), null)); } return(new LinqQueryExpression(new List <QueryClause>(this.clauses), topInvoke.ExpressionType, topInvoke.UnderlyingSameMethodInstructions)); }
public override void ExplicitVisit(VariableReference fragment) { _fragments.Add(fragment); }
public void LoopTest() { var loopvardecl = new VariableDeclaration("loopvariable", "int", 0); var loopvarref = new VariableReference("loopvariable", 0); var range = new Range(new IntegerLiteral("2", 0), new IntegerLiteral("5", 0), 0); var loopbody = new List<Statement>(); var resultdecl = new VariableDeclaration("result", "int", 0); var resultref = new VariableReference("result", 0); loopbody.Add(new Assignment(resultref, new ArithmeticOp("+", resultref, loopvarref, 0), 0)); var program = new List<Statement>(); program.Add(resultdecl); program.Add(loopvardecl); program.Add(new Loop(loopvarref, range, loopbody, 0)); var symboltable = new SymbolTable(); symboltable.define(new Symbol("loopvariable", "int")); symboltable.define(new Symbol("result", "int")); var interpreter = new InterpretingNodeVisitor(symboltable); interpreter.Run(new Program(program)); Assert.That(interpreter.Valuetable[symboltable.resolve("result")], Is.EqualTo(14)); }
public void ValidRead(string type) { var variabledecl = new VariableDeclaration("foo", type, 0); statementlist.Add(variabledecl); var variable = new VariableReference("foo", 0); var print = new ExpressionStatement("read", variable, 0); statementlist.Add(print); var parsetree = new Program(statementlist); Assert.DoesNotThrow(() => symbolTableBuilder.BuildSymbolTableAndTypeCheck(parsetree)); }
public void VariableDefinitionAndReferenceInAssignment() { var variableref = new VariableReference("foo", 0); var variabledecl = new VariableDeclaration("foo", "int", 0); var assignment = new Assignment(variabledecl, variableref, 0); statementlist.Add(assignment); var parsetree = new Program(statementlist); Assert.Throws<SemanticError>(() => symbolTableBuilder.BuildSymbolTableAndTypeCheck(parsetree)); }
private bool TryProcessJoinMethod(MethodInvocationExpression methodInvoke, bool isGroupJoin, bool queryable) { MethodDefinition methodDef = methodInvoke.MethodExpression.MethodDefinition; if (methodDef.Parameters.Count != 5) { return(false); } Expression innerCollection = (Expression) new LinqQueriesRebuilder(this.methodContext).Visit(methodInvoke.Arguments[1].Clone()); LambdaExpression outerKeySelector = GetLambdaExpression(methodInvoke.Arguments[2], queryable); if (outerKeySelector == null || outerKeySelector.Arguments.Count != 1) { return(false); } ProcessCurrentIdentifier(methodInvoke.Arguments[0], outerKeySelector.Parameters[0].Resolve()); Expression outerKey = ProcessReturnExpression(outerKeySelector, new[] { this.currentIdentifier }); if (outerKey == null) { return(false); } LambdaExpression innerKeySelector = GetLambdaExpression(methodInvoke.Arguments[3], queryable); if (innerKeySelector == null || innerKeySelector.Arguments.Count != 1) { return(false); } VariableReference innerIdentifier = CreateNewIdentifier(innerKeySelector.Parameters[0].Name, innerKeySelector.Parameters[0].ParameterType); Expression innerKey = ProcessReturnExpression(innerKeySelector, new[] { innerIdentifier }); if (innerKey == null) { return(false); } LambdaExpression resultSelector = GetLambdaExpression(methodInvoke.Arguments[4], queryable); if (resultSelector == null || resultSelector.Arguments.Count != 2) { return(false); } ParameterReference[] resultSelectorParameters = resultSelector.Parameters; VariableReference resultSelectorSecondIdentifier = isGroupJoin ? CreateNewIdentifier(resultSelectorParameters[1].Name, resultSelectorParameters[1].ParameterType) : innerIdentifier; Expression result = ProcessReturnExpression(resultSelector, new[] { this.currentIdentifier, resultSelectorSecondIdentifier }); if (result == null) { return(false); } clauses.Add(new JoinClause(GetIdentifierReference(innerIdentifier, ref innerCollection), innerCollection, outerKey, innerKey, null)); if (isGroupJoin) { clauses.Add(new IntoClause(new VariableReferenceExpression(resultSelectorSecondIdentifier, null), null)); } clauses.Add(new SelectClause(result, null)); this.currentIdentifier = null; return(true); }
public static IVariable CreateIndexedPropertyReference(IRuntimeContextInstance context, IValue index) { var newVar = new VariableReference(); newVar._refType = ReferenceType.IndexedProperty; newVar._context = context; newVar._index = index; return newVar; }
public override void Visit(VariableReference node) { this.action(node); }
private bool IsTransparentIdentifier(VariableReference identifier) { return(identifier.Name.StartsWith("<>h__TransparentIdentifier") || identifier.Name.StartsWith("$VB$")); }
public void UndefinedVariable() { var variable = new VariableReference("foo", 0); var integer = new IntegerLiteral("42", 0); var assignment = new Assignment(variable, integer, 0); statementlist.Add(assignment); var parsetree = new Program(statementlist); Assert.Throws<SemanticError>(() => symbolTableBuilder.BuildSymbolTableAndTypeCheck(parsetree)); }
public static IVariable CreateSimpleReference(IVariable var) { var newVar = new VariableReference(); newVar._refType = ReferenceType.Simple; newVar._referencedValue = var; return newVar; }
public abstract void UnifyWithConnectedWireTypeAsNodeInput(VariableReference wireFacadeVariable, TerminalTypeUnificationResults unificationResults);
public void It_has_a_useful_ToString_method() { var a = new VariableReference("a"); Assert.AreEqual("VariableReference(\"a\")", a.ToString()); }
public Instruction ParseSingle(ParseState ParseState) { var InstructionPosition = Stream.Position; var OpcodeNum = BinaryReader.ReadUInt16(); if (!Opcodes.ContainsKey(OpcodeNum)) { throw(new NotImplementedException(String.Format("Unhandled opcode 0x{0:X2}", OpcodeNum))); } var Opcode = Opcodes[OpcodeNum]; var Params = new List<object>(); foreach (var FormatChar in Opcode.Format) { switch (FormatChar) { case '<': break; case 's': Params.Add(ReadString()); break; case 'S': Params.Add(ReadStringz()); break; case '1': Params.Add(BinaryReader.ReadByte()); break; case '7': Params.Add((AritmeticOps)BinaryReader.ReadByte()); break; case '9': Params.Add((ComparisionOps)BinaryReader.ReadByte()); break; case '2': Params.Add(BinaryReader.ReadInt16()); break; case 'v': Params.Add(new VariableReference() { Index = BinaryReader.ReadUInt16() }); break; case '4': Params.Add(BinaryReader.ReadUInt32()); break; case 'L': Params.Add(new LabelReference() { Offset = BinaryReader.ReadUInt32() }); break; case 'P': { var ParamType = BinaryReader.ReadByte(); object Value = null; switch (ParamType) { case 0x00: Value = BinaryReader.ReadSByte(); break; case 0x10: Value = BinaryReader.ReadByte(); break; case 0x20: Value = BinaryReader.ReadInt16(); break; case 0x40: Value = BinaryReader.ReadInt32(); break; case 0x01: Value = new VariableReference() { Index = BinaryReader.ReadUInt16() }; break; case 0x02: Value = new SpecialReference() { Index = BinaryReader.ReadUInt16() }; break; default: throw (new NotImplementedException(String.Format("Invalid param type {0}", ParamType))); } Params.Add(Value); } break; default: throw(new NotImplementedException(String.Format("Invalid format '{0}'", FormatChar))); } } try { if (ParseState.Unindent.Contains((uint)InstructionPosition)) { ParseState.Indent--; } switch (Opcode.OpcodeName) { case "JUMP_ALWAYS": ParseState.Indent--; break; } return new Instruction() { Position = (uint)InstructionPosition, Opcode = Opcode, Parameters = Params.ToArray(), Indent = ParseState.Indent, }; } finally { switch (Opcode.OpcodeName) { //case "FUNCTION_DEF": case "JUMP_IF": ParseState.Unindent.Add(((LabelReference)(Params.ToArray()[3])).Offset); ParseState.Indent++; break; case "JUMP_ALWAYS": ParseState.Unindent.Add(((LabelReference)(Params.ToArray()[0])).Offset); ParseState.Indent += 2; break; } } }
public void ReadBool() { var variabledecl = new VariableDeclaration("foo", "bool", 0); statementlist.Add(variabledecl); var variable = new VariableReference("foo", 0); var print = new ReadStatement(variable, 0); statementlist.Add(print); var parsetree = new Program(statementlist); Assert.Throws<SemanticError>(() => symbolTableBuilder.BuildSymbolTableAndTypeCheck(parsetree)); }
public static IVariable CreateContextPropertyReference(IRuntimeContextInstance context, int propertyNumber) { var newVar = new VariableReference(); newVar._refType = ReferenceType.ContextProperty; newVar._context = context; newVar._contextPropertyNumber = propertyNumber; return newVar; }
public void SeveralVariableDeclarationsBeforeLoop(string type) { var intdeclaration = new VariableDeclaration("foo", "int", 0); var otherdeclaration = new VariableDeclaration("bar", type, 0); var variableref = new VariableReference("bar", 0); var integer = new IntegerLiteral("5", 0); var range = new Range(integer, integer, 0); var loop = new Loop(variableref, range, new List<Statement>(), 0); statementlist.Add(intdeclaration); statementlist.Add(otherdeclaration); statementlist.Add(loop); var parsetree = new Program(statementlist); Assert.Throws<SemanticError>(() => symbolTableBuilder.BuildSymbolTableAndTypeCheck(parsetree)); }
/// <summary> /// Tries to get the variable that is used by the specified instruction. /// </summary> /// <param name="instruction"></param> /// <param name="varReference"></param> /// <returns>Flase if the instruction does not handle variables.</returns> private bool TryGetVariableFromInstruction(Instruction instruction, out VariableReference varReference) { return(StateMachineUtilities.TryGetVariableFromInstruction(instruction, moveNextMethodContext.Variables, out varReference)); }
public ReadStatement(VariableReference variable, int row) : base(row) { Variable = variable; }
private LinqQueryExpression RemoveTransparentIdentifiers(LinqQueryExpression originalQuery) { LinqQueryExpression linqQuery = (LinqQueryExpression)originalQuery.Clone(); List <VariableReference> identifiers = new List <VariableReference>(); TransparentIdentifierCleaner cleaner = new TransparentIdentifierCleaner(); HashSet <VariableReference> transparentIdentifiers = new HashSet <VariableReference>(); for (int i = 0; i < linqQuery.Clauses.Count; i++) { linqQuery.Clauses[i] = (QueryClause)cleaner.Visit(linqQuery.Clauses[i]); QueryClause currentClause = linqQuery.Clauses[i]; if (currentClause.CodeNodeType == CodeNodeType.FromClause) { identifiers.Add(GetVariableReference((currentClause as FromClause).Identifier)); } else if (currentClause.CodeNodeType == CodeNodeType.JoinClause) { if (linqQuery.Clauses[i + 1].CodeNodeType != CodeNodeType.IntoClause) { identifiers.Add(GetVariableReference((currentClause as JoinClause).InnerIdentifier)); } else { identifiers.Add(((IntoClause)linqQuery.Clauses[i + 1]).Identifier.Variable); i++; } } else if (currentClause.CodeNodeType == CodeNodeType.SelectClause && i != linqQuery.Clauses.Count - 1) { VariableReference intoIdentifier = ((IntoClause)linqQuery.Clauses[i + 1]).Identifier.Variable; if (IsTransparentIdentifier(intoIdentifier)) { Dictionary <PropertyDefinition, Expression> propertyToValueMap = GetPropertyToValueMap((currentClause as SelectClause).Expression); if (propertyToValueMap == null) { return(originalQuery); } if (identifiers.Count == 2) { if (!RemoveIdentifier(propertyToValueMap, identifiers)) { return(originalQuery); } linqQuery.Clauses.RemoveAt(i); linqQuery.Clauses.RemoveAt(i); i--; } else if (identifiers.Count == 1) { LetClause letClause = GenerateLetClause(propertyToValueMap, identifiers[0]); if (letClause == null) { return(originalQuery); } linqQuery.Clauses[i] = letClause; linqQuery.Clauses.RemoveAt(i + 1); } else { return(originalQuery); } this.methodContext.VariablesToRename.Add(intoIdentifier.Resolve()); transparentIdentifiers.Add(intoIdentifier); identifiers.Clear(); identifiers.Add(intoIdentifier); UpdateCleaner(cleaner, intoIdentifier, propertyToValueMap); } } else if (currentClause.CodeNodeType == CodeNodeType.IntoClause) { identifiers.Clear(); identifiers.Add(((IntoClause)currentClause).Identifier.Variable); } } TransparentIdentifierFinder finder = new TransparentIdentifierFinder(transparentIdentifiers); if (finder.ContainsTransparentIdentifiers(linqQuery)) { return(originalQuery); } return(linqQuery); }
public Loop(VariableReference variable, Range range, List<Statement> body, int row) : base(row) { Variable = variable; Range = range; LoopBody = body; }
private LetClause GenerateLetClause(Dictionary <PropertyDefinition, Expression> propertyToValueMap, VariableReference oldIdentifier) { PropertyDefinition oldIdentifierProperty = null; PropertyDefinition newIdentifierProperty = null; foreach (KeyValuePair <PropertyDefinition, Expression> pair in propertyToValueMap) { if (pair.Key.Name == oldIdentifier.Name && pair.Value.CodeNodeType == CodeNodeType.VariableReferenceExpression && (pair.Value as VariableReferenceExpression).Variable == oldIdentifier) { oldIdentifierProperty = pair.Key; } else { newIdentifierProperty = pair.Key; } } if (oldIdentifierProperty == null || newIdentifierProperty == null) { return(null); } Expression newIdentifierValue = propertyToValueMap[newIdentifierProperty]; VariableDefinition newIdentifier = CreateNewIdentifier(newIdentifierProperty.Name, newIdentifierValue.ExpressionType); LetClause result = new LetClause(new VariableReferenceExpression(newIdentifier, null), newIdentifierValue, null); propertyToValueMap[newIdentifierProperty] = result.Identifier; return(result); }
protected Instruction SetupSingleReturnPoint(Instruction suggestedSingleReturnPoint, VariableReference resultVar) { var proc = ILProcessorFactory.GetOrCreateProcessor(TargetMethod.Body); var rets = proc.Body.Instructions.Where(i => i.OpCode == OpCodes.Ret).ToList(); if (rets.Count == 1) { if (!TargetMethod.ReturnType.IsTypeOf(typeof(void))) { proc.SafeInsertBefore(rets.First(), proc.CreateOptimized(OpCodes.Stloc, resultVar.Index)); } return(proc.SafeReplace(rets.First(), suggestedSingleReturnPoint)); } foreach (var i in rets) { if (!TargetMethod.ReturnType.IsTypeOf(typeof(void))) { proc.SafeInsertBefore(i, proc.CreateOptimized(OpCodes.Stloc, resultVar.Index)); } proc.SafeReplace(i, proc.Create(OpCodes.Br, suggestedSingleReturnPoint)); //todo:: optimize } proc.SafeAppend(suggestedSingleReturnPoint); return(suggestedSingleReturnPoint); }
protected override async Task OnParametersSetAsync() { _renderFragments = new QueryDictionary <RenderFragment>(); foreach (var column in GridComponent.Grid.Columns) { // Name must have a non empty value if (string.IsNullOrWhiteSpace(column.Name)) { column.Name = Guid.NewGuid().ToString(); } if (((ICGridColumn)column).SubGrids != null) { var values = ((ICGridColumn)column).GetSubGridKeyValues(Item); var grid = await((ICGridColumn)column).SubGrids(values.Values.ToArray(), false, true, false, true) as ICGrid; grid.Direction = GridComponent.Grid.Direction; grid.FixedValues = values; VariableReference reference = new VariableReference(); if (Children.ContainsKey(column.Name)) { Children[column.Name] = reference; } else { Children.Add(column.Name, reference); } if (_renderFragments.ContainsKey(column.Name)) { _renderFragments[column.Name] = CreateSubGridComponent(grid, reference); } else { _renderFragments.Add(column.Name, CreateSubGridComponent(grid, reference)); } } else if (column.DeleteComponentType != null) { VariableReference reference = new VariableReference(); if (Children.ContainsKey(column.Name)) { Children[column.Name] = reference; } else { Children.Add(column.Name, reference); } if (_renderFragments.ContainsKey(column.Name)) { _renderFragments[column.Name] = GridCellComponent <T> .CreateComponent(_sequence, GridComponent, column.DeleteComponentType, column, Item, null, true, reference); } else { _renderFragments.Add(column.Name, GridCellComponent <T> .CreateComponent(_sequence, GridComponent, column.DeleteComponentType, column, Item, null, true, reference)); } } } _tabGroups = GridComponent.Grid.Columns .Where(r => !string.IsNullOrWhiteSpace(r.TabGroup) && _renderFragments.Keys.Any(s => s.Equals(r.Name))) .Select(r => r.TabGroup).Distinct(); if (((CGrid <T>)GridComponent.Grid).ButtonCrudComponents != null && ((CGrid <T>)GridComponent.Grid).ButtonCrudComponents.Count() > 0) { foreach (var key in ((CGrid <T>)GridComponent.Grid).ButtonCrudComponents.Keys) { var buttonCrudComponent = ((CGrid <T>)GridComponent.Grid).ButtonCrudComponents.Get(key); if ((buttonCrudComponent.DeleteMode != null && buttonCrudComponent.DeleteMode(Item)) || (buttonCrudComponent.DeleteModeAsync != null && await buttonCrudComponent.DeleteModeAsync(Item)) || (buttonCrudComponent.GridMode.HasFlag(GridMode.Delete))) { _buttonCrudComponentVisibility.Add(key, true); } else { _buttonCrudComponentVisibility.Add(key, false); } } } _shouldRender = true; }
public void ValidLoop() { var integer1 = new IntegerLiteral("1", 0); var integer2 = new IntegerLiteral("5", 0); var range = new Range(integer1, integer2, 0); var variabledecl = new VariableDeclaration("foo", "int", 0); var variable = new VariableReference("foo", 0); var loop = new Loop(variable, range, new List<Statement>(), 0); statementlist.Add(variabledecl); statementlist.Add(loop); var parsetree = new Program(statementlist); Assert.DoesNotThrow(() => symbolTableBuilder.BuildSymbolTableAndTypeCheck(parsetree)); }
public bool Process(AssemblyProcessorContext context) { var assembly = context.Assembly; var mscorlibAssembly = CecilExtensions.FindCorlibAssembly(assembly); if (mscorlibAssembly == null) { throw new InvalidOperationException("Missing mscorlib.dll from assembly"); } // For now, use import, but this can cause mixed framework versions when processing an assembly with a different framework version. voidType = assembly.MainModule.TypeSystem.Void; stringType = assembly.MainModule.TypeSystem.String; objectType = assembly.MainModule.TypeSystem.Object; var propertyInfoType = assembly.MainModule.ImportReference(mscorlibAssembly.MainModule.GetTypeResolved(typeof(PropertyInfo).FullName)); var typeType = mscorlibAssembly.MainModule.GetTypeResolved(typeof(Type).FullName); TypeDefinition propertyChangedExtendedEventArgsType; ModuleDefinition xenkoCoreModule; try { xenkoCoreModule = assembly.GetXenkoCoreModule(); } catch (Exception) { return(true); } propertyChangedExtendedEventArgsType = xenkoCoreModule.GetTypes().First(x => x.Name == "PropertyChangedExtendedEventArgs").Resolve(); var typeTokenInfoEx = mscorlibAssembly.MainModule.GetTypeResolved("System.Reflection.TypeInfo").Resolve(); var getPropertyMethod = typeTokenInfoEx.Methods.First(x => x.Name == "GetDeclaredProperty" && x.Parameters.Count == 1); var getTypeFromHandleMethod = typeType.Methods.First(x => x.Name == "GetTypeFromHandle"); var getTokenInfoExMethod = CecilExtensions.FindReflectionAssembly(assembly).MainModule.GetTypeResolved("System.Reflection.IntrospectionExtensions").Resolve().Methods.First(x => x.Name == "GetTypeInfo"); var propertyChangedExtendedEventArgsConstructor = assembly.MainModule.ImportReference(propertyChangedExtendedEventArgsType.Methods.First(x => x.IsConstructor)); bool modified = false; foreach (var type in assembly.MainModule.GetTypes()) { MethodReference getPropertyChangedMethod; getPropertyChangedMethod = GetGetPropertyChangedMethod(assembly, type); //var propertyChangedField = GetPropertyChangedField(type); //if (propertyChangedField == null) // continue; var propertyChangedField = GetPropertyChangedField(type); if (getPropertyChangedMethod == null && propertyChangedField == null) { continue; } TypeReference propertyChangedFieldType; if (getPropertyChangedMethod == null) { modified = true; getPropertyChangedMethod = GetOrCreateGetPropertyChangedMethod(assembly, type, propertyChangedField); } if (propertyChangedField != null) { propertyChangedField = assembly.MainModule.ImportReference(propertyChangedField); propertyChangedFieldType = propertyChangedField.FieldType; } else { propertyChangedFieldType = getPropertyChangedMethod.ReturnType; } // Add generic to declaring type if (getPropertyChangedMethod.DeclaringType.HasGenericParameters) { getPropertyChangedMethod = getPropertyChangedMethod.MakeGeneric(getPropertyChangedMethod.DeclaringType.GenericParameters.ToArray()); } var propertyChangedInvoke = assembly.MainModule.ImportReference(propertyChangedFieldType.Resolve().Methods.First(x => x.Name == "Invoke")); foreach (var property in type.Properties) { if (property.SetMethod == null || !property.HasThis) { continue; } MethodReference propertyGetMethod = property.GetMethod; // Only patch properties that have a public Getter var methodDefinition = propertyGetMethod.Resolve(); if ((methodDefinition.Attributes & MethodAttributes.Public) != MethodAttributes.Public) { continue; } // Add generic to declaring type if (propertyGetMethod.DeclaringType.HasGenericParameters) { propertyGetMethod = propertyGetMethod.MakeGeneric(propertyGetMethod.DeclaringType.GenericParameters.ToArray()); } //var versionableAttribute = property.CustomAttributes.FirstOrDefault(x => x.AttributeType.FullName == typeof(VersionableAttribute).FullName); //if (versionableAttribute == null) // continue; modified = true; FieldReference staticField = new FieldDefinition(property.Name + "PropertyInfo", FieldAttributes.Static | FieldAttributes.Private | FieldAttributes.InitOnly, propertyInfoType); type.Fields.Add((FieldDefinition)staticField); // Add generic to declaring type if (staticField.DeclaringType.HasGenericParameters) { staticField = staticField.MakeGeneric(staticField.DeclaringType.GenericParameters.ToArray()); } // In static constructor, find PropertyInfo and store it in static field { var staticConstructor = type.GetStaticConstructor(); if (staticConstructor == null) { staticConstructor = new MethodDefinition(".cctor", MethodAttributes.Private | MethodAttributes.HideBySig | MethodAttributes.Static | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName, voidType); staticConstructor.Body.GetILProcessor().Append(Instruction.Create(OpCodes.Ret)); type.Methods.Add(staticConstructor); } VariableReference localTokenEx = null; int localTokenExIndex = 0; for (int i = 0; i < staticConstructor.Body.Variables.Count; i++) { var localVar = staticConstructor.Body.Variables[i]; if (localVar.VariableType.FullName == typeTokenInfoEx.FullName) { localTokenEx = localVar; localTokenExIndex = i; break; } } if (localTokenEx == null) { localTokenEx = new VariableDefinition(assembly.MainModule.ImportReference(typeTokenInfoEx)); staticConstructor.Body.Variables.Add((VariableDefinition)localTokenEx); localTokenExIndex = staticConstructor.Body.Variables.Count - 1; } var ilProcessor = staticConstructor.Body.GetILProcessor(); var returnInstruction = staticConstructor.Body.Instructions.Last(); var newReturnInstruction = Instruction.Create(returnInstruction.OpCode); newReturnInstruction.Operand = returnInstruction.Operand; returnInstruction.OpCode = OpCodes.Nop; returnInstruction.Operand = null; // Find PropertyInfo and store it in static field ilProcessor.Append(Instruction.Create(OpCodes.Ldtoken, type)); ilProcessor.Append(Instruction.Create(OpCodes.Call, assembly.MainModule.ImportReference(getTypeFromHandleMethod))); ilProcessor.Append(Instruction.Create(OpCodes.Call, assembly.MainModule.ImportReference(getTokenInfoExMethod))); ilProcessor.Append(LocationToStloc(ilProcessor, localTokenExIndex)); ilProcessor.Append(ilProcessor.Create(OpCodes.Ldloca_S, (byte)localTokenExIndex)); ilProcessor.Append(Instruction.Create(OpCodes.Ldstr, property.Name)); ilProcessor.Append(Instruction.Create(OpCodes.Call, assembly.MainModule.ImportReference(getPropertyMethod))); ilProcessor.Append(Instruction.Create(OpCodes.Stsfld, staticField)); ilProcessor.Append(newReturnInstruction); } { var ilProcessor = property.SetMethod.Body.GetILProcessor(); var returnInstruction = property.SetMethod.Body.Instructions.Last(); var firstInstruction = property.SetMethod.Body.Instructions[0]; if (property.SetMethod.Body.Instructions[0].OpCode != OpCodes.Nop) { ilProcessor.InsertBefore(property.SetMethod.Body.Instructions[0], Instruction.Create(OpCodes.Nop)); } var newReturnInstruction = Instruction.Create(returnInstruction.OpCode); newReturnInstruction.Operand = returnInstruction.Operand; returnInstruction.OpCode = OpCodes.Nop; returnInstruction.Operand = null; var propertyChangedVariable = new VariableDefinition(assembly.MainModule.ImportReference(propertyChangedFieldType)); property.SetMethod.Body.Variables.Add(propertyChangedVariable); var oldValueVariable = new VariableDefinition(objectType); property.SetMethod.Body.Variables.Add(oldValueVariable); Instruction jump1, jump2; // Prepend: // var propertyChanged = GetPropertyChanged(); // var oldValue = propertyChanged != null ? (object)Property : null; property.SetMethod.Body.SimplifyMacros(); ilProcessor.InsertBefore(firstInstruction, Instruction.Create(OpCodes.Ldarg_0)); ilProcessor.InsertBefore(firstInstruction, Instruction.Create(OpCodes.Call, getPropertyChangedMethod)); ilProcessor.InsertBefore(firstInstruction, Instruction.Create(OpCodes.Stloc, propertyChangedVariable)); ilProcessor.InsertBefore(firstInstruction, Instruction.Create(OpCodes.Ldloc, propertyChangedVariable)); ilProcessor.InsertBefore(firstInstruction, jump1 = Instruction.Create(OpCodes.Brtrue, Instruction.Create(OpCodes.Nop))); ilProcessor.InsertBefore(firstInstruction, Instruction.Create(OpCodes.Ldnull)); ilProcessor.InsertBefore(firstInstruction, jump2 = Instruction.Create(OpCodes.Br, Instruction.Create(OpCodes.Nop))); ilProcessor.InsertBefore(firstInstruction, (Instruction)(jump1.Operand = Instruction.Create(OpCodes.Ldarg_0))); ilProcessor.InsertBefore(firstInstruction, Instruction.Create(OpCodes.Call, propertyGetMethod)); if (property.PropertyType.IsValueType) { ilProcessor.InsertBefore(firstInstruction, Instruction.Create(OpCodes.Box, property.PropertyType)); } ilProcessor.InsertBefore(firstInstruction, (Instruction)(jump2.Operand = Instruction.Create(OpCodes.Nop))); ilProcessor.InsertBefore(firstInstruction, Instruction.Create(OpCodes.Stloc, oldValueVariable)); // Append: // if (propertyChanged != null) // propertyChanged(this, new PropertyChangedExtendedEventArgs("Property", oldValue, Property)); ilProcessor.Append(Instruction.Create(OpCodes.Ldloc, propertyChangedVariable)); ilProcessor.Append(Instruction.Create(OpCodes.Ldnull)); ilProcessor.Append(Instruction.Create(OpCodes.Ceq)); ilProcessor.Append(Instruction.Create(OpCodes.Brtrue, newReturnInstruction)); ilProcessor.Append(Instruction.Create(OpCodes.Ldloc, propertyChangedVariable)); ilProcessor.Append(Instruction.Create(OpCodes.Ldarg_0)); ilProcessor.Append(Instruction.Create(OpCodes.Ldsfld, staticField)); ilProcessor.Append(Instruction.Create(OpCodes.Ldloc, oldValueVariable)); ilProcessor.Append(Instruction.Create(OpCodes.Ldarg_0)); ilProcessor.Append(Instruction.Create(OpCodes.Call, propertyGetMethod)); if (property.PropertyType.IsValueType) { ilProcessor.Append(Instruction.Create(OpCodes.Box, property.PropertyType)); } ilProcessor.Append(Instruction.Create(OpCodes.Newobj, propertyChangedExtendedEventArgsConstructor)); ilProcessor.Append(Instruction.Create(OpCodes.Callvirt, propertyChangedInvoke)); ilProcessor.Append(Instruction.Create(OpCodes.Nop)); ilProcessor.Append(newReturnInstruction); property.SetMethod.Body.OptimizeMacros(); } } } return(modified); }
public void FixtureSetUp() { var op1decl = new VariableDeclaration("op1", "int", 0); var op2decl = new VariableDeclaration("op2", "int", 0); resultdecl = new VariableDeclaration("result", "int", 0); op1assignment = new Assignment(op1decl, new IntegerLiteral("5", 0), 0); op2assignment = new Assignment(op2decl, new IntegerLiteral("2", 0), 0); op1 = new VariableReference("op1", 0); op2 = new VariableReference("op2", 0); }
/// <summary> /// Run the interpretation /// </summary> internal override void Execute() { int indexValue = -1; object targetObject = null; object leftValue = null; object rightValue; PropertyInfo propertyInfo; Variable propertyVariable; IList propertyVariableList; var leftExpression = Statement._leftExpression; var rightExpression = Statement._rightExpression; if (DebugMode) { ParentInterpreter.Log(this, $"Assign '{leftExpression}' to '{rightExpression}'"); if (!typeof(IAlgorithmAssignable).IsAssignableFrom(leftExpression.GetType())) { ParentInterpreter.ChangeState(this, new AlgorithmInterpreterStateEventArgs(new Error(new NotAssignableException($"The left expression is not assignable."), Statement), ParentInterpreter.GetDebugInfo())); return; } } switch (leftExpression.DomType) { case AlgorithmDomType.PropertyReferenceExpression: var propertyReferenceInterpreter = new PropertyReference(DebugMode, ParentInterpreter, leftExpression); leftValue = propertyReferenceInterpreter.GetAssignableObject(); targetObject = propertyReferenceInterpreter.TargetObject; break; case AlgorithmDomType.VariableReferenceExpression: leftValue = new VariableReference(DebugMode, ParentInterpreter, leftExpression).GetAssignableObject(); break; case AlgorithmDomType.ArrayIndexerExpression: var arrayIndexerInterpreter = new ArrayIndexerExpression(DebugMode, ParentInterpreter, leftExpression); leftValue = arrayIndexerInterpreter.GetAssignableObject(); indexValue = arrayIndexerInterpreter.IndexValue; break; default: ParentInterpreter.ChangeState(this, new AlgorithmInterpreterStateEventArgs(new Error(new InvalidCastException($"Unable to find an interpreter for this expression : '{leftExpression.GetType().FullName}'"), Statement), ParentInterpreter.GetDebugInfo())); break; } if (ParentInterpreter.FailedOrStop) { return; } rightValue = ParentInterpreter.RunExpression(rightExpression); if (ParentInterpreter.FailedOrStop) { return; } propertyInfo = leftValue as PropertyInfo; if (propertyInfo != null) { if (!propertyInfo.CanWrite) { ParentInterpreter.ChangeState(this, new AlgorithmInterpreterStateEventArgs(new Error(new NotAssignableException($"This core property is not assignable."), Statement), ParentInterpreter.GetDebugInfo())); return; } propertyInfo.SetValue(targetObject, rightValue); } propertyVariable = leftValue as Variable; if (propertyVariable != null) { if (propertyVariable.IsArray && !(typeof(Array).IsAssignableFrom(rightValue.GetType()) || typeof(IList).IsAssignableFrom(rightValue.GetType()))) { ParentInterpreter.ChangeState(this, new AlgorithmInterpreterStateEventArgs(new Error(new NotAssignableException($"The left expression wait for an array, but the right value is not an array."), Statement), ParentInterpreter.GetDebugInfo())); return; } if (!propertyVariable.IsArray && (typeof(Array).IsAssignableFrom(rightValue.GetType()) || typeof(IList).IsAssignableFrom(rightValue.GetType()))) { ParentInterpreter.ChangeState(this, new AlgorithmInterpreterStateEventArgs(new Error(new NotAssignableException($"The left expression does not support array value, but the right value is an array."), Statement), ParentInterpreter.GetDebugInfo())); return; } propertyVariable.Value = rightValue; } propertyVariableList = leftValue as IList; if (propertyVariableList != null) { if (indexValue < 0 || indexValue >= propertyVariableList.Count) { ParentInterpreter.ChangeState(this, new AlgorithmInterpreterStateEventArgs(new Error(new IndexOutOfRangeException($"Unable to get the item number '{indexValue}' because the limit of the array is '{propertyVariableList.Count - 1}'."), Statement), ParentInterpreter.GetDebugInfo())); return; } propertyVariableList[indexValue] = rightValue; } if (DebugMode) { ParentInterpreter.Log(this, "'{0}' is now equal to {1}", leftExpression.ToString(), rightValue == null ? "{null}" : $"'{rightValue}' (type:{rightValue.GetType().FullName})"); } }
public void Visit(VariableReference variable) { var getter = context.CompiledGetter(variable.Path); getter = CompoundExpression.NullCheck(getter, ""); getter = Expression.Call(getter, context.TargetType.GetMethod("ToString")); if (variable.Escaped) { parts.Add(Expression.Call(null, typeof(Encoders).GetMethod("DefaultHtmlEncode"), getter)); } else { parts.Add(getter); } }