//----------------------------------------------- // 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; }
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) { }
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) { }
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) { }
/// <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); }
//----------------------------------------------- // 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; }
/// <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; }
//----------------------------------------------- // Constructor //----------------------------------------------- /// <summary> /// Construct a new (empty) QilList /// </summary> public QilList(QilNodeType nodeType) : base(nodeType) { this.members = new QilNode[4]; this.xmlType = null; }
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> 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; }
public QilLiteral(QilNodeType nodeType, object?value) : base(nodeType) { Value = value; }