protected PreresolvingDatumWriter(Schema schema, ArrayAccess arrayAccess, MapAccess mapAccess) { Schema = schema; _arrayAccess = arrayAccess; _mapAccess = mapAccess; _writer = ResolveWriter(schema); }
public bool Visit(ArrayAccess node) { if (node.SymType != null) { return(true); } node.ArrayIdent.Accept(this); foreach (var expression in node.AccessExpr) { expression.Accept(this); if (expression.SymType.GetType() != SymbolStack.SymInt.GetType()) { throw new Exception(string.Format( "({0}, {1}) semantic error: index '{2}' is not integer", expression.Token.Line, expression.Token.Line, expression.ToString())); } } if (node.ArrayIdent.SymType == null) { throw new Exception(string.Format( "({0}, {1}) semantic error: array type of expression '{2}' is undeclared", node.Token.Line, node.Token.Line, node.ToString())); } node.SymType = ((SymArrayType)node.ArrayIdent.SymType).ElementSymType; node.IsLValue = true; return(true); }
public void Visit(ArrayAccess n) { n.Array.Accept(this); Helpers.Write("["); n.Index.Accept(this); Helpers.Write("]"); }
public BitRange VisitArrayAccess(ArrayAccess acc) { var arr = acc.Array.Accept(this); var idx = acc.Index.Accept(this); return(arr | idx); }
protected IEncoder(Schema schema, ArrayAccess arrayAccess, MapAccess mapAccess) { Schema = schema; _arrayAccess = arrayAccess; _mapAccess = mapAccess; _writer = ResolveWriter(schema); }
public bool VisitArrayAccess(ArrayAccess acc, TypeVariable tv) { MeetDataType(acc, acc.DataType); Expression arr; int offset; if (fieldAccessPattern.Match(acc.Array)) { arr = fieldAccessPattern.CapturedExpression("p"); offset = OffsetOf((Constant)fieldAccessPattern.CapturedExpression("c")); } else { arr = acc.Array; offset = 0; } BinaryExpression b = acc.Index as BinaryExpression; int stride = 1; if (b != null && (b.Operator == Operator.IMul || b.Operator == Operator.SMul || b.Operator == Operator.UMul)) { Constant c = b.Right as Constant; if (c != null) { stride = c.ToInt32(); } } ArrayField(null, arr, arr.DataType.Size, offset, stride, 0, acc); acc.Array.Accept(this, acc.Array.TypeVariable); acc.Index.Accept(this, acc.Index.TypeVariable); return(false); }
private ArrayAccess ParseArrayAccess() { var tx = _stream.Fixate(); var id = ParseIdentifier(false); if (id == null) { return(null); } var t = NextToken(); if (!t.IsDelimiter(Delimiter.BraceOpen)) { _stream.Rollback(tx); // Undo brace and identifier read return(null); } var node = new ArrayAccess(); node.AddChild(id); var expr = ParseExpression(); node.AddChild(expr); t = NextToken(); AssertDelimiter(Delimiter.BraceClose, t); node.PropagatePosition(t); return(node); }
private IADomain ReadTransfer(ReadStmt readStmt, IADomain domain) { var newDomain = CopyDomain(domain); if (domain.IsBottom()) { return(newDomain); } var ident = readStmt.Left switch { VarAccess varAccess => varAccess.Left, ArrayAccess arrayAccess => arrayAccess.Left, RecordAccess recordAccess => recordAccess.Right, }; if (readStmt.Left is ArrayAccess) { var ra = readStmt.Left as ArrayAccess; var indexInterval = IAUtil.Arithmetic(ra.Right, domain); if (indexInterval.IsBottom) { return(Bottom().GetDomain()); } } newDomain[ident] = new Interval(ExtendedZ.NegativeInfinity(), ExtendedZ.PositiveInfinity()).ToIntervalK(_program); return(newDomain); }
private (int Position, string Variable) _GetAccessor(ArrayAccess access) { var array = access.Expression; if (array.Accessors.Count == 0) { Debug.WriteLine($"unsupported amount of array accessors: {array.Accessors.Count}"); throw new UnsupportedSyntaxException($"invalid number of dimensions for array access: {array}"); } for (var i = 0; i < array.Accessors.Count; ++i) { var accessor = (array.Accessors[i] as VariableExpression)?.Name; if (accessor == null) { continue; } var loopDependant = _loopDependenceAnalysis.Entry[access.Node] .Where(descriptor => descriptor.Kind is LoopDependent) .Where(descriptor => descriptor.Name.Equals(accessor)) .Any(); if (loopDependant) { return(i, accessor); } } throw new UnsupportedSyntaxException($"array access does not make us of a loop dependant variable: {array}"); }
public void InstanceIsNotEqualToCompletelyDifferent() { var access1 = new ArrayAccess(_CreateFlowNode(), _CreateArrayExpression(), true); var access2 = new ArrayAccess(_CreateFlowNode(), _CreateArrayExpression(), false); Assert.AreNotEqual(access1, access2); }
public DataType VisitArrayAccess(ArrayAccess acc) { DataType dtArr = acc.Array.Accept(this); DataType dtIdx = acc.Index.Accept(this); return(RecordDataType(acc.DataType, acc)); }
public void InstanceHasNotSameHashCodeAsCompletelyDifferent() { var access1 = new ArrayAccess(_CreateFlowNode(), _CreateArrayExpression(), true); var access2 = new ArrayAccess(_CreateFlowNode(), _CreateArrayExpression(), false); Assert.AreNotEqual(access1.GetHashCode(), access2.GetHashCode()); }
public virtual Expression VisitArrayAccess(ArrayAccess acc) { var a = acc.Array.Accept(this); var i = acc.Index.Accept(this); return(new ArrayAccess(acc.DataType, a, i)); }
public virtual Expression VisitArrayAccess(ArrayAccess acc) { return(new ArrayAccess( acc.DataType, acc.Array.Accept(this), acc.Index.Accept(this))); }
public bool VisitArrayAccess(ArrayAccess acc) { var dead = acc.Array.Accept(this); dead &= acc.Index.Accept(this); return(dead); }
private List <Expression> ExtractFromArrayAccess(ArrayAccess access) { var binaryOperation = new BinaryOperation(access.InputRange, access.Lhs, access.Index); var result = this.ExtractFromOperationNode(binaryOperation); (access.Lhs, access.Index) = (binaryOperation.LeftValue, binaryOperation.RightValue); return(result); }
public void InstanceIsNotEqualToOtherWithDifferentExpression() { var node = _CreateFlowNode(); var access1 = new ArrayAccess(node, _CreateArrayExpression(), false); var access2 = new ArrayAccess(node, _CreateArrayExpression(), false); Assert.AreNotEqual(access1, access2); }
public void InstanceIsNotEqualToOtherWithDifferentNode() { var expression = _CreateArrayExpression(); var access1 = new ArrayAccess(_CreateFlowNode(), expression, true); var access2 = new ArrayAccess(_CreateFlowNode(), expression, true); Assert.AreNotEqual(access1, access2); }
public override bool Visit(ArrayAccess node) { Visit((LvalueExpression)node); TraversePrint(node.lvalue); TraversePrint(node.acessors); TraversePrint(node.array); return(true); }
public void InstanceHasNotSameHashCodeAsOtherWithDifferenExpression() { var node = _CreateFlowNode(); var access1 = new ArrayAccess(node, _CreateArrayExpression(), false); var access2 = new ArrayAccess(node, _CreateArrayExpression(), false); Assert.AreNotEqual(access1.GetHashCode(), access2.GetHashCode()); }
public void EqbArrayAccess() { ArrayAccess e = new ArrayAccess(PrimitiveType.Real32, new Identifier("a", PrimitiveType.Ptr32, null), new Identifier("i", PrimitiveType.Int32, null)); e.Accept(eqb); Assert.AreEqual("T_3", e.TypeVariable.ToString()); Assert.AreEqual("T_1", e.Array.TypeVariable.ToString()); Assert.AreEqual("T_2", e.Index.TypeVariable.ToString()); }
public void EqbArrayAccess() { ArrayAccess e = new ArrayAccess(PrimitiveType.Real32, new Identifier("a", PrimitiveType.Pointer32, null), new Identifier("i", PrimitiveType.Int32, null)); e.Accept(eqb); Assert.AreEqual("T_3", e.TypeVariable.ToString()); Assert.AreEqual("T_1", e.Array.TypeVariable.ToString()); Assert.AreEqual("T_2", e.Index.TypeVariable.ToString()); }
public Result VisitArrayAccess(ArrayAccess acc) { var a = acc.Array.Accept(this).PropagatedExpression; var i = acc.Index.Accept(this).PropagatedExpression; var newAcc = new ArrayAccess(acc.DataType, a, i); return(SimplifyExpression(newAcc)); }
public virtual T Visit(ArrayAccess node) { Visit((LvalueExpression)node); traverse(node.lvalue); traverse(node.acessors); traverse(node.array); return(DefaultReturnValue()); }
public void InstanceHasSameHashCodeAsOtherWithSameInformation() { var expression = _CreateArrayExpression(); var node = _CreateFlowNode(); var access1 = new ArrayAccess(node, expression, true); var access2 = new ArrayAccess(node, expression, true); Assert.AreEqual(access1.GetHashCode(), access2.GetHashCode()); }
public void InstancesHaveNotSameHashCodeIfOneIsWritingAndOtherNot() { var expression = _CreateArrayExpression(); var node = _CreateFlowNode(); var access1 = new ArrayAccess(node, expression, false); var access2 = new ArrayAccess(node, expression, true); Assert.AreNotEqual(access1.GetHashCode(), access2.GetHashCode()); }
public void InstanceIsEqualToOtherWithSameInformation() { var expression = _CreateArrayExpression(); var node = _CreateFlowNode(); var access1 = new ArrayAccess(node, expression, true); var access2 = new ArrayAccess(node, expression, true); Assert.AreEqual(access1, access2); }
public void InstanceIsNotEqualIfOneIsWritingAndOtherNot() { var expression = _CreateArrayExpression(); var node = _CreateFlowNode(); var access1 = new ArrayAccess(node, expression, false); var access2 = new ArrayAccess(node, expression, true); Assert.AreNotEqual(access1, access2); }
public void VisitArrayAccess(ArrayAccess acc) { int prec = SetPrecedence(PrecedenceArrayAccess); acc.Array.Accept(this); ResetPresedence(prec); writer.Write("["); WriteExpression(acc.Index); writer.Write("]"); }
public override Expression VisitArrayAccess(ArrayAccess acc) { if (acc.Array is BinaryExpression bin && bin.Operator == Operator.IAdd && bin.Right is Constant c) { // (x + C)[...] var arrayPtr = Rewrite(bin.Left, false); var index = Rewrite(acc.Index, false); return(RewriteComplexExpression(arrayPtr, index, c.ToInt32(), true)); }
public Expression VisitArrayAccess(ArrayAccess acc) { var arr = acc.Array.Accept(this); var idx = acc.Index.Accept(this); if (arr is InvalidConstant || idx is InvalidConstant) { return(InvalidConstant.Create(acc.DataType)); } return(new ArrayAccess(acc.DataType, arr, idx)); }
public virtual void VisitArrayAccess(ArrayAccess acc) { acc.Index.Accept(this); acc.Array.Accept(this); }
public override Expression VisitArrayAccess(ArrayAccess acc) { BinaryExpression bin; Constant c; if (acc.Array.As(out bin) && bin.Operator == Operator.IAdd && bin.Right.As(out c)) { // (x + C)[...] var arrayPtr = Rewrite(bin.Left, false); var index = Rewrite(acc.Index, false); return RewriteComplexExpression(arrayPtr, index, c.ToInt32(), true); } else { // (x)[...] var arrayPtr = Rewrite(acc.Array, false); var index = Rewrite(acc.Index, false); return RewriteComplexExpression(arrayPtr, index, 0, true); } }
public void VisitArrayAccess(ArrayAccess access) { handler.MemAccessTrait(basePointer, access, access.DataType.Size, eField, 0); }
public override void VisitArrayAccess(ArrayAccess acc) { acc.Array.Accept(this); acc.Index.Accept(this); EnsureTypeVariable(acc); }
void BODY_ARRAYACCESS(out pBaseLangObject outObj, pBaseLangObject parent) { var obj = new ArrayAccess(parent); outObj = obj; pBaseLangObject blo; Expect(12); VALUE(out blo, obj); obj.addChild(blo); Expect(13); }
public void VisitArrayAccess(ArrayAccess acc) { int prec = SetPrecedence(PrecedenceArrayAccess); acc.Array.Accept(this); ResetPresedence(prec); writer.Write("["); WriteExpression(acc.Index); writer.Write("]"); }
public override Expression VisitArrayAccess(ArrayAccess acc) { var tmr = new TypedMemoryExpressionRewriter(prog); return tmr.RewriteArrayAccess(acc.TypeVariable, acc.Array, acc.Index); }