public void EqualsObj_xEqualsy_and_yEqualsx_returns_xEqualsz() { var x = new SequenceExpression(new Chromosome[2]); var y = new SequenceExpression(new Chromosome[2]); var z = new SequenceExpression(new Chromosome[2]); Assert.IsTrue(!(x.Equals((object)y) && y.Equals((object)z)) || x.Equals((object)z)); }
protected virtual void VisitSequenceExpression(SequenceExpression sequenceExpression) { foreach (var e in sequenceExpression.Expressions) { VisitExpression(e); } }
public int Visit(SequenceExpression expression) { _writer.Write("seq {0}(", expression.Name); for (var i = 0; i < expression.Arguments.Count; i++) { if (i > 0) { _writer.Write(", "); } _writer.Write(expression.Arguments[i]); } if (expression.OtherArguments != null) { if (expression.Arguments.Count > 0) { _writer.Write(", "); } _writer.Write("...{0}", expression.OtherArguments); } _writer.WriteLine(")"); expression.Block.Accept(this); return(0); }
public override int Compile(FunctionContext context) { var seq = new SequenceExpression(_token, null, new List <string>(), null, Body); var expr = new CallExpression(_token, seq, new List <Expression>()); return(expr.Compile(context)); }
public AssignmentTargetAttributeIndexed(SequenceVariable destVar, String attributeName, SequenceExpression keyExpr) : base(AssignmentTargetType.AttributeIndexed) { DestVar = destVar; AttributeName = attributeName; KeyExpression = keyExpr; }
protected AssignmentTargetAttributeIndexed(AssignmentTargetAttributeIndexed that, Dictionary<SequenceVariable, SequenceVariable> originalToCopy, IGraphProcessingEnvironment procEnv) : base(that) { DestVar = that.DestVar.Copy(originalToCopy, procEnv); AttributeName = that.AttributeName; KeyExpression = that.KeyExpression.CopyExpression(originalToCopy, procEnv); }
/// <summary> /// Helper for checking function method calls. /// Checks whether called entity exists, and type checks the input. /// Throws an exception when an error is found. /// </summary> /// <param name="seqExprFuncMethodCall">The function method call to check</param> /// <param name="targetExpr">The target of the procedure function call</param> public void CheckFunctionMethodCall(SequenceExpression targetExpr, SequenceExpressionFunctionMethodCall seqExprFuncMethodCall) { String targetExprType = targetExpr.Type(this); if (targetExprType == "") { // only runtime checks possible (we could check whether the called procedure signature exists in at least one of the model types, if not it's a type error, can't work at runtime, but that kind of negative check is not worth the effort) return; } InheritanceType ownerType = TypesHelper.GetInheritanceType(targetExprType, Model); if (ownerType == null) { // error, must be node or edge type throw new SequenceParserException(targetExprType, SequenceParserError.UserMethodsOnlyAvailableForGraphElements); } // check whether called function method exists if (ownerType.GetFunctionMethod(seqExprFuncMethodCall.Name) == null) { throw new SequenceParserException(seqExprFuncMethodCall, -1, SequenceParserError.UnknownProcedure); } CheckFunctionCallBase(seqExprFuncMethodCall, ownerType); }
protected override void VisitSequenceExpression(SequenceExpression sequenceExpression) { for (int i = 0, n = sequenceExpression.Expressions.Count; i < n; i++) { Visit(sequenceExpression.Expressions[i]); } }
public void DebugRewriteSequenceExpression(SequenceExpression seqExpr) { if (impl.nonDebugNonGuiExitOnError) { ApplyRewriteSequenceExpression(seqExpr, false); return; } bool debugModeActivated; if (!CheckDebuggerAlive()) { if (!SetDebugMode(true)) { return; } debugModeActivated = true; } else { debugModeActivated = false; } ApplyRewriteSequenceExpression(seqExpr, true); if (debugModeActivated && CheckDebuggerAlive()) // enabled debug mode here and didn't loose connection? { if (UserInterface.ShowMsgAskForYesNo("Do you want to leave debug mode?")) { SetDebugMode(false); } } }
public SubruleDebuggingConfigurationRule(SubruleDebuggingEvent sde, string graphElementName, SubruleDebuggingDecision sdd, SequenceExpression ifClause) { this.debuggingEvent = sde; this.nameToMatch = graphElementName; this.decisionOnMatch = sdd; this.ifClause = ifClause; }
public string GetMethodName(MethodExpression method) { return(method switch { AggregateExpression aggregate => this.GetAggregateName(aggregate.Function), SequenceExpression sequence => this.GetSequenceName(sequence), _ => method.Name, });
public SubruleDebuggingConfigurationRule(SubruleDebuggingEvent sde, IAction action, SubruleDebuggingDecision sdd, SequenceExpression ifClause) { this.debuggingEvent = sde; this.actionToMatch = action; this.decisionOnMatch = sdd; this.ifClause = ifClause; }
private void DeleteExpression(Expression expr) { NameExpression name = expr as NameExpression; if (name != null) { var var = Scope.CreateVariable(name, _unit, name.Name); return; } IndexExpression index = expr as IndexExpression; if (index != null) { var values = _eval.Evaluate(index.Target); var indexValues = _eval.Evaluate(index.Index); foreach (var value in values) { value.DeleteIndex(index, _unit, indexValues); } return; } MemberExpression member = expr as MemberExpression; if (member != null) { if (!string.IsNullOrEmpty(member.Name)) { var values = _eval.Evaluate(member.Target); foreach (var value in values) { value.DeleteMember(member, _unit, member.Name); } } return; } ParenthesisExpression paren = expr as ParenthesisExpression; if (paren != null) { DeleteExpression(paren.Expression); return; } SequenceExpression seq = expr as SequenceExpression; if (seq != null) { foreach (var item in seq.Items) { DeleteExpression(item); } return; } }
public object EvaluateGraphRewriteSequenceExpression(SequenceExpression sequenceExpression) { PerformanceInfo.Start(); object res = sequenceExpression.Evaluate(this); PerformanceInfo.Stop(); return(res); }
protected AssignmentTargetVisited(AssignmentTargetVisited that, Dictionary <SequenceVariable, SequenceVariable> originalToCopy, IGraphProcessingEnvironment procEnv) : base(that) { GraphElementVar = that.GraphElementVar.Copy(originalToCopy, procEnv); if (VisitedFlagExpression != null) { VisitedFlagExpression = that.VisitedFlagExpression.CopyExpression(originalToCopy, procEnv); } }
private string GetSequenceName(SequenceExpression sequence) { if (sequence.Method != SequenceMethod.Current) { throw new DataException($"The MySQL driver does not support the '{sequence.Method.ToString()}' sequence function."); } return("LAST_INSERT_ID"); }
public SubruleDebuggingConfigurationRule(SubruleDebuggingEvent sde, GrGenType graphElementType, bool only, SubruleDebuggingDecision sdd, SequenceExpression ifClause) { this.debuggingEvent = sde; this.typeToMatch = graphElementType; this.onlyThisType = only; this.decisionOnMatch = sdd; this.ifClause = ifClause; }
private static Expression Sequence(INode node) { if (node.Count > 1) { var expressions = node.Children.Select(Expression); return(SequenceExpression.From(node, expressions)); } return(Expression(node[0])); }
protected override void VisitSequenceExpression(SequenceExpression expression) { var start = parsers.Count; base.VisitSequenceExpression(expression); var parser = new Sequence(Pop(start)); Push(parser); }
/// <summary> /// Instantiates a new FilterCall object for an auto-supplied filter (with sequence expression parameter) /// </summary> public FilterCall(String package, String name, SequenceExpression argument, String packageContext) { PrePackage = package; Name = name; IsAutoSupplied = true; ArgumentExpressions = new SequenceExpression[1]; ArgumentExpressions[0] = argument; Arguments = new object[1]; Arguments[0] = null; PrePackageContext = packageContext; }
protected static void CopyArgumentExpressionsAndArguments(Dictionary <SequenceVariable, SequenceVariable> originalToCopy, IGraphProcessingEnvironment procEnv, SequenceExpression[] sourceArgumentExpressions, out SequenceExpression[] targetArgumentExpressions, out object[] targetArguments) { targetArgumentExpressions = new SequenceExpression[sourceArgumentExpressions.Length]; for (int i = 0; i < sourceArgumentExpressions.Length; ++i) { targetArgumentExpressions[i] = sourceArgumentExpressions[i].CopyExpression(originalToCopy, procEnv); } targetArguments = new object[targetArgumentExpressions.Length]; }
public JsValue EvaluateSequenceExpression(SequenceExpression sequenceExpression) { var result = Undefined.Instance; foreach (var expression in sequenceExpression.Expressions) { result = _engine.GetValue(_engine.EvaluateExpression(expression)); } return(result); }
private UstSpecific.CommaExpression VisitSequenceExpression(SequenceExpression sequenceExpression) { var exprs = new Collections.List <UstExprs.Expression>(sequenceExpression.Expressions.Count); foreach (Expression expr in sequenceExpression.Expressions) { exprs.Add(VisitExpression(expr)); } return(new UstSpecific.CommaExpression(exprs, GetTextSpan(sequenceExpression))); }
protected override void WalkSequenceExpression(SequenceExpression sequenceExpression) { foreach (var expression in sequenceExpression.Sequence) { this.WalkExpression(expression); if (!this.zeroWidth[expression]) { break; } } }
public JsValue EvaluateSequenceExpression(SequenceExpression sequenceExpression) { var result = Undefined.Instance; var expressions = sequenceExpression.Expressions; for (int i = 0, len = expressions.Count; i < len; i++) { result = _engine.GetValue(_engine.EvaluateExpression(expressions[i])); } return(result); }
private void DeleteExpression(Expression expr) { NameExpression name = expr as NameExpression; if (name != null) { var variable = _eval.LookupVariableByName(name.Name, expr); if (variable != null) { variable.AddReference(name, _unit); } } IndexExpression index = expr as IndexExpression; if (index != null) { var values = _eval.Evaluate(index.Target); var indexValues = _eval.Evaluate(index.Index); foreach (var value in values) { value.DeleteIndex(index, _unit, indexValues); } } MemberExpression member = expr as MemberExpression; if (member != null) { var values = _eval.Evaluate(member.Target); foreach (var value in values) { value.DeleteMember(member, _unit, member.Name); } } ParenthesisExpression paren = expr as ParenthesisExpression; if (paren != null) { DeleteExpression(paren.Expression); } SequenceExpression seq = expr as SequenceExpression; if (seq != null) { foreach (var item in seq.Items) { DeleteExpression(item); } } }
private Expression Sequence(INode node) { Debug.Assert(node.Name == "sequence"); if (node.Count > 1) { var prefixes = node.Children.Select(Prefix); return(SequenceExpression.From(node, prefixes)); } return(Prefix(node[0])); }
public SequenceExpression ParseSequenceExpression(String seqExprStr) { Dictionary <String, String> predefinedVariables = new Dictionary <string, string>(); SequenceParserEnvironmentInterpreted parserEnv = new SequenceParserEnvironmentInterpreted(curActions); List <string> warnings = new List <string>(); SequenceExpression seqExpr = SequenceParser.ParseSequenceExpression(seqExprStr, predefinedVariables, parserEnv, warnings); foreach (string warning in warnings) { System.Console.Error.WriteLine(warning); } return(seqExpr); }
public Expression Parse(Parser parser, Token token, out bool trailingSemicolon) { string name; List<string> arguments; string otherArgs; bool isOperator; ScopeExpression body; FunctionParselet.ParseFunction(parser, token, true, out trailingSemicolon, out name, out arguments, out otherArgs, out isOperator, out body); var sequence = new SequenceExpression(token, name, arguments, otherArgs, isOperator, body); return isOperator ? FunctionParselet.MakeOperator(name, sequence) : sequence; }
public virtual Expression Visit(SequenceExpression expression) { return(new SequenceExpression( expression.Token, expression.Name, expression.Arguments.ToList(), expression.OtherArguments, (ScopeExpression)expression.Block.Accept(this), expression.DebugName) { EndToken = expression.EndToken }); }
public void Sequence_ToString_Returns_list_of_method_names() { const BindingFlags flags = BindingFlags.Public | BindingFlags.Instance; var methods = typeof(TerminalExpressionTests).GetMethods(flags); var method = methods.First(m => m.ReturnType == typeof(void)); var tree = new[] { new Chromosome { Node = new TerminalExpression(method) }, new Chromosome { Node = new TerminalExpression(method) } }; var sequence = new SequenceExpression(tree); var output = sequence.ToString(); var expected = string.Format("[{1}* {0}(){1}* {0}(){1}]", method.Name, Environment.NewLine); Assert.AreEqual(expected, output); }
protected void CheckEdgeTypeIsKnown(SequenceCheckingEnvironment env, SequenceExpression typeExpr, String whichArgument) { if (typeExpr == null || typeExpr.Type(env) == "") { return; } string typeString = GetTypeString(env, typeExpr); if (TypesHelper.GetEdgeType(typeString, env.Model) == null && typeString != null) { throw new SequenceParserException(Symbol + whichArgument, "edge type or string denoting edge type", typeString); } }
public FilterCallWithLambdaExpression(String packagePrefixedName, SequenceVariable initArrayAccess, SequenceExpression initExpression, SequenceVariable arrayAccess, SequenceVariable previousAccumulationAccess, SequenceVariable index, SequenceVariable element, SequenceExpression lambdaExpression) : base(packagePrefixedName) { this.initArrayAccess = initArrayAccess; this.initExpression = initExpression; this.arrayAccess = arrayAccess; this.previousAccumulationAccess = previousAccumulationAccess; this.index = index; this.element = element; this.lambdaExpression = lambdaExpression; }
public void VisitSequence(SequenceExpression seqExpr) { seqExpr.Items.AcceptWalker(this); }
void RValueList(out SequenceExpression seq) { Expression tmp; var exprs = new List<Expression>(); CondExpr(out tmp); exprs.Add(tmp); while (la.kind == 12) { Get(); CondExpr(out tmp); exprs.Add(tmp); } seq = Expression.MakeSequenceExpression(exprs); }
void LValueList(out SequenceExpression lhs) { var lvalues = new List<Expression>(); Expression tmp; LhsPrimary(out tmp); lvalues.Add(tmp); while (WeakSeparator(12,3,14) ) { LhsPrimary(out tmp); lvalues.Add(tmp); } lhs = Expression.MakeSequenceExpression(lvalues); }
public override object Visit(SequenceExpression that, object value = null) { /** \note A sequence (list or array initializer) \b can include class objects by using the \c new keyword. */ foreach (Expression expression in that.Values) expression.Visit(this); return null; }
private Expression DoSequence(List<Result> results) { Expression value = null; if (results.Count == 1) value = results[0].Value; else if (results.Count > 1) value = new SequenceExpression((from r in results where r.Value != null select r.Value).ToArray()); return value; }
void PrintExpression(SequenceExpression e, int d) { SayLn("SequenceExpression("); PrintExpressionList(e.Exps, d + 1); Say(")"); }
public virtual object Visit(SequenceExpression that, object value) { throw new System.NotImplementedException(); }
public void EqualsObj_xEqualsNull_returnsFalse() { var x = new SequenceExpression(new Chromosome[2]); Assert.IsFalse(x.Equals((object)null)); }
public void EqualsObj_xEqualsy_returns_yEqualsx() { var x = new SequenceExpression(new Chromosome[2]); var y = new SequenceExpression(new Chromosome[2]); Assert.IsTrue(x.Equals((object)y) == y.Equals((object)x)); }
public override object Visit(SequenceExpression that, object value) { _writer.Write('['); foreach (Expression below in that.Values) { if (below != that.Values[0]) _writer.Write(", "); below.Visit(this); } _writer.Write(']'); return null; }
public void VisitSequence(SequenceExpression seqExpr) { throw new NotImplementedException(); }
public override object Visit(SequenceExpression that, object value = null) { PrintPrologue(that); PrintSequence("Values", that.Values); PrintNodeId("Type", that.Type); PrintEpilogue(that); foreach (Expression expression in that.Values) expression.Visit(this); that.Type.Visit(this); return null; }