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;
}
