//-----------------------------------------------
// Constructor
//-----------------------------------------------
/// <summary>
/// Construct a new node
/// </summary>
public QilName(QilNodeType nodeType, string local, string uri, string prefix) : base(nodeType, null)
{
LocalName = local;
NamespaceUri = uri;
Prefix = prefix;
Value = this;
}
//-----------------------------------------------
// Constructor
//-----------------------------------------------
/// <summary>
/// Construct a node
/// </summary>
public QilFunction(QilNodeType nodeType, QilNode arguments, QilNode definition, QilNode sideEffects, XmlQueryType resultType)
: base(nodeType) {
this.arguments = arguments;
this.definition = definition;
this.sideEffects = sideEffects;
this.xmlType = resultType;
}
//-----------------------------------------------
// Constructor
//-----------------------------------------------
/// <summary>
/// Construct a new node
/// </summary>
public QilName(QilNodeType nodeType, string local, string uri, string prefix) : base(nodeType, null)
{
LocalName = local;
NamespaceUri = uri;
Prefix = prefix;
Value = this;
}
public QilFunction(QilNodeType nodeType, QilNode arguments, QilNode definition, QilNode sideEffects, XmlQueryType resultType)
: base(nodeType)
{
_arguments = arguments;
_definition = definition;
_sideEffects = sideEffects;
this.xmlType = resultType;
}
/// <summary>
/// Default to worst possible construction information.
/// </summary>
private XmlILConstructInfo(QilNodeType nodeType)
{
_nodeType = nodeType;
_xstatesInitial = _xstatesFinal = PossibleXmlStates.Any;
_xstatesBeginLoop = _xstatesEndLoop = PossibleXmlStates.None;
_isNmspInScope = false;
_mightHaveNmsp = true;
_mightHaveAttrs = true;
_mightHaveDupAttrs = true;
_mightHaveNmspAfterAttrs = true;
_constrMeth = XmlILConstructMethod.Iterator;
_parentInfo = null;
}
/// <summary>
/// Construct QIL from a rooted graph of QilNodes with a specific factory.
/// </summary>
public QilExpression(QilNodeType nodeType, QilNode root, QilFactory factory) : base(nodeType) {
this.factory = factory;
this.isDebug = factory.False();
XmlWriterSettings settings = new XmlWriterSettings();
settings.ConformanceLevel = ConformanceLevel.Auto;
this.defWSet = factory.LiteralObject(settings);
this.wsRules = factory.LiteralObject(new List<WhitespaceRule>());
this.funList = factory.FunctionList();
this.gloVars = factory.GlobalVariableList();
this.gloParams = factory.GlobalParameterList();
this.rootNod = root;
}
/// <summary>
/// Construct QIL from a rooted graph of QilNodes with a specific factory.
/// </summary>
public QilExpression(QilNodeType nodeType, QilNode root, QilFactory factory) : base(nodeType)
{
_factory = factory;
_isDebug = factory.False();
XmlWriterSettings settings = new XmlWriterSettings();
settings.ConformanceLevel = ConformanceLevel.Auto;
_defWSet = factory.LiteralObject(settings);
_wsRules = factory.LiteralObject(new List<WhitespaceRule>());
_gloVars = factory.GlobalVariableList();
_gloParams = factory.GlobalParameterList();
_earlBnd = factory.LiteralObject(new List<EarlyBoundInfo>());
_funList = factory.FunctionList();
_rootNod = root;
}
/// <summary>
/// Construct QIL from a rooted graph of QilNodes with a specific factory.
/// </summary>
public QilExpression(QilNodeType nodeType, QilNode root, QilFactory factory) : base(nodeType)
{
this.factory = factory;
this.isDebug = factory.False();
XmlWriterSettings settings = new XmlWriterSettings();
settings.ConformanceLevel = ConformanceLevel.Auto;
this.defWSet = factory.LiteralObject(settings);
this.wsRules = factory.LiteralObject(new List <WhitespaceRule>());
this.funList = factory.FunctionList();
this.gloVars = factory.GlobalVariableList();
this.gloParams = factory.GlobalParameterList();
this.rootNod = root;
}
public QilNode InvokeEqualityOperator(QilNodeType op, QilNode left, QilNode right)
{
Debug.Assert(op == QilNodeType.Eq || op == QilNodeType.Ne);
left = TypeAssert(left, T.ItemS);
right = TypeAssert(right, T.ItemS);
double opCode = op switch
{
QilNodeType.Eq => (double)XsltLibrary.ComparisonOperator.Eq,
_ => (double)XsltLibrary.ComparisonOperator.Ne,
};
return(XsltInvokeEarlyBound(QName("EqualityOperator"),
XsltMethods.EqualityOperator, T.BooleanX, new QilNode[] { Double(opCode), left, right }
));
}
/// <summary>
/// Construct QIL from a rooted graph of QilNodes with a specific factory.
/// </summary>
public QilExpression(QilNodeType nodeType, QilNode root, QilFactory factory) : base(nodeType)
{
_factory = factory;
_isDebug = factory.False();
XmlWriterSettings settings = new XmlWriterSettings();
settings.ConformanceLevel = ConformanceLevel.Auto;
_defWSet = factory.LiteralObject(settings);
_wsRules = factory.LiteralObject(new List <WhitespaceRule>());
_gloVars = factory.GlobalVariableList();
_gloParams = factory.GlobalParameterList();
_earlBnd = factory.LiteralObject(new List <EarlyBoundInfo>());
_funList = factory.FunctionList();
_rootNod = root;
}
public QilNode InvokeEqualityOperator(QilNodeType op, QilNode left, QilNode right)
{
Debug.Assert(op == QilNodeType.Eq || op == QilNodeType.Ne);
double opCode;
left = TypeAssert(left, T.ItemS);
right = TypeAssert(right, T.ItemS);
switch (op)
{
case QilNodeType.Eq: opCode = (double)XsltLibrary.ComparisonOperator.Eq; break;
default: opCode = (double)XsltLibrary.ComparisonOperator.Ne; break;
}
return(XsltInvokeEarlyBound(QName("EqualityOperator"),
XsltMethods.EqualityOperator, T.BooleanX, new QilNode[] { Double(opCode), left, right }
));
}
public QilNode InvokeRelationalOperator(QilNodeType op, QilNode left, QilNode right)
{
Debug.Assert(op == QilNodeType.Lt || op == QilNodeType.Le || op == QilNodeType.Gt || op == QilNodeType.Ge);
left = TypeAssert(left, T.ItemS);
right = TypeAssert(right, T.ItemS);
double opCode = op switch
{
QilNodeType.Lt => (double)XsltLibrary.ComparisonOperator.Lt,
QilNodeType.Le => (double)XsltLibrary.ComparisonOperator.Le,
QilNodeType.Gt => (double)XsltLibrary.ComparisonOperator.Gt,
_ => (double)XsltLibrary.ComparisonOperator.Ge,
};
return(XsltInvokeEarlyBound(QName("RelationalOperator"),
XsltMethods.RelationalOperator, T.BooleanX, new QilNode[] { Double(opCode), left, right }
));
}
public QilNode InvokeRelationalOperator(QilNodeType op, QilNode left, QilNode right)
{
Debug.Assert(op == QilNodeType.Lt || op == QilNodeType.Le || op == QilNodeType.Gt || op == QilNodeType.Ge);
double opCode;
left = TypeAssert(left, T.ItemS);
right = TypeAssert(right, T.ItemS);
switch (op)
{
case QilNodeType.Lt: opCode = (double)XsltLibrary.ComparisonOperator.Lt; break;
case QilNodeType.Le: opCode = (double)XsltLibrary.ComparisonOperator.Le; break;
case QilNodeType.Gt: opCode = (double)XsltLibrary.ComparisonOperator.Gt; break;
default: opCode = (double)XsltLibrary.ComparisonOperator.Ge; break;
}
return(XsltInvokeEarlyBound(QName("RelationalOperator"),
XsltMethods.RelationalOperator, T.BooleanX, new QilNode[] { Double(opCode), left, right }
));
}
//-----------------------------------------------
// Constructor
//-----------------------------------------------
/// <summary>
/// Construct a new node
/// </summary>
public QilChoice(QilNodeType nodeType, QilNode expression, QilNode branches) : base(nodeType, expression, branches) {
}
//-----------------------------------------------
// Constructor
//-----------------------------------------------
/// <summary>
/// Construct a new node
/// </summary>
public QilStrConcat(QilNodeType nodeType, QilNode delimiter, QilNode values) : base(nodeType, delimiter, values) {
}
//-----------------------------------------------
// Constructor
//-----------------------------------------------
/// <summary>
/// Construct a reference
/// </summary>
public QilReference(QilNodeType nodeType) : base(nodeType) {
}
//-----------------------------------------------
// Constructor
//-----------------------------------------------
/// <summary>
/// Construct a new node
/// </summary>
public QilBinary(QilNodeType nodeType, QilNode left, QilNode right) : base(nodeType)
{
_left = left;
_right = right;
}
//-----------------------------------------------
// Constructor
//-----------------------------------------------
/// <summary>
/// Construct a new node
/// </summary>
public QilTargetType(QilNodeType nodeType, QilNode expr, QilNode targetType) : base(nodeType, expr, targetType)
{
}
//-----------------------------------------------
// Constructor
//-----------------------------------------------
/// <summary>
/// Construct a new node
/// </summary>
public QilStrConcat(QilNodeType nodeType, QilNode delimiter, QilNode values) : base(nodeType, delimiter, values)
{
}
public QilUnary(QilNodeType nodeType, QilNode child) : base(nodeType)
{
_child = child;
}
//-----------------------------------------------
// Constructors
//-----------------------------------------------
/// <summary>
/// Construct QIL from a rooted graph of QilNodes with a new factory.
/// </summary>
public QilExpression(QilNodeType nodeType, QilNode root) : this(nodeType, root, new QilFactory()) {
}
/// <summary>
/// Return true if "nd" matches the Step pattern and the StepType argument is equal to "stepType".
/// </summary>
private bool IsStepPattern(QilNode nd, QilNodeType stepType) {
return IsStepPattern(OptimizerPatterns.Read(nd), stepType);
}
//-----------------------------------------------
// Constructor
//-----------------------------------------------
/// <summary>
/// Construct a new node
/// </summary>
public QilTernary(QilNodeType nodeType, QilNode left, QilNode center, QilNode right) : base(nodeType) {
this.left = left;
this.center = center;
this.right = right;
}
//-----------------------------------------------
// Constructor
//-----------------------------------------------
/// <summary>
/// Construct a new node
/// </summary>
public QilDataSource(QilNodeType nodeType, QilNode name, QilNode baseUri) : base(nodeType, name, baseUri) {
}
//-----------------------------------------------
// Constructor
//-----------------------------------------------
/// <summary>
/// Construct a new node
/// </summary>
public QilTernary(QilNodeType nodeType, QilNode left, QilNode center, QilNode right) : base(nodeType)
{
_left = left;
_center = center;
_right = right;
}
//-----------------------------------------------
// Constructor
//-----------------------------------------------
/// <summary>
/// Construct an iterator
/// </summary>
public QilIterator(QilNodeType nodeType, QilNode binding) : base(nodeType)
{
Binding = binding;
}
//-----------------------------------------------
// Constructor
//-----------------------------------------------
/// <summary>
/// Construct a new node
/// </summary>
public QilInvoke(QilNodeType nodeType, QilNode function, QilNode arguments) : base(nodeType, function, arguments)
{
}
//-----------------------------------------------
// Constructor
//-----------------------------------------------
/// <summary>
/// Construct a new node
/// </summary>
public QilDataSource(QilNodeType nodeType, QilNode name, QilNode baseUri) : base(nodeType, name, baseUri)
{
}
public QilNode InvokeRelationalOperator(QilNodeType op, QilNode left, QilNode right) {
Debug.Assert(op == QilNodeType.Lt || op == QilNodeType.Le || op == QilNodeType.Gt || op == QilNodeType.Ge);
double opCode;
left = TypeAssert(left, T.ItemS);
right = TypeAssert(right, T.ItemS);
switch (op) {
case QilNodeType.Lt: opCode = (double)XsltLibrary.ComparisonOperator.Lt; break;
case QilNodeType.Le: opCode = (double)XsltLibrary.ComparisonOperator.Le; break;
case QilNodeType.Gt: opCode = (double)XsltLibrary.ComparisonOperator.Gt; break;
default: opCode = (double)XsltLibrary.ComparisonOperator.Ge; break;
}
return XsltInvokeEarlyBound(QName("RelationalOperator"),
XsltMethods.RelationalOperator, T.BooleanX, new QilNode[] { Double(opCode), left, right }
);
}
//-----------------------------------------------
// Constructor
//-----------------------------------------------
/// <summary>
/// Construct a new node
/// </summary>
public QilBinary(QilNodeType nodeType, QilNode left, QilNode right) : base(nodeType)
{
this.left = left;
this.right = right;
}
/// <summary>
/// Return true if arithmetic operation "opType" can be computed over two literal operands without causing
/// an overflow or divide by zero exception.
/// </summary>
private bool CanFoldArithmetic(QilNodeType opType, QilLiteral left, QilLiteral right) {
return (FoldArithmetic(opType, left, right) is QilLiteral);
}
//-----------------------------------------------
// Constructor
//-----------------------------------------------
/// <summary>
/// Construct a new node
/// </summary>
public QilInvokeLateBound(QilNodeType nodeType, QilNode name, QilNode arguments) : base(nodeType, name, arguments) {
}
//-----------------------------------------------
// Constructor
//-----------------------------------------------
/// <summary>
/// Construct a new node
/// </summary>
public QilBinary(QilNodeType nodeType, QilNode left, QilNode right) : base(nodeType) {
this.left = left;
this.right = right;
}
//-----------------------------------------------
// Constructor
//-----------------------------------------------
/// <summary>
/// Construct a new node
/// </summary>
public QilTernary(QilNodeType nodeType, QilNode left, QilNode center, QilNode right) : base(nodeType)
{
this.left = left;
this.center = center;
this.right = right;
}
/// <summary>
/// Compute the arithmetic operation "opType" over two literal operands and return the result as a QilLiteral.
/// Arithmetic operations are always checked; in the case of an overflow or divide by zero exception, return
/// the unfolded result.
/// </summary>
private QilNode FoldArithmetic(QilNodeType opType, QilLiteral left, QilLiteral right) {
Debug.Assert(left.NodeType == right.NodeType);
// Catch any overflow or divide by zero exceptions
try {
checked {
switch (left.NodeType) {
case QilNodeType.LiteralInt32: {
int intLeft = left;
int intRight = right;
switch (opType) {
case QilNodeType.Add: return f.LiteralInt32(intLeft + intRight);
case QilNodeType.Subtract: return f.LiteralInt32(intLeft - intRight);
case QilNodeType.Multiply: return f.LiteralInt32(intLeft * intRight);
case QilNodeType.Divide: return f.LiteralInt32(intLeft / intRight);
case QilNodeType.Modulo: return f.LiteralInt32(intLeft % intRight);
}
break;
}
case QilNodeType.LiteralInt64: {
long lngLeft = left;
long lngRight = right;
switch (opType) {
case QilNodeType.Add: return f.LiteralInt64(lngLeft + lngRight);
case QilNodeType.Subtract: return f.LiteralInt64(lngLeft - lngRight);
case QilNodeType.Multiply: return f.LiteralInt64(lngLeft * lngRight);
case QilNodeType.Divide: return f.LiteralInt64(lngLeft / lngRight);
case QilNodeType.Modulo: return f.LiteralInt64(lngLeft % lngRight);
}
break;
}
case QilNodeType.LiteralDecimal: {
decimal lngLeft = left;
decimal lngRight = right;
switch (opType) {
case QilNodeType.Add: return f.LiteralDecimal(lngLeft + lngRight);
case QilNodeType.Subtract: return f.LiteralDecimal(lngLeft - lngRight);
case QilNodeType.Multiply: return f.LiteralDecimal(lngLeft * lngRight);
case QilNodeType.Divide: return f.LiteralDecimal(lngLeft / lngRight);
case QilNodeType.Modulo: return f.LiteralDecimal(lngLeft % lngRight);
}
break;
}
case QilNodeType.LiteralDouble: {
double lngLeft = left;
double lngRight = right;
switch (opType) {
case QilNodeType.Add: return f.LiteralDouble(lngLeft + lngRight);
case QilNodeType.Subtract: return f.LiteralDouble(lngLeft - lngRight);
case QilNodeType.Multiply: return f.LiteralDouble(lngLeft * lngRight);
case QilNodeType.Divide: return f.LiteralDouble(lngLeft / lngRight);
case QilNodeType.Modulo: return f.LiteralDouble(lngLeft % lngRight);
}
break;
}
}
}
}
catch (OverflowException) {
}
catch (DivideByZeroException) {
}
// An error occurred, so don't fold operationo
switch (opType) {
case QilNodeType.Add: return f.Add(left, right);
case QilNodeType.Subtract: return f.Subtract(left, right);
case QilNodeType.Multiply: return f.Multiply(left, right);
case QilNodeType.Divide: return f.Divide(left, right);
case QilNodeType.Modulo: return f.Modulo(left, right);
}
Debug.Assert(false, "Cannot fold this arithmetic operation: " + opType);
return null;
}
public QilList(QilNodeType nodeType) : base(nodeType)
{
_members = new QilNode[4];
this.xmlType = null;
}
//-----------------------------------------------
// Constructor
//-----------------------------------------------
/// <summary>
/// Construct a new node
/// </summary>
public QilLoop(QilNodeType nodeType, QilNode variable, QilNode body) : base(nodeType, variable, body) {
}
private void CheckClassAndNodeType(QilNode node, Type clrTypeClass, QilNodeType nodeType) {
CheckClass(node, clrTypeClass);
Check(node.NodeType == nodeType, node, "Node must have QilNodeType." + nodeType);
}
private void CheckClassAndNodeType(QilNode node, Type clrTypeClass, QilNodeType nodeType)
{
CheckClass(node, clrTypeClass);
Check(node.NodeType == nodeType, node, "Node must have QilNodeType." + nodeType);
}
//-----------------------------------------------
// Constructor
//-----------------------------------------------
/// <summary>
/// Construct a new node
/// </summary>
public QilSortKey(QilNodeType nodeType, QilNode key, QilNode collation) : base(nodeType, key, collation) {
}
//-----------------------------------------------
// Constructor
//-----------------------------------------------
/// <summary>
/// Construct a parameter
/// </summary>
public QilParameter(QilNodeType nodeType, QilNode defaultValue, QilNode name, XmlQueryType xmlType) : base(nodeType, defaultValue)
{
_name = name;
this.xmlType = xmlType;
}
//-----------------------------------------------
// Constructor
//-----------------------------------------------
/// <summary>
/// Construct a new node
/// </summary>
public QilSortKey(QilNodeType nodeType, QilNode key, QilNode collation) : base(nodeType, key, collation)
{
}
//-----------------------------------------------
// Constructor
//-----------------------------------------------
/// <summary>
/// Construct an iterator
/// </summary>
public QilIterator(QilNodeType nodeType, QilNode binding) : base(nodeType)
{
Binding = binding;
}
/// <summary>
/// Return true if "patt" matches the Step pattern and the StepType argument is equal to "stepType".
/// </summary>
private bool IsStepPattern(OptimizerPatterns patt, QilNodeType stepType) {
return patt.MatchesPattern(OptimizerPatternName.Step) && ((QilNode) patt.GetArgument(OptimizerPatternArgument.StepNode)).NodeType == stepType;
}
//-----------------------------------------------
// Constructors
//-----------------------------------------------
/// <summary>
/// Construct QIL from a rooted graph of QilNodes with a new factory.
/// </summary>
public QilExpression(QilNodeType nodeType, QilNode root) : this(nodeType, root, new QilFactory())
{
}
//-----------------------------------------------
// Constructor
//-----------------------------------------------
/// <summary>
/// Construct a new (empty) QilList
/// </summary>
public QilList(QilNodeType nodeType) : base(nodeType) {
this.members = new QilNode[4];
this.xmlType = null;
}
//-----------------------------------------------
// Constructor
//-----------------------------------------------
/// <summary>
/// Construct a new node
/// </summary>
public QilChoice(QilNodeType nodeType, QilNode expression, QilNode branches) : base(nodeType, expression, branches)
{
}
public void CallArithmeticOp(QilNodeType opType, XmlTypeCode code)
{
MethodInfo meth = null;
switch (code)
{
case XmlTypeCode.Int:
case XmlTypeCode.Integer:
case XmlTypeCode.Double:
case XmlTypeCode.Float:
switch (opType)
{
case QilNodeType.Add: Emit(OpCodes.Add); break;
case QilNodeType.Subtract: Emit(OpCodes.Sub); break;
case QilNodeType.Multiply: Emit(OpCodes.Mul); break;
case QilNodeType.Divide: Emit(OpCodes.Div); break;
case QilNodeType.Modulo: Emit(OpCodes.Rem); break;
case QilNodeType.Negate: Emit(OpCodes.Neg); break;
default: Debug.Assert(false, opType + " must be an arithmetic operation."); break;
}
break;
case XmlTypeCode.Decimal:
switch (opType)
{
case QilNodeType.Add: meth = XmlILMethods.DecAdd; break;
case QilNodeType.Subtract: meth = XmlILMethods.DecSub; break;
case QilNodeType.Multiply: meth = XmlILMethods.DecMul; break;
case QilNodeType.Divide: meth = XmlILMethods.DecDiv; break;
case QilNodeType.Modulo: meth = XmlILMethods.DecRem; break;
case QilNodeType.Negate: meth = XmlILMethods.DecNeg; break;
default: Debug.Assert(false, opType + " must be an arithmetic operation."); break;
}
Call(meth);
break;
default:
Debug.Assert(false, "The " + opType + " arithmetic operation cannot be performed on values of type " + code + ".");
break;
}
}
//-----------------------------------------------
// Constructor
//-----------------------------------------------
/// <summary>
/// Construct a new node
/// </summary>
/// <param name="method">QilLiteral containing the Clr MethodInfo for the early bound function</param>
public QilInvokeEarlyBound(QilNodeType nodeType, QilNode name, QilNode method, QilNode arguments, XmlQueryType resultType)
: base(nodeType, name, method, arguments)
{
this.xmlType = resultType;
}
/// <summary>
/// Construct a new node
/// </summary>
public QilNode(QilNodeType nodeType, XmlQueryType xmlType)
{
this.nodeType = nodeType;
this.xmlType = xmlType;
}
public QilNode InvokeEqualityOperator(QilNodeType op, QilNode left, QilNode right) {
Debug.Assert(op == QilNodeType.Eq || op == QilNodeType.Ne);
double opCode;
left = TypeAssert(left, T.ItemS);
right = TypeAssert(right, T.ItemS);
switch (op) {
case QilNodeType.Eq: opCode = (double)XsltLibrary.ComparisonOperator.Eq; break;
default: opCode = (double)XsltLibrary.ComparisonOperator.Ne; break;
}
return XsltInvokeEarlyBound(QName("EqualityOperator"),
XsltMethods.EqualityOperator, T.BooleanX, new QilNode[] { Double(opCode), left, right }
);
}
//-----------------------------------------------
// Constructor
//-----------------------------------------------
/// <summary>
/// Construct a new node
/// </summary>
/// <param name="method">QilLiteral containing the Clr MethodInfo for the early bound function</param>
public QilInvokeEarlyBound(QilNodeType nodeType, QilNode name, QilNode method, QilNode arguments, XmlQueryType resultType)
: base(nodeType, name, method, arguments) {
this.xmlType = resultType;
}
//-----------------------------------------------
// Constructor
//-----------------------------------------------
/// <summary>
/// Construct a reference
/// </summary>
public QilReference(QilNodeType nodeType) : base(nodeType)
{
}
//-----------------------------------------------
// Constructor
//-----------------------------------------------
/// <summary>
/// Construct a new node
/// </summary>
public QilInvokeLateBound(QilNodeType nodeType, QilNode name, QilNode arguments) : base(nodeType, name, arguments)
{
}
//-----------------------------------------------
// Constructor
//-----------------------------------------------
/// <summary>
/// Construct a new node
/// </summary>
public QilUnary(QilNodeType nodeType, QilNode child) : base(nodeType) {
this.child = child;
}
/// <summary>
/// Compute the arithmetic operation "opType" over two literal operands and return the result as a QilLiteral.
/// In the case of an overflow or divide by zero exception, return the unfolded result.
/// </summary>
private QilNode FoldComparison(QilNodeType opType, QilNode left, QilNode right) {
object litLeft, litRight;
int cmp;
Debug.Assert(left.XmlType == right.XmlType, "Comparison is not defined between " + left.XmlType + " and " + right.XmlType);
// Extract objects that represent each literal value
litLeft = ExtractLiteralValue(left);
litRight = ExtractLiteralValue(right);
if (left.NodeType == QilNodeType.LiteralDouble) {
// Equals and CompareTo do not handle NaN correctly
if (Double.IsNaN((double) litLeft) || Double.IsNaN((double) litRight))
return (opType == QilNodeType.Ne) ? f.True() : f.False();
}
if (opType == QilNodeType.Eq)
return litLeft.Equals(litRight) ? f.True() : f.False();
if (opType == QilNodeType.Ne)
return litLeft.Equals(litRight) ? f.False() : f.True();
if (left.NodeType == QilNodeType.LiteralString) {
// CompareTo does not use Ordinal comparison
cmp = string.CompareOrdinal((string) litLeft, (string) litRight);
}
else {
cmp = ((IComparable) litLeft).CompareTo(litRight);
}
switch (opType) {
case QilNodeType.Gt: return cmp > 0 ? f.True() : f.False();
case QilNodeType.Ge: return cmp >= 0 ? f.True() : f.False();
case QilNodeType.Lt: return cmp < 0 ? f.True() : f.False();
case QilNodeType.Le: return cmp <= 0 ? f.True() : f.False();
}
Debug.Assert(false, "Cannot fold this comparison operation: " + opType);
return null;
}
//-----------------------------------------------
// Constructor
//-----------------------------------------------
/// <summary>
/// Construct a new node
/// </summary>
public QilNode(QilNodeType nodeType)
{
this.nodeType = nodeType;
}
//-----------------------------------------------
// Constructor
//-----------------------------------------------
/// <summary>
/// Construct a new node
/// </summary>
public QilLoop(QilNodeType nodeType, QilNode variable, QilNode body) : base(nodeType, variable, body)
{
}
public QilLiteral(QilNodeType nodeType, object?value) : base(nodeType)
{
Value = value;
}
//-----------------------------------------------
// Constructor
//-----------------------------------------------
/// <summary>
/// Construct a new node
/// </summary>
public QilInvoke(QilNodeType nodeType, QilNode function, QilNode arguments) : base(nodeType, function, arguments) {
}
