Esempio n. 1
0
        public static double ToDouble(XPathItem item)
        {
            XsltLibrary.CheckXsltValue(item);

            if (item.IsNode)
            {
                return(XPathConvert.StringToDouble(item.Value));
            }

            Type itemType = item.ValueType;

            if (itemType == StringType)
            {
                return(XPathConvert.StringToDouble(item.Value));
            }
            else if (itemType == DoubleType)
            {
                return(item.ValueAsDouble);
            }
            else
            {
                Debug.Assert(itemType == BooleanType, $"Unexpected type of atomic sequence {itemType}");
                return(item.ValueAsBoolean ? 1d : 0d);
            }
        }
Esempio n. 2
0
        //------------------------------------------------------------------------
        // ToBoolean (internal type to internal type)
        //------------------------------------------------------------------------

        public static bool ToBoolean(XPathItem item)
        {
            XsltLibrary.CheckXsltValue(item);

            if (item.IsNode)
            {
                return(true);
            }

            Type itemType = item.ValueType;

            if (itemType == StringType)
            {
                return(item.Value.Length != 0);
            }
            else if (itemType == DoubleType)
            {
                // (x < 0 || 0 < x)  ==  (x != 0) && !Double.IsNaN(x)
                double dbl = item.ValueAsDouble;
                return(dbl < 0 || 0 < dbl);
            }
            else
            {
                Debug.Assert(itemType == BooleanType, $"Unexpected type of atomic sequence {itemType}");
                return(item.ValueAsBoolean);
            }
        }
Esempio n. 3
0
        public static bool ToBoolean(IList <XPathItem> listItems)
        {
            XsltLibrary.CheckXsltValue(listItems);

            if (listItems.Count == 0)
            {
                return(false);
            }

            return(ToBoolean(listItems[0]));
        }
Esempio n. 4
0
        public static string ToString(IList <XPathItem> listItems)
        {
            XsltLibrary.CheckXsltValue(listItems);

            if (listItems.Count == 0)
            {
                return(string.Empty);
            }

            return(ToString(listItems[0]));
        }
Esempio n. 5
0
        public static IList <XPathNavigator> ToNodeSet(IList <XPathItem> listItems)
        {
            XsltLibrary.CheckXsltValue(listItems);

            if (listItems.Count == 1)
            {
                return(new XmlQueryNodeSequence(ToNode(listItems[0])));
            }

            return(XmlILStorageConverter.ItemsToNavigators(listItems));
        }
Esempio n. 6
0
        public static XPathNavigator ToNode(IList <XPathItem> listItems)
        {
            XsltLibrary.CheckXsltValue(listItems);

            if (listItems.Count == 1)
            {
                return(ToNode(listItems[0]));
            }

            throw new XslTransformException(SR.Xslt_NodeSetNotNode, string.Empty);
        }
Esempio n. 7
0
        public static double ToDouble(IList <XPathItem> listItems)
        {
            XsltLibrary.CheckXsltValue(listItems);

            if (listItems.Count == 0)
            {
                return(double.NaN);
            }

            return(ToDouble(listItems[0]));
        }
Esempio n. 8
0
        public static string ToString(XPathItem item)
        {
            XsltLibrary.CheckXsltValue(item);

            // Use XPath 1.0 rules to convert double to string
            if (!item.IsNode && item.ValueType == DoubleType)
            {
                return(XPathConvert.DoubleToString(item.ValueAsDouble));
            }

            return(item.Value);
        }
Esempio n. 9
0
        //------------------------------------------------
        // Msxml Extension Functions
        //------------------------------------------------

        public static double MSNumber(IList <XPathItem> value)
        {
            XsltLibrary.CheckXsltValue(value);
            if (value.Count == 0)
            {
                return(Double.NaN);
            }
            XPathItem item = value[0];

            string stringValue;

            if (item.IsNode)
            {
                stringValue = item.Value;
            }
            else
            {
                Type itemType = item.ValueType;
                if (itemType == XsltConvert.StringType)
                {
                    stringValue = item.Value;
                }
                else if (itemType == XsltConvert.DoubleType)
                {
                    return(item.ValueAsDouble);
                }
                else
                {
                    Debug.Assert(itemType == XsltConvert.BooleanType, "Unexpected type of atomic value " + itemType.ToString());
                    return(item.ValueAsBoolean ? 1d : 0d);
                }
            }

            Debug.Assert(stringValue != null);
            double d;

            if (XmlConvert.TryToDouble(stringValue, out d) != null)
            {
                d = double.NaN;
            }
            return(d);
        }
Esempio n. 10
0
        //------------------------------------------------------------------------
        // EnsureXXX methods (TreatAs)
        //------------------------------------------------------------------------

        public static IList <XPathNavigator> EnsureNodeSet(IList <XPathItem> listItems)
        {
            XsltLibrary.CheckXsltValue(listItems);

            if (listItems.Count == 1)
            {
                XPathItem item = listItems[0];
                if (!item.IsNode)
                {
                    throw new XslTransformException(SR.XPath_NodeSetExpected, string.Empty);
                }

                if (item is RtfNavigator)
                {
                    throw new XslTransformException(SR.XPath_RtfInPathExpr, string.Empty);
                }
            }

            return(XmlILStorageConverter.ItemsToNavigators(listItems));
        }
Esempio n. 11
0
        //------------------------------------------------
        // EXslt Functions
        //------------------------------------------------

        public static string EXslObjectType(IList <XPathItem> value)
        {
            if (value.Count != 1)
            {
                XsltLibrary.CheckXsltValue(value);
                return("node-set");
            }

            XPathItem item = value[0];

            if (item is RtfNavigator)
            {
                return("RTF");
            }
            else if (item.IsNode)
            {
                Debug.Assert(item is XPathNavigator);
                return("node-set");
            }

            object o = item.TypedValue;

            if (o is string)
            {
                return("string");
            }
            else if (o is double)
            {
                return("number");
            }
            else if (o is bool)
            {
                return("boolean");
            }
            else
            {
                Debug.Fail("Unexpected type: " + o.GetType().ToString());
                return("external");
            }
        }
Esempio n. 12
0
        //------------------------------------------------------------------------
        // ToNode (internal type to internal type)
        //------------------------------------------------------------------------

        public static XPathNavigator ToNode(XPathItem item)
        {
            XsltLibrary.CheckXsltValue(item);

            if (!item.IsNode)
            {
                // Create Navigator over text node containing string value of item
                XPathDocument doc    = new XPathDocument();
                XmlRawWriter  writer = doc.LoadFromWriter(XPathDocument.LoadFlags.AtomizeNames, string.Empty);
                writer.WriteString(ToString(item));
                writer.Close();
                return(doc.CreateNavigator());
            }

            RtfNavigator?rtf = item as RtfNavigator;

            if (rtf != null)
            {
                return(rtf.ToNavigator());
            }

            return((XPathNavigator)item);
        }
        //-----------------------------------------------
        // Constructors
        //-----------------------------------------------

        /// <summary>
        /// This constructor is internal so that external users cannot construct it (and therefore we do not have to test it separately).
        /// </summary>
        internal XmlQueryRuntime(XmlILCommand cmd, object defaultDataSource, XmlResolver dataSources, XsltArgumentList argList, XmlSequenceWriter seqWrt) {
            Debug.Assert(cmd != null, "Command object must be non-null");
            string[] names = cmd.Names;
            Int32Pair[] filters = cmd.Filters;
            WhitespaceRuleLookup wsRules;
            int i;

            this.cmd = cmd;

            // Early-Bound Library Objects
            wsRules = (cmd.WhitespaceRules.Count != 0) ? new WhitespaceRuleLookup(cmd.WhitespaceRules) : null;
            this.ctxt = new XmlQueryContext(this, defaultDataSource, dataSources, argList, wsRules);
            this.xsltLib = null;
            this.earlyInfo = cmd.EarlyBound;
            this.earlyObjects = (this.earlyInfo != null) ? new object[earlyInfo.Length] : null;

            // Global variables and parameters
            this.globalNames = cmd.GlobalNames;
            this.globalValues = (this.globalNames != null) ? new object[this.globalNames.Length] : null;

            // Names
            this.nameTableQuery = this.ctxt.QueryNameTable;
            this.atomizedNames = null;

            if (names != null) {
                // Atomize all names in "nameTableQuery".  Use names from the default data source's
                // name table when possible.
                XmlNameTable nameTableDefault = ctxt.DefaultNameTable;
                this.atomizedNames = new string[names.Length];

                if (nameTableDefault != this.nameTableQuery && nameTableDefault != null) {
                    // Ensure that atomized names from the default data source are added to the
                    // name table used in this query
                    for (i = 0; i < names.Length; i++) {
                        string name = nameTableDefault.Get(names[i]);
                        this.atomizedNames[i] = this.nameTableQuery.Add(name ?? names[i]);
                    }
                }
                else {
                    // Enter names into nametable used in this query
                    for (i = 0; i < names.Length; i++)
                        this.atomizedNames[i] = this.nameTableQuery.Add(names[i]);
                }
            }

            // Name filters
            this.filters = null;
            if (filters != null) {
                // Construct name filters.  Each pair of integers in the filters[] array specifies the
                // (localName, namespaceUri) of the NameFilter to be created.
                this.filters = new XmlNavigatorFilter[filters.Length];

                for (i = 0; i < filters.Length; i++)
                    this.filters[i] = XmlNavNameFilter.Create(this.atomizedNames[filters[i].Left], this.atomizedNames[filters[i].Right]);
            }

            // Prefix maping lists
            this.prefixMappingsList = cmd.PrefixMappingsList;

            // Xml types
            this.types = cmd.Types;

            // Xml collations
            this.collations = cmd.Collations;

            // Document ordering
            this.docOrderCmp = new DocumentOrderComparer();

            // Indexes
            this.indexes = null;

            // Output construction
            this.stkOutput = new Stack<XmlQueryOutput>(16);
            this.output = new XmlQueryOutput(this, seqWrt);
        }
Esempio n. 14
0
        //-----------------------------------------------
        // Constructors
        //-----------------------------------------------

        /// <summary>
        /// This constructor is internal so that external users cannot construct it (and therefore we do not have to test it separately).
        /// </summary>
        internal XmlQueryRuntime(XmlQueryStaticData data, object defaultDataSource, XmlResolver dataSources, XsltArgumentList argList, XmlSequenceWriter seqWrt)
        {
            Debug.Assert(data != null);
            string[]             names   = data.Names;
            Int32Pair[]          filters = data.Filters;
            WhitespaceRuleLookup wsRules;
            int i;

            // Early-Bound Library Objects
            wsRules       = (data.WhitespaceRules != null && data.WhitespaceRules.Count != 0) ? new WhitespaceRuleLookup(data.WhitespaceRules) : null;
            _ctxt         = new XmlQueryContext(this, defaultDataSource, dataSources, argList, wsRules);
            _xsltLib      = null;
            _earlyInfo    = data.EarlyBound;
            _earlyObjects = (_earlyInfo != null) ? new object[_earlyInfo.Length] : null;

            // Global variables and parameters
            _globalNames  = data.GlobalNames;
            _globalValues = (_globalNames != null) ? new object[_globalNames.Length] : null;

            // Names
            _nameTableQuery = _ctxt.QueryNameTable;
            _atomizedNames  = null;

            if (names != null)
            {
                // Atomize all names in "nameTableQuery".  Use names from the default data source's
                // name table when possible.
                XmlNameTable nameTableDefault = _ctxt.DefaultNameTable;
                _atomizedNames = new string[names.Length];

                if (nameTableDefault != _nameTableQuery && nameTableDefault != null)
                {
                    // Ensure that atomized names from the default data source are added to the
                    // name table used in this query
                    for (i = 0; i < names.Length; i++)
                    {
                        string name = nameTableDefault.Get(names[i]);
                        _atomizedNames[i] = _nameTableQuery.Add(name ?? names[i]);
                    }
                }
                else
                {
                    // Enter names into nametable used in this query
                    for (i = 0; i < names.Length; i++)
                    {
                        _atomizedNames[i] = _nameTableQuery.Add(names[i]);
                    }
                }
            }

            // Name filters
            _filters = null;
            if (filters != null)
            {
                // Construct name filters.  Each pair of integers in the filters[] array specifies the
                // (localName, namespaceUri) of the NameFilter to be created.
                _filters = new XmlNavigatorFilter[filters.Length];

                for (i = 0; i < filters.Length; i++)
                {
                    _filters[i] = XmlNavNameFilter.Create(_atomizedNames[filters[i].Left], _atomizedNames[filters[i].Right]);
                }
            }

            // Prefix maping lists
            _prefixMappingsList = data.PrefixMappingsList;

            // Xml types
            _types = data.Types;

            // Xml collations
            _collations = data.Collations;

            // Document ordering
            _docOrderCmp = new DocumentOrderComparer();

            // Indexes
            _indexes = null;

            // Output construction
            _stkOutput = new Stack <XmlQueryOutput>(16);
            _output    = new XmlQueryOutput(this, seqWrt);
        }
Esempio n. 15
0
        //-----------------------------------------------
        // Constructors
        //-----------------------------------------------

        /// <summary>
        /// This constructor is internal so that external users cannot construct it (and therefore we do not have to test it separately).
        /// </summary>
        internal XmlQueryRuntime(XmlQueryStaticData data, object defaultDataSource, XmlResolver dataSources, XsltArgumentList argList, XmlSequenceWriter seqWrt)
        {
            Debug.Assert(data != null);
            string[] names = data.Names;
            Int32Pair[] filters = data.Filters;
            WhitespaceRuleLookup wsRules;
            int i;

            // Early-Bound Library Objects
            wsRules = (data.WhitespaceRules != null && data.WhitespaceRules.Count != 0) ? new WhitespaceRuleLookup(data.WhitespaceRules) : null;
            _ctxt = new XmlQueryContext(this, defaultDataSource, dataSources, argList, wsRules);
            _xsltLib = null;
            _earlyInfo = data.EarlyBound;
            _earlyObjects = (_earlyInfo != null) ? new object[_earlyInfo.Length] : null;

            // Global variables and parameters
            _globalNames = data.GlobalNames;
            _globalValues = (_globalNames != null) ? new object[_globalNames.Length] : null;

            // Names
            _nameTableQuery = _ctxt.QueryNameTable;
            _atomizedNames = null;

            if (names != null)
            {
                // Atomize all names in "nameTableQuery".  Use names from the default data source's
                // name table when possible.
                XmlNameTable nameTableDefault = _ctxt.DefaultNameTable;
                _atomizedNames = new string[names.Length];

                if (nameTableDefault != _nameTableQuery && nameTableDefault != null)
                {
                    // Ensure that atomized names from the default data source are added to the
                    // name table used in this query
                    for (i = 0; i < names.Length; i++)
                    {
                        string name = nameTableDefault.Get(names[i]);
                        _atomizedNames[i] = _nameTableQuery.Add(name ?? names[i]);
                    }
                }
                else
                {
                    // Enter names into nametable used in this query
                    for (i = 0; i < names.Length; i++)
                        _atomizedNames[i] = _nameTableQuery.Add(names[i]);
                }
            }

            // Name filters
            _filters = null;
            if (filters != null)
            {
                // Construct name filters.  Each pair of integers in the filters[] array specifies the
                // (localName, namespaceUri) of the NameFilter to be created.
                _filters = new XmlNavigatorFilter[filters.Length];

                for (i = 0; i < filters.Length; i++)
                    _filters[i] = XmlNavNameFilter.Create(_atomizedNames[filters[i].Left], _atomizedNames[filters[i].Right]);
            }

            // Prefix maping lists
            _prefixMappingsList = data.PrefixMappingsList;

            // Xml types
            _types = data.Types;

            // Xml collations
            _collations = data.Collations;

            // Document ordering
            _docOrderCmp = new DocumentOrderComparer();

            // Indexes
            _indexes = null;

            // Output construction
            _stkOutput = new Stack<XmlQueryOutput>(16);
            _output = new XmlQueryOutput(this, seqWrt);
        }
        //-----------------------------------------------
        // Constructors
        //-----------------------------------------------

        /// <summary>
        /// This constructor is internal so that external users cannot construct it (and therefore we do not have to test it separately).
        /// </summary>
        internal XmlQueryRuntime(XmlILCommand cmd, object defaultDataSource, XmlResolver dataSources, XsltArgumentList argList, XmlSequenceWriter seqWrt)
        {
            Debug.Assert(cmd != null, "Command object must be non-null");
            string[]             names   = cmd.Names;
            Int32Pair[]          filters = cmd.Filters;
            WhitespaceRuleLookup wsRules;
            int i;

            this.cmd = cmd;

            // Early-Bound Library Objects
            wsRules           = (cmd.WhitespaceRules.Count != 0) ? new WhitespaceRuleLookup(cmd.WhitespaceRules) : null;
            this.ctxt         = new XmlQueryContext(this, defaultDataSource, dataSources, argList, wsRules);
            this.xsltLib      = null;
            this.earlyInfo    = cmd.EarlyBound;
            this.earlyObjects = (this.earlyInfo != null) ? new object[earlyInfo.Length] : null;

            // Global variables and parameters
            this.globalNames  = cmd.GlobalNames;
            this.globalValues = (this.globalNames != null) ? new object[this.globalNames.Length] : null;

            // Names
            this.nameTableQuery = this.ctxt.QueryNameTable;
            this.atomizedNames  = null;

            if (names != null)
            {
                // Atomize all names in "nameTableQuery".  Use names from the default data source's
                // name table when possible.
                XmlNameTable nameTableDefault = ctxt.DefaultNameTable;
                this.atomizedNames = new string[names.Length];

                if (nameTableDefault != this.nameTableQuery && nameTableDefault != null)
                {
                    // Ensure that atomized names from the default data source are added to the
                    // name table used in this query
                    for (i = 0; i < names.Length; i++)
                    {
                        string name = nameTableDefault.Get(names[i]);
                        this.atomizedNames[i] = this.nameTableQuery.Add(name ?? names[i]);
                    }
                }
                else
                {
                    // Enter names into nametable used in this query
                    for (i = 0; i < names.Length; i++)
                    {
                        this.atomizedNames[i] = this.nameTableQuery.Add(names[i]);
                    }
                }
            }

            // Name filters
            this.filters = null;
            if (filters != null)
            {
                // Construct name filters.  Each pair of integers in the filters[] array specifies the
                // (localName, namespaceUri) of the NameFilter to be created.
                this.filters = new XmlNavigatorFilter[filters.Length];

                for (i = 0; i < filters.Length; i++)
                {
                    this.filters[i] = XmlNavNameFilter.Create(this.atomizedNames[filters[i].Left], this.atomizedNames[filters[i].Right]);
                }
            }

            // Prefix maping lists
            this.prefixMappingsList = cmd.PrefixMappingsList;

            // Xml types
            this.types = cmd.Types;

            // Xml collations
            this.collations = cmd.Collations;

            // Document ordering
            this.docOrderCmp = new DocumentOrderComparer();

            // Indexes
            this.indexes = null;

            // Output construction
            this.stkOutput = new Stack <XmlQueryOutput>(16);
            this.output    = new XmlQueryOutput(this, seqWrt);
        }