public static string Balance(SequenceExpressionType op, string operand, IGraphModel model)
{
string result;
switch (op)
{
case SequenceExpressionType.UnaryMinus:
result = BalanceArithmetic(operand, model);
return(result);
default:
return("");
}
}
/// <summary>
/// Initializes a new SequenceExpression object with the given sequence expression type.
/// </summary>
/// <param name="seqExprType">The sequence expression type.</param>
public SequenceExpression(SequenceExpressionType seqExprType)
: base(SequenceComputationType.Expression)
{
SequenceExpressionType = seqExprType;
id = idSource;
++idSource;
}
public SequenceExpressionFunctionCall(SequenceExpressionType seqExprType, FunctionInvocationParameterBindings paramBindings)
: base(seqExprType)
{
ParamBindings = paramBindings;
}
public SequenceExpressionIsReachable(SequenceExpression sourceNode, SequenceExpression endElement, SequenceExpression edgeType, SequenceExpression oppositeNodeType, SequenceExpressionType type)
: base(type)
{
SourceNode = sourceNode;
EndElement = endElement;
EdgeType = edgeType;
OppositeNodeType = oppositeNodeType;
if(!(type == SequenceExpressionType.IsReachableNodes || type == SequenceExpressionType.IsReachableNodesViaIncoming || type == SequenceExpressionType.IsReachableNodesViaOutgoing)
&& !(type == SequenceExpressionType.IsReachableEdges || type == SequenceExpressionType.IsReachableEdgesViaIncoming || type == SequenceExpressionType.IsReachableEdgesViaOutgoing))
throw new Exception("Internal failure, reachable with wrong type");
}
public SequenceExpressionIsAdjacentIncident(SequenceExpression sourceNode, SequenceExpression endElement, SequenceExpression edgeType, SequenceExpression oppositeNodeType, SequenceExpressionType type)
: base(type)
{
SourceNode = sourceNode;
EndElement = endElement;
EdgeType = edgeType;
OppositeNodeType = oppositeNodeType;
if(!(type == SequenceExpressionType.IsAdjacentNodes || type == SequenceExpressionType.IsAdjacentNodesViaIncoming || type == SequenceExpressionType.IsAdjacentNodesViaOutgoing)
&& !(type == SequenceExpressionType.IsIncidentEdges || type == SequenceExpressionType.IsIncomingEdges || type == SequenceExpressionType.IsOutgoingEdges))
throw new Exception("Internal failure, isAdjacent/isIncident with wrong type");
}
public SequenceExpressionCountBoundedReachable(SequenceExpression sourceNode, SequenceExpression depth, SequenceExpression edgeType, SequenceExpression oppositeNodeType, SequenceExpressionType type)
: base(type)
{
SourceNode = sourceNode;
Depth = depth;
EdgeType = edgeType;
OppositeNodeType = oppositeNodeType;
if(!(type == SequenceExpressionType.CountBoundedReachableNodes || type == SequenceExpressionType.CountBoundedReachableNodesViaIncoming || type == SequenceExpressionType.CountBoundedReachableNodesViaOutgoing)
&& !(type == SequenceExpressionType.CountBoundedReachableEdges || type == SequenceExpressionType.CountBoundedReachableEdgesViaIncoming || type == SequenceExpressionType.CountBoundedReachableEdgesViaOutgoing))
throw new Exception("Internal failure, count bounded reachable with wrong type");
}
public SequenceExpressionBoundedReachableWithRemainingDepth(SequenceExpression sourceNode, SequenceExpression depth, SequenceExpression edgeType, SequenceExpression oppositeNodeType, SequenceExpressionType type)
: base(type)
{
SourceNode = sourceNode;
Depth = depth;
EdgeType = edgeType;
OppositeNodeType = oppositeNodeType;
if(!(type == SequenceExpressionType.BoundedReachableNodesWithRemainingDepth || type == SequenceExpressionType.BoundedReachableNodesWithRemainingDepthViaIncoming || type == SequenceExpressionType.BoundedReachableNodesWithRemainingDepthViaOutgoing))
throw new Exception("Internal failure, bounded reachable with remaining depth with wrong type");
}
public SequenceExpressionCountAdjacentIncident(SequenceExpression sourceNode, SequenceExpression edgeType, SequenceExpression oppositeNodeType, SequenceExpressionType type)
: base(type)
{
SourceNode = sourceNode;
EdgeType = edgeType;
OppositeNodeType = oppositeNodeType;
if(!(type == SequenceExpressionType.CountAdjacentNodes || type == SequenceExpressionType.CountAdjacentNodesViaIncoming || type == SequenceExpressionType.CountAdjacentNodesViaOutgoing)
&& !(type == SequenceExpressionType.CountIncidentEdges || type == SequenceExpressionType.CountIncomingEdges || type == SequenceExpressionType.CountOutgoingEdges))
throw new Exception("Internal failure, count adjacent/incident with wrong type");
}
public string BalancedTypeStatic; // the type of the operator, i.e. the common type of both operands for the operation
/// <summary>
/// Initializes a new SequenceBinaryExpression object with the given sequence expression type.
/// </summary>
/// <param name="seqExprType">The sequence expression type.</param>
/// <param name="left">The left sequence expression.</param>
/// <param name="right">The right sequence expression.</param>
public SequenceBinaryExpression(SequenceExpressionType seqExprType,
SequenceExpression left, SequenceExpression right)
: base(seqExprType)
{
SequenceExpressionType = seqExprType;
this.Left = left;
this.Right = right;
}
public SequenceExpressionContainer(SequenceExpressionType type, SequenceExpression containerExpr)
: base(type)
{
ContainerExpr = containerExpr;
}
public SequenceExpressionContainerConstructor(SequenceExpressionType seqExprType, String valueType, SequenceExpression[] containerItems)
: base(seqExprType)
{
ValueType = valueType;
ContainerItems = containerItems;
}
internal StatementsSeqExpr(
Token identifer,
SequenceExpressionType type)
: this()
{
identifier = identifer;
sequenceType = type;
}
/// <summary>
/// Returns the types to which the operands must be casted to,
/// for the types of the left and right operands and the operator given.
/// Used for type checking and casting at compile time.
/// Returns "" if the type can only be determined at runtime.
/// Returns "-" in case of a type error.
/// </summary>
public static string Balance(SequenceExpressionType op, string left, string right, IGraphModel model)
{
string result;
switch(op)
{
case SequenceExpressionType.Equal:
case SequenceExpressionType.NotEqual:
result = BalanceArithmetic(left, right, model);
if(result == "") return "";
if(result == "-")
{
result = BalanceString(left, right, model);
if(result == "") return "";
if(result == "-")
{
result = BalanceGraphElement(left, right, model);
if(result == "") return "";
if(result == "-")
{
result = BalanceExternalType(left, right, model);
if(result == "") return "";
if(result == "-")
{
if(left == right) return left;
else return "-";
}
}
}
}
return result;
case SequenceExpressionType.Lower:
case SequenceExpressionType.LowerEqual:
case SequenceExpressionType.Greater:
case SequenceExpressionType.GreaterEqual:
result = BalanceArithmetic(left, right, model);
if(result == "-")
{
if(left == right && (left.StartsWith("set<") || left.StartsWith("map<")
|| left.StartsWith("array<") || left.StartsWith("deque<")))
{
return left;
}
result = BalanceExternalType(left, right, model);
return result;
}
return result;
case SequenceExpressionType.StructuralEqual:
return "graph";
case SequenceExpressionType.Plus:
result = BalanceArithmetic(left, right, model);
if(result == "") return "";
if(result == "-")
{
result = BalanceString(left, right, model);
if(result == "") return "";
if(result == "-")
{
if(left == right && (left.StartsWith("array<") || left.StartsWith("deque<")))
return left;
else return "-";
}
}
return result;
case SequenceExpressionType.Minus:
case SequenceExpressionType.Mul:
case SequenceExpressionType.Div:
case SequenceExpressionType.Mod:
result = BalanceArithmetic(left, right, model);
return result;
default:
return "";
}
}
// implicit casts supported by GrGen:
// enum -> (integer) number
// integer number -> larger integer number (note that there are no operators working on byte and short)
// floating point number -> larger floating point number
// integer number -> floating point number
// everything -> string (for convenient emitting)
// explicit casts supported by GrGen:
// integer number -> smaller integer number
// floating point number -> smaller floating point number
// floating point number -> integer number
// everything -> object
/// <summary>
/// Returns the types to which the operands must be casted to,
/// for the types of the left and right operands and the operator given.
/// Used for type checking and casting at compile time.
/// Returns "" if the type can only be determined at runtime.
/// Returns "-" in case of a type error.
/// </summary>
public static string Balance(SequenceExpressionType op, string left, string right, IGraphModel model)
{
string result;
switch (op)
{
case SequenceExpressionType.Equal:
case SequenceExpressionType.NotEqual:
result = BalanceArithmetic(left, right, model);
if (result == "")
{
return("");
}
if (result == "-")
{
result = BalanceString(left, right, model);
if (result == "")
{
return("");
}
if (result == "-")
{
result = BalanceGraphElement(left, right, model);
if (result == "")
{
return("");
}
if (result == "-")
{
result = BalanceExternalType(left, right, model);
if (result == "")
{
return("");
}
if (result == "-")
{
if (left == right)
{
return(left);
}
else
{
return("-");
}
}
}
}
}
return(result);
case SequenceExpressionType.Lower:
case SequenceExpressionType.LowerEqual:
case SequenceExpressionType.Greater:
case SequenceExpressionType.GreaterEqual:
result = BalanceArithmetic(left, right, model);
if (result == "-")
{
if (left == right && (left.StartsWith("set<") || left.StartsWith("map<") ||
left.StartsWith("array<") || left.StartsWith("deque<")))
{
return(left);
}
result = BalanceExternalType(left, right, model);
return(result);
}
return(result);
case SequenceExpressionType.StructuralEqual:
return("graph");
case SequenceExpressionType.Plus:
result = BalanceArithmetic(left, right, model);
if (result == "")
{
return("");
}
if (result == "-")
{
result = BalanceString(left, right, model);
if (result == "")
{
return("");
}
if (result == "-")
{
if (left == right && (left.StartsWith("array<") || left.StartsWith("deque<")))
{
return(left);
}
else
{
return("-");
}
}
}
return(result);
case SequenceExpressionType.Minus:
case SequenceExpressionType.Mul:
case SequenceExpressionType.Div:
case SequenceExpressionType.Mod:
result = BalanceArithmetic(left, right, model);
return(result);
case SequenceExpressionType.Except:
if (left == "" || right == "")
{
return("");
}
if (left == right && left.StartsWith("set<"))
{
return(left);
}
if (left == right && left.StartsWith("map<"))
{
return(left);
}
if (left.StartsWith("map<") && right.StartsWith("set<") && TypesHelper.ExtractSrc(left) == TypesHelper.ExtractSrc(right))
{
return(left);
}
return("-");
case SequenceExpressionType.StrictAnd:
case SequenceExpressionType.StrictOr:
if (left == "" || right == "")
{
return("");
}
if (left == right && left == "boolean")
{
return(left);
}
if (left == right && left.StartsWith("set<"))
{
return(left);
}
if (left == right && left.StartsWith("map<"))
{
return(left);
}
return("-");
default:
return("");
}
}
