Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

1056 lines
42 KiB
C#

//-----------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------------------------
namespace System.ServiceModel.Dispatcher
{
using System.Collections;
using System.Runtime;
internal static class XPathCharTypes
{
static byte[] charProperties;
// Types of characters identified by this class
private const byte None = 0x00;
private const byte Letter = 0x01;
private const byte Combining = 0x02;
private const byte Digit = 0x04;
private const byte Extender = 0x08;
private const byte Whitespace = 0x10;
private const byte NCName = 0x20;
private const byte NCNameStart = 0x40;
#region Data Tables
// The character tables below hold unicode characters that are paired to represent character ranges.
// The first is the first character in the range, the second is the last character in the range.
// The definition of NCName is taken from "Namespaces in XML" (http://www.w3.org/TR/REC-xml-names/) Section 2
// The definition of Whitespace is taken from: "XML 1.0 (Second Edition)" (http://www.w3.org/TR/REC-xml) Section 2.3
// All classes of characters contain references to their definitions
// BaseChars
// Taken from: "XML 1.0 (Second Edition)" (http://www.w3.org/TR/REC-xml) Appendix B
// [#x0041-#x005A] | [#x0061-#x007A] | [#x00C0-#x00D6] | [#x00D8-#x00F6] | [#x00F8-#x00FF] | [#x0100-#x0131] | [#x0134-#x013E] | [#x0141-#x0148] | [#x014A-#x017E] | [#x0180-#x01C3] | [#x01CD-#x01F0] | [#x01F4-#x01F5] | [#x01FA-#x0217] | [#x0250-#x02A8] | [#x02BB-#x02C1] | #x0386 | [#x0388-#x038A] | #x038C | [#x038E-#x03A1] | [#x03A3-#x03CE] | [#x03D0-#x03D6] | #x03DA | #x03DC | #x03DE | #x03E0 | [#x03E2-#x03F3] | [#x0401-#x040C] | [#x040E-#x044F] | [#x0451-#x045C] | [#x045E-#x0481] | [#x0490-#x04C4] | [#x04C7-#x04C8] | [#x04CB-#x04CC] | [#x04D0-#x04EB] | [#x04EE-#x04F5] | [#x04F8-#x04F9] | [#x0531-#x0556] | #x0559 | [#x0561-#x0586] | [#x05D0-#x05EA] | [#x05F0-#x05F2] | [#x0621-#x063A] | [#x0641-#x064A] | [#x0671-#x06B7] | [#x06BA-#x06BE] | [#x06C0-#x06CE] | [#x06D0-#x06D3] | #x06D5 | [#x06E5-#x06E6] | [#x0905-#x0939] | #x093D | [#x0958-#x0961] | [#x0985-#x098C] | [#x098F-#x0990] | [#x0993-#x09A8] | [#x09AA-#x09B0] | #x09B2 | [#x09B6-#x09B9] | [#x09DC-#x09DD] | [#x09DF-#x09E1] | [#x09F0-#x09F1] | [#x0A05-#x0A0A] | [#x0A0F-#x0A10] | [#x0A13-#x0A28] | [#x0A2A-#x0A30] | [#x0A32-#x0A33] | [#x0A35-#x0A36] | [#x0A38-#x0A39] | [#x0A59-#x0A5C] | #x0A5E | [#x0A72-#x0A74] | [#x0A85-#x0A8B] | #x0A8D | [#x0A8F-#x0A91] | [#x0A93-#x0AA8] | [#x0AAA-#x0AB0] | [#x0AB2-#x0AB3] | [#x0AB5-#x0AB9] | #x0ABD | #x0AE0 | [#x0B05-#x0B0C] | [#x0B0F-#x0B10] | [#x0B13-#x0B28] | [#x0B2A-#x0B30] | [#x0B32-#x0B33] | [#x0B36-#x0B39] | #x0B3D | [#x0B5C-#x0B5D] | [#x0B5F-#x0B61] | [#x0B85-#x0B8A] | [#x0B8E-#x0B90] | [#x0B92-#x0B95] | [#x0B99-#x0B9A] | #x0B9C | [#x0B9E-#x0B9F] | [#x0BA3-#x0BA4] | [#x0BA8-#x0BAA] | [#x0BAE-#x0BB5] | [#x0BB7-#x0BB9] | [#x0C05-#x0C0C] | [#x0C0E-#x0C10] | [#x0C12-#x0C28] | [#x0C2A-#x0C33] | [#x0C35-#x0C39] | [#x0C60-#x0C61] | [#x0C85-#x0C8C] | [#x0C8E-#x0C90] | [#x0C92-#x0CA8] | [#x0CAA-#x0CB3] | [#x0CB5-#x0CB9] | #x0CDE | [#x0CE0-#x0CE1] | [#x0D05-#x0D0C] | [#x0D0E-#x0D10] | [#x0D12-#x0D28] | [#x0D2A-#x0D39] | [#x0D60-#x0D61] | [#x0E01-#x0E2E] | #x0E30 | [#x0E32-#x0E33] | [#x0E40-#x0E45] |
// [#x0E81-#x0E82] | #x0E84 | [#x0E87-#x0E88] | #x0E8A | #x0E8D | [#x0E94-#x0E97] | [#x0E99-#x0E9F] | [#x0EA1-#x0EA3] | #x0EA5 | #x0EA7 | [#x0EAA-#x0EAB] | [#x0EAD-#x0EAE] | #x0EB0 | [#x0EB2-#x0EB3] | #x0EBD | [#x0EC0-#x0EC4] | [#x0F40-#x0F47] | [#x0F49-#x0F69] | [#x10A0-#x10C5] | [#x10D0-#x10F6] | #x1100 | [#x1102-#x1103] | [#x1105-#x1107] | #x1109 | [#x110B-#x110C] | [#x110E-#x1112] | #x113C | #x113E | #x1140 | #x114C | #x114E | #x1150 | [#x1154-#x1155] | #x1159 | [#x115F-#x1161] | #x1163 | #x1165 | #x1167 | #x1169 | [#x116D-#x116E] | [#x1172-#x1173] | #x1175 | #x119E | #x11A8 | #x11AB | [#x11AE-#x11AF] | [#x11B7-#x11B8] | #x11BA | [#x11BC-#x11C2] | #x11EB | #x11F0 | #x11F9 | [#x1E00-#x1E9B] | [#x1EA0-#x1EF9] | [#x1F00-#x1F15] | [#x1F18-#x1F1D] | [#x1F20-#x1F45] | [#x1F48-#x1F4D] | [#x1F50-#x1F57] | #x1F59 | #x1F5B | #x1F5D | [#x1F5F-#x1F7D] | [#x1F80-#x1FB4] | [#x1FB6-#x1FBC] | #x1FBE | [#x1FC2-#x1FC4] | [#x1FC6-#x1FCC] | [#x1FD0-#x1FD3] | [#x1FD6-#x1FDB] | [#x1FE0-#x1FEC] | [#x1FF2-#x1FF4] | [#x1FF6-#x1FFC] | #x2126 | [#x212A-#x212B] | #x212E | [#x2180-#x2182] | [#x3041-#x3094] | [#x30A1-#x30FA] | [#x3105-#x312C] | [#xAC00-#xD7A3]
const string BaseChars =
"\u0041\u005A\u0061\u007A\u00C0\u00D6\u00D8\u00F6" +
"\u00F8\u00FF\u0100\u0131\u0134\u013E\u0141\u0148" +
"\u014A\u017E\u0180\u01C3\u01CD\u01F0\u01F4\u01F5" +
"\u01FA\u0217\u0250\u02A8\u02BB\u02C1\u0386\u0386" +
"\u0388\u038A\u038C\u038C\u038E\u03A1\u03A3\u03CE" +
"\u03D0\u03D6\u03DA\u03DA\u03DC\u03DC\u03DE\u03DE" +
"\u03E0\u03E0\u03E2\u03F3\u0401\u040C\u040E\u044F" +
"\u0451\u045C\u045E\u0481\u0490\u04C4\u04C7\u04C8" +
"\u04CB\u04CC\u04D0\u04EB\u04EE\u04F5\u04F8\u04F9" +
"\u0531\u0556\u0559\u0559\u0561\u0586\u05D0\u05EA" +
"\u05F0\u05F2\u0621\u063A\u0641\u064A\u0671\u06B7" +
"\u06BA\u06BE\u06C0\u06CE\u06D0\u06D3\u06D5\u06D5" +
"\u06E5\u06E6\u0905\u0939\u093D\u093D\u0958\u0961" +
"\u0985\u098C\u098F\u0990\u0993\u09A8\u09AA\u09B0" +
"\u09B2\u09B2\u09B6\u09B9\u09DC\u09DD\u09DF\u09E1" +
"\u09F0\u09F1\u0A05\u0A0A\u0A0F\u0A10\u0A13\u0A28" +
"\u0A2A\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39" +
"\u0A59\u0A5C\u0A5E\u0A5E\u0A72\u0A74\u0A85\u0A8B" +
"\u0A8D\u0A8D\u0A8F\u0A91\u0A93\u0AA8\u0AAA\u0AB0" +
"\u0AB2\u0AB3\u0AB5\u0AB9\u0ABD\u0ABD\u0AE0\u0AE0" +
"\u0B05\u0B0C\u0B0F\u0B10\u0B13\u0B28\u0B2A\u0B30" +
"\u0B32\u0B33\u0B36\u0B39\u0B3D\u0B3D\u0B5C\u0B5D" +
"\u0B5F\u0B61\u0B85\u0B8A\u0B8E\u0B90\u0B92\u0B95" +
"\u0B99\u0B9A\u0B9C\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4" +
"\u0BA8\u0BAA\u0BAE\u0BB5\u0BB7\u0BB9\u0C05\u0C0C" +
"\u0C0E\u0C10\u0C12\u0C28\u0C2A\u0C33\u0C35\u0C39" +
"\u0C60\u0C61\u0C85\u0C8C\u0C8E\u0C90\u0C92\u0CA8" +
"\u0CAA\u0CB3\u0CB5\u0CB9\u0CDE\u0CDE\u0CE0\u0CE1" +
"\u0D05\u0D0C\u0D0E\u0D10\u0D12\u0D28\u0D2A\u0D39" +
"\u0D60\u0D61\u0E01\u0E2E\u0E30\u0E30\u0E32\u0E33" +
"\u0E40\u0E45\u0E81\u0E82\u0E84\u0E84\u0E87\u0E88" +
"\u0E8A\u0E8A\u0E8D\u0E8D\u0E94\u0E97\u0E99\u0E9F" +
"\u0EA1\u0EA3\u0EA5\u0EA5\u0EA7\u0EA7\u0EAA\u0EAB" +
"\u0EAD\u0EAE\u0EB0\u0EB0\u0EB2\u0EB3\u0EBD\u0EBD" +
"\u0EC0\u0EC4\u0F40\u0F47\u0F49\u0F69\u10A0\u10C5" +
"\u10D0\u10F6\u1100\u1100\u1102\u1103\u1105\u1107" +
"\u1109\u1109\u110B\u110C\u110E\u1112\u113C\u113C" +
"\u113E\u113E\u1140\u1140\u114C\u114C\u114E\u114E" +
"\u1150\u1150\u1154\u1155\u1159\u1159\u115F\u1161" +
"\u1163\u1163\u1165\u1165\u1167\u1167\u1169\u1169" +
"\u116D\u116E\u1172\u1173\u1175\u1175\u119E\u119E" +
"\u11A8\u11A8\u11AB\u11AB\u11AE\u11AF\u11B7\u11B8" +
"\u11BA\u11BA\u11BC\u11C2\u11EB\u11EB\u11F0\u11F0" +
"\u11F9\u11F9\u1E00\u1E9B\u1EA0\u1EF9\u1F00\u1F15" +
"\u1F18\u1F1D\u1F20\u1F45\u1F48\u1F4D\u1F50\u1F57" +
"\u1F59\u1F59\u1F5B\u1F5B\u1F5D\u1F5D\u1F5F\u1F7D" +
"\u1F80\u1FB4\u1FB6\u1FBC\u1FBE\u1FBE\u1FC2\u1FC4" +
"\u1FC6\u1FCC\u1FD0\u1FD3\u1FD6\u1FDB\u1FE0\u1FEC" +
"\u1FF2\u1FF4\u1FF6\u1FFC\u2126\u2126\u212A\u212B" +
"\u212E\u212E\u2180\u2182\u3041\u3094\u30A1\u30FA" +
"\u3105\u312C\uAC00\uD7A3";
// IdeogramicChars
// Taken from: "XML 1.0 (Second Edition)" (http://www.w3.org/TR/REC-xml) Appendix B
// [#x4E00-#x9FA5] | #x3007 | [#x3021-#x3029]
const string IdeogramicChars =
"\u4E00\u9FA5\u3007\u3007\u3021\u3029";
// CombiningChars
// Taken from: "XML 1.0 (Second Edition)" (http://www.w3.org/TR/REC-xml) Appendix B
// [#x0300-#x0345] | [#x0360-#x0361] | [#x0483-#x0486] | [#x0591-#x05A1] | [#x05A3-#x05B9] | [#x05BB-#x05BD] | #x05BF | [#x05C1-#x05C2] | #x05C4 | [#x064B-#x0652] | #x0670 | [#x06D6-#x06DC] | [#x06DD-#x06DF] | [#x06E0-#x06E4] | [#x06E7-#x06E8] | [#x06EA-#x06ED] | [#x0901-#x0903] | #x093C | [#x093E-#x094C] | #x094D | [#x0951-#x0954] | [#x0962-#x0963] | [#x0981-#x0983] | #x09BC | #x09BE | #x09BF | [#x09C0-#x09C4] | [#x09C7-#x09C8] | [#x09CB-#x09CD] | #x09D7 | [#x09E2-#x09E3] | #x0A02 | #x0A3C | #x0A3E | #x0A3F | [#x0A40-#x0A42] | [#x0A47-#x0A48] | [#x0A4B-#x0A4D] | [#x0A70-#x0A71] | [#x0A81-#x0A83] | #x0ABC | [#x0ABE-#x0AC5] | [#x0AC7-#x0AC9] | [#x0ACB-#x0ACD] | [#x0B01-#x0B03] | #x0B3C | [#x0B3E-#x0B43] | [#x0B47-#x0B48] | [#x0B4B-#x0B4D] | [#x0B56-#x0B57] | [#x0B82-#x0B83] | [#x0BBE-#x0BC2] | [#x0BC6-#x0BC8] | [#x0BCA-#x0BCD] | #x0BD7 | [#x0C01-#x0C03] | [#x0C3E-#x0C44] | [#x0C46-#x0C48] | [#x0C4A-#x0C4D] | [#x0C55-#x0C56] | [#x0C82-#x0C83] | [#x0CBE-#x0CC4] | [#x0CC6-#x0CC8] | [#x0CCA-#x0CCD] | [#x0CD5-#x0CD6] | [#x0D02-#x0D03] | [#x0D3E-#x0D43] | [#x0D46-#x0D48] | [#x0D4A-#x0D4D] | #x0D57 | #x0E31 | [#x0E34-#x0E3A] | [#x0E47-#x0E4E] | #x0EB1 | [#x0EB4-#x0EB9] | [#x0EBB-#x0EBC] | [#x0EC8-#x0ECD] | [#x0F18-#x0F19] | #x0F35 | #x0F37 | #x0F39 | #x0F3E | #x0F3F | [#x0F71-#x0F84] | [#x0F86-#x0F8B] | [#x0F90-#x0F95] | #x0F97 | [#x0F99-#x0FAD] | [#x0FB1-#x0FB7] | #x0FB9 | [#x20D0-#x20DC] | #x20E1 | [#x302A-#x302F] | #x3099 | #x309A
const string CombiningChars =
"\u0300\u0345\u0360\u0361\u0483\u0486\u0591\u05A1" +
"\u05A3\u05B9\u05BB\u05BD\u05BF\u05BF\u05C1\u05C2" +
"\u05C4\u05C4\u064B\u0652\u0670\u0670\u06D6\u06DC" +
"\u06DD\u06DF\u06E0\u06E4\u06E7\u06E8\u06EA\u06ED" +
"\u0901\u0903\u093C\u093C\u093E\u094C\u094D\u094D" +
"\u0951\u0954\u0962\u0963\u0981\u0983\u09BC\u09BC" +
"\u09BE\u09BE\u09BF\u09BF\u09C0\u09C4\u09C7\u09C8" +
"\u09CB\u09CD\u09D7\u09D7\u09E2\u09E3\u0A02\u0A02" +
"\u0A3C\u0A3C\u0A3E\u0A3E\u0A3F\u0A3F\u0A40\u0A42" +
"\u0A47\u0A48\u0A4B\u0A4D\u0A70\u0A71\u0A81\u0A83" +
"\u0ABC\u0ABC\u0ABE\u0AC5\u0AC7\u0AC9\u0ACB\u0ACD" +
"\u0B01\u0B03\u0B3C\u0B3C\u0B3E\u0B43\u0B47\u0B48" +
"\u0B4B\u0B4D\u0B56\u0B57\u0B82\u0B83\u0BBE\u0BC2" +
"\u0BC6\u0BC8\u0BCA\u0BCD\u0BD7\u0BD7\u0C01\u0C03" +
"\u0C3E\u0C44\u0C46\u0C48\u0C4A\u0C4D\u0C55\u0C56" +
"\u0C82\u0C83\u0CBE\u0CC4\u0CC6\u0CC8\u0CCA\u0CCD" +
"\u0CD5\u0CD6\u0D02\u0D03\u0D3E\u0D43\u0D46\u0D48" +
"\u0D4A\u0D4D\u0D57\u0D57\u0E31\u0E31\u0E34\u0E3A" +
"\u0E47\u0E4E\u0EB1\u0EB1\u0EB4\u0EB9\u0EBB\u0EBC" +
"\u0EC8\u0ECD\u0F18\u0F19\u0F35\u0F35\u0F37\u0F37" +
"\u0F39\u0F39\u0F3E\u0F3E\u0F3F\u0F3F\u0F71\u0F84" +
"\u0F86\u0F8B\u0F90\u0F95\u0F97\u0F97\u0F99\u0FAD" +
"\u0FB1\u0FB7\u0FB9\u0FB9\u20D0\u20DC\u20E1\u20E1" +
"\u302A\u302F\u3099\u3099\u309A\u309A";
// DigitChars
// Taken from: "XML 1.0 (Second Edition)" (http://www.w3.org/TR/REC-xml) Appendix B
// [#x0030-#x0039] | [#x0660-#x0669] | [#x06F0-#x06F9] | [#x0966-#x096F] | [#x09E6-#x09EF] | [#x0A66-#x0A6F] | [#x0AE6-#x0AEF] | [#x0B66-#x0B6F] | [#x0BE7-#x0BEF] | [#x0C66-#x0C6F] | [#x0CE6-#x0CEF] | [#x0D66-#x0D6F] | [#x0E50-#x0E59] | [#x0ED0-#x0ED9] | [#x0F20-#x0F29]
const string DigitChars =
"\u0030\u0039\u0660\u0669\u06F0\u06F9\u0966\u096F" +
"\u09E6\u09EF\u0A66\u0A6F\u0AE6\u0AEF\u0B66\u0B6F" +
"\u0BE7\u0BEF\u0C66\u0C6F\u0CE6\u0CEF\u0D66\u0D6F" +
"\u0E50\u0E59\u0ED0\u0ED9\u0F20\u0F29";
// ExtenderChars
// Taken from: "XML 1.0 (Second Edition)" (http://www.w3.org/TR/REC-xml) Appendix B
// #x00B7 | #x02D0 | #x02D1 | #x0387 | #x0640 | #x0E46 | #x0EC6 | #x3005 | [#x3031-#x3035] | [#x309D-#x309E] | [#x30FC-#x30FE]
const string ExtenderChars =
"\u00B7\u00B7\u02D0\u02D0\u02D1\u02D1\u0387\u0387" +
"\u0640\u0640\u0E46\u0E46\u0EC6\u0EC6\u3005\u3005" +
"\u3031\u3035\u309D\u309E\u30FC\u30FE";
// WhitespaceChars
// Taken from: "XML 1.0 (Second Edition)" (http://www.w3.org/TR/REC-xml) Section 2.3
// #x0020 | #x0009 | #x000D | #x000A
const string WhitespaceChars =
"\u0020\u0020\u0009\u0009\u000D\u000D\u000A\u000A";
// Other NCName start chars
// Taken from: "Namespaces in XML" (http://www.w3.org/TR/REC-xml-names/) Section 2
const string OtherNCNameStartChars =
"__";
// Other NCName chars
// Taken from: "Namespaces in XML" (http://www.w3.org/TR/REC-xml-names/) Section 2
const string OtherNCNameChars =
"..--__";
#endregion
// Static Constructor
// Initializes the table of unicode -> type mappings
static XPathCharTypes()
{
if (charProperties != null)
{
return;
}
charProperties = new byte[char.MaxValue];
// PERF: precompute the classes of each character set so SetProperties only needs to be run once per set.
// Letter = BaseChar + Ideogramic
SetProperties(BaseChars, Letter);
SetProperties(IdeogramicChars, Letter);
// Combining
SetProperties(CombiningChars, Combining);
// Digit
SetProperties(DigitChars, Digit);
// Extender
SetProperties(ExtenderChars, Extender);
// Whitespace
SetProperties(WhitespaceChars, Whitespace);
// NCNameStart = Base + Ideogramic + Other
SetProperties(BaseChars, NCNameStart);
SetProperties(IdeogramicChars, NCNameStart);
SetProperties(OtherNCNameStartChars, NCNameStart);
// NCName = NCNameStart + Combining + Extender
SetProperties(BaseChars, NCName);
SetProperties(IdeogramicChars, NCName);
SetProperties(DigitChars, NCName);
SetProperties(CombiningChars, NCName);
SetProperties(ExtenderChars, NCName);
SetProperties(OtherNCNameChars, NCName);
}
// Identify all described characters as belonging to a particular type
private static void SetProperties(string ranges, byte value)
{
// Iterate over all characters in the table
for (int p = 0; p < ranges.Length; p += 2)
{
// Iterate over all characters in a range
for (int i = ranges[p], last = ranges[p + 1]; i <= last; i++)
{
// Add the code to the character
charProperties[i] |= value;
}
}
}
// Get a character's code
// This is done as a separate function for clarity and flexability
// The compiler should just inline it
private static byte GetCode(char c)
{
return charProperties[c];
}
#region Classifying functions
// These are functions that simply test whether a character is of a particular type
#if NO
internal static bool IsLetter(char c)
{
return ((GetCode(c) & Letter) != 0);
}
internal static bool IsCombining(char c)
{
return ((GetCode(c) & Combining) != 0);
}
#endif
internal static bool IsDigit(char c)
{
return ((GetCode(c) & Digit) != 0);
}
#if NO
internal static bool IsExtender(char c)
{
return ((GetCode(c) & Extender) != 0);
}
#endif
internal static bool IsWhitespace(char c)
{
return ((GetCode(c) & Whitespace) != 0);
}
internal static bool IsNCName(char c)
{
return ((GetCode(c) & NCName) != 0);
}
internal static bool IsNCNameStart(char c)
{
return ((GetCode(c) & NCNameStart) != 0);
}
#endregion
}
internal enum XPathTokenID
{
Unknown = 0x00000000,
Terminal = 0x10000000,
NameTest = 0x20000000,
NodeType = 0x40000000,
Operator = 0x01000000,
NamedOperator = 0x02000000,
Function = 0x04000000,
Axis = 0x08000000,
Literal = 0x00100000,
Number = 0x00200000,
Variable = 0x00400000,
TypeMask = 0x7f400000,
// terminals
LParen = 0x00000001 | XPathTokenID.Terminal,
RParen = 0x00000002 | XPathTokenID.Terminal,
LBracket = 0x00000003 | XPathTokenID.Terminal,
RBracket = 0x00000004 | XPathTokenID.Terminal,
Period = 0x00000005 | XPathTokenID.Terminal,
DblPeriod = 0x00000006 | XPathTokenID.Terminal,
AtSign = 0x00000007 | XPathTokenID.Terminal,
Comma = 0x00000008 | XPathTokenID.Terminal,
DblColon = 0x00000009 | XPathTokenID.Terminal,
Whitespace = 0x0000000A | XPathTokenID.Terminal,
// operators
Eq = 0x0000000B | XPathTokenID.Operator,
Neq = 0x0000000C | XPathTokenID.Operator,
Gt = 0x0000000D | XPathTokenID.Operator,
Gte = 0x0000000E | XPathTokenID.Operator,
Lt = 0x0000000F | XPathTokenID.Operator,
Lte = 0x00000010 | XPathTokenID.Operator,
Plus = 0x00000012 | XPathTokenID.Operator,
Minus = 0x00000013 | XPathTokenID.Operator,
Slash = 0x00000014 | XPathTokenID.Operator,
Multiply = 0x00000015 | XPathTokenID.Operator,
Pipe = 0x00000016 | XPathTokenID.Operator,
DblSlash = 0x00000017 | XPathTokenID.Operator,
Mod = 0x00000018 | XPathTokenID.NamedOperator,
And = 0x00000019 | XPathTokenID.NamedOperator,
Or = 0x0000001A | XPathTokenID.NamedOperator,
Div = 0x0000001B | XPathTokenID.NamedOperator,
// Literals
Integer = 0x0000001C | XPathTokenID.Number,
Decimal = 0x0000001D | XPathTokenID.Number,
String = 0x0000001E | XPathTokenID.Literal,
//
Comment = 0x0000001F | XPathTokenID.NodeType,
Text = 0x00000020 | XPathTokenID.NodeType,
Processing = 0x00000021 | XPathTokenID.NodeType,
Node = 0x00000022 | XPathTokenID.NodeType,
Wildcard = 0x00000023 | XPathTokenID.NameTest,
NameWildcard = 0x00000024 | XPathTokenID.NameTest,
//QName = 0x00000025 | XPathTokenID.NameTest,
// Keywords
Ancestor = 0x00000027 | XPathTokenID.Axis,
AncestorOrSelf = 0x00000028 | XPathTokenID.Axis,
Attribute = 0x00000029 | XPathTokenID.Axis,
Child = 0x0000002A | XPathTokenID.Axis,
Descendant = 0x0000002B | XPathTokenID.Axis,
DescendantOrSelf = 0x0000002C | XPathTokenID.Axis,
Following = 0x0000002D | XPathTokenID.Axis,
FollowingSibling = 0x0000002E | XPathTokenID.Axis,
Namespace = 0x0000002F | XPathTokenID.Axis,
Parent = 0x00000030 | XPathTokenID.Axis,
Preceding = 0x00000031 | XPathTokenID.Axis,
PrecedingSibling = 0x00000032 | XPathTokenID.Axis,
Self = 0x00000033 | XPathTokenID.Axis
}
// Represents a single token of an XPath expression
internal class XPathToken
{
string name;
double number;
string prefix;
XPathTokenID tokenID;
internal XPathToken()
{
this.tokenID = XPathTokenID.Unknown;
}
internal string Name
{
get
{
return this.name;
}
}
internal double Number
{
get
{
return this.number;
}
}
internal string Prefix
{
get
{
return this.prefix;
}
}
internal XPathTokenID TokenID
{
get
{
return this.tokenID;
}
}
internal void Clear()
{
this.number = double.NaN;
this.prefix = string.Empty;
this.name = string.Empty;
this.tokenID = XPathTokenID.Unknown;
}
internal void Set(XPathTokenID id)
{
this.Clear();
this.tokenID = id;
}
internal void Set(XPathTokenID id, double number)
{
this.Set(id);
this.number = number;
}
internal void Set(XPathTokenID id, string name)
{
Fx.Assert(null != name, "");
this.Clear();
this.tokenID = id;
this.name = name;
}
internal void Set(XPathTokenID id, XPathParser.QName qname)
{
this.Set(id, qname.Name);
this.prefix = qname.Prefix;
}
}
internal class XPathLexer
{
static Hashtable namedTypes; // Mapping from named types to token IDs
XPathTokenID previousID;
string xpath;
int tokenStart;
int currChar;
int xpathLength;
char ch;
XPathToken token;
bool resolveKeywords;
// Static Constructor
// Set up the mapping of named types
static XPathLexer()
{
namedTypes = new Hashtable();
// Named operators
namedTypes.Add("and", XPathTokenID.And);
namedTypes.Add("or", XPathTokenID.Or);
namedTypes.Add("mod", XPathTokenID.Mod);
namedTypes.Add("div", XPathTokenID.Div);
// Axes
namedTypes.Add("ancestor", XPathTokenID.Ancestor);
namedTypes.Add("ancestor-or-self", XPathTokenID.AncestorOrSelf);
namedTypes.Add("attribute", XPathTokenID.Attribute);
namedTypes.Add("child", XPathTokenID.Child);
namedTypes.Add("descendant", XPathTokenID.Descendant);
namedTypes.Add("descendant-or-self", XPathTokenID.DescendantOrSelf);
namedTypes.Add("following", XPathTokenID.Following);
namedTypes.Add("following-sibling", XPathTokenID.FollowingSibling);
namedTypes.Add("namespace", XPathTokenID.Namespace);
namedTypes.Add("parent", XPathTokenID.Parent);
namedTypes.Add("preceding", XPathTokenID.Preceding);
namedTypes.Add("preceding-sibling", XPathTokenID.PrecedingSibling);
namedTypes.Add("self", XPathTokenID.Self);
// Node types
namedTypes.Add("comment", XPathTokenID.Comment);
namedTypes.Add("text", XPathTokenID.Text);
namedTypes.Add("processing-instruction", XPathTokenID.Processing);
namedTypes.Add("node", XPathTokenID.Node);
}
internal XPathLexer(string xpath)
: this(xpath, true)
{
}
internal XPathLexer(string xpath, bool resolveKeywords)
{
this.resolveKeywords = resolveKeywords;
// Hold on to a copy of the string so it can't be changed out from under us
this.xpath = string.Copy(xpath);
this.xpathLength = this.xpath.Length;
// Start at the beginning
this.tokenStart = 0;
this.currChar = 0;
this.ch = char.MinValue;
this.previousID = XPathTokenID.Unknown;
// We will not create new tokens, we will simply change the old one.
// This will be the only XPathToken instance created by the lexer
// The 'next token' data can be more quickly communicated to the parser if they both hold a reference to the data.
this.token = new XPathToken();
// Strip leading whitespace
ConsumeWhitespace();
}
internal int FirstTokenChar
{
get
{
return this.tokenStart;
}
}
internal XPathToken Token
{
get
{
// Return the lexer's token instance.
return this.token;
}
}
// Try to advance to the next character in the xpath string
private bool AdvanceChar()
{
if (this.currChar < this.xpathLength)
{
// Advance to the next character
this.ch = this.xpath[this.currChar];
this.currChar++;
return true;
}
else if (this.currChar == this.xpathLength)
{
// Signal that we're at the end of the string
this.currChar++;
this.ch = char.MinValue;
}
return false;
}
// Advance the 'start of token' marker to the current location in the string
private void ConsumeToken()
{
this.tokenStart = this.currChar;
}
// Query for the portion of the xpath expression already consumed.
internal string ConsumedSubstring()
{
return this.xpath.Substring(0, this.tokenStart);
}
// Query for the portion of the xpath expression currently being consumed as a token.
private string CurrentSubstring()
{
return this.xpath.Substring(this.tokenStart, this.currChar - this.tokenStart);
}
private char PeekChar()
{
return PeekChar(1);
}
private char PeekChar(int offset)
{
int peekChar = this.currChar + offset - 1;
if (peekChar < this.xpathLength)
{
return this.xpath[peekChar];
}
return char.MinValue;
}
private void PutbackChar()
{
if (this.currChar > this.tokenStart)
{
--this.currChar;
}
}
// Move to the next token
// This updates the values in the token instance and returns true if successful.
internal bool MoveNext()
{
// Hold onto the ID of the last token.
// It will be needed by some of the special cases.
this.previousID = this.token.TokenID;
// If there are no more characters, we can't get another token.
if (!AdvanceChar())
{
return false;
}
if (XPathCharTypes.IsNCNameStart(this.ch))
{
// Extract a QName if we've got the start of an NCName
TokenizeQName();
}
else if (XPathCharTypes.IsDigit(this.ch))
{
// Extract a number
TokenizeNumber();
}
else
{
// Everything else is a single/double character token, or a variable.
switch (this.ch)
{
case '(':
token.Set(XPathTokenID.LParen);
break;
case ')':
token.Set(XPathTokenID.RParen);
break;
case '[':
token.Set(XPathTokenID.LBracket);
break;
case ']':
token.Set(XPathTokenID.RBracket);
break;
case '.':
// Watch for a double period
if (PeekChar() == '.')
{
AdvanceChar();
token.Set(XPathTokenID.DblPeriod);
}
else
{
// Check if the period is the start of a number
if (XPathCharTypes.IsDigit(PeekChar()))
{
TokenizeNumber();
}
else
{
token.Set(XPathTokenID.Period);
}
}
break;
case '@':
token.Set(XPathTokenID.AtSign);
break;
case ',':
token.Set(XPathTokenID.Comma);
break;
case ':':
// Only a double colon is permitted.
// The single colon part of the QName is consumed in TokenizeQName if it is valid
if (PeekChar() == ':')
{
AdvanceChar();
token.Set(XPathTokenID.DblColon);
}
else
{
ThrowError(QueryCompileError.UnexpectedToken, CurrentSubstring());
}
break;
case '/':
// Check for a double slash
if (PeekChar() == '/')
{
AdvanceChar();
token.Set(XPathTokenID.DblSlash);
}
else
{
token.Set(XPathTokenID.Slash);
}
break;
case '|':
token.Set(XPathTokenID.Pipe);
break;
case '+':
token.Set(XPathTokenID.Plus);
break;
case '-':
token.Set(XPathTokenID.Minus);
break;
case '=':
token.Set(XPathTokenID.Eq);
break;
case '!':
// This can only be the start of a '!='
// 'not' is a negation in XPath
if (PeekChar() == '=')
{
AdvanceChar();
token.Set(XPathTokenID.Neq);
}
else
{
ThrowError(QueryCompileError.UnsupportedOperator, CurrentSubstring());
}
break;
case '<':
// Watch for '<='
if (PeekChar() == '=')
{
AdvanceChar();
token.Set(XPathTokenID.Lte);
}
else
{
token.Set(XPathTokenID.Lt);
}
break;
case '>':
// Watch for '>='
if (PeekChar() == '=')
{
AdvanceChar();
token.Set(XPathTokenID.Gte);
}
else
{
token.Set(XPathTokenID.Gt);
}
break;
case '*':
// Check if we're supposed to parse a '*' as a multiply
if (IsSpecialPrev())
{
token.Set(XPathTokenID.Multiply);
}
else
{
token.Set(XPathTokenID.Wildcard, new XPathParser.QName(string.Empty, QueryDataModel.Wildcard));
}
break;
case '$':
// Make sure '$' was followed by something that counts as a variable name
XPathParser.QName qname = GetQName();
if (qname.Prefix.Length == 0 && qname.Name.Length == 0)
{
AdvanceChar();
ThrowError(QueryCompileError.InvalidVariable, this.ch == char.MinValue ? string.Empty : CurrentSubstring());
}
token.Set(XPathTokenID.Variable, qname);
break;
case '\"':
TokenizeLiteral('\"');
break;
case '\'':
TokenizeLiteral('\'');
break;
default:
// Unrecognized character
token.Set(XPathTokenID.Unknown);
break;
}
}
// Whitespace can mark the end of a token, but is not part of the XPath syntax
ConsumeWhitespace();
return true;
}
private void ConsumeWhitespace()
{
// Advance over all whitespace characters and consume the all recently read characters
for (; XPathCharTypes.IsWhitespace(PeekChar()); AdvanceChar());
ConsumeToken();
}
private void TokenizeQName()
{
for (; XPathCharTypes.IsNCName(PeekChar()); AdvanceChar());
string name1 = this.CurrentSubstring();
XPathTokenID id = XPathTokenID.Unknown;
XPathParser.QName qname = new XPathParser.QName("", "");
if (PeekChar() == ':' && PeekChar(2) != ':')
{
AdvanceChar();
ConsumeToken();
AdvanceChar();
if (XPathCharTypes.IsNCNameStart(this.ch))
{
// It's a full QName
for (; XPathCharTypes.IsNCName(PeekChar()); AdvanceChar());
id = XPathTokenID.NameTest;
qname = new XPathParser.QName(name1, this.CurrentSubstring());
}
else if (this.ch == '*')
{
// We've got a wildcard
id = XPathTokenID.NameWildcard;
qname = new XPathParser.QName(name1, QueryDataModel.Wildcard);
}
else
{
ThrowError(QueryCompileError.InvalidNCName, this.ch == char.MinValue ? "" : CurrentSubstring());
}
}
else
{
// It's a name test without a prefix
id = XPathTokenID.NameTest;
qname = new XPathParser.QName(string.Empty, name1);
}
// Handle special cases
ConsumeWhitespace();
if (IsSpecialPrev())
{
// If we're in the the first special case of the lexer, a qname MUST
// be a NamedOperator
token.Set(GetNamedOperator(qname));
return;
}
else if (qname.Prefix.Length == 0)
{
if (this.PeekChar() == '(')
{
// An NCName followed by a '(' MUST be eiter a node type or function name
id = GetNodeTypeOrFunction(qname);
if (id != XPathTokenID.Function)
{
token.Set(id);
}
else
{
token.Set(id, qname);
}
}
else if (this.PeekChar() == ':' && this.PeekChar(2) == ':')
{
// An NCName followed by a '::' MUST be an axis
token.Set(GetAxisName(qname));
}
else
{
token.Set(id, qname);
}
}
else
{
if (this.PeekChar() == '(')
{
id = XPathTokenID.Function;
}
token.Set(id, qname);
}
}
private XPathParser.QName GetQName()
{
string name1 = GetNCName();
// Return an empty QName if we can't read one
if (name1 == null)
{
return new XPathParser.QName(string.Empty, string.Empty);
}
// Pull the '$' off a variable
if (name1[0] == '$')
{
name1 = name1.Substring(1);
}
// See if there's a second part to the QName
if (PeekChar() == ':' && XPathCharTypes.IsNCNameStart(PeekChar(2)))
{
AdvanceChar();
ConsumeToken();
return new XPathParser.QName(name1, GetNCName());
}
else
{
return new XPathParser.QName(string.Empty, name1);
}
}
private string GetNCName()
{
// Make sure we're starting an NCName
if (XPathCharTypes.IsNCNameStart(PeekChar()))
{
AdvanceChar();
// Read all the NCName characters
for (; XPathCharTypes.IsNCName(PeekChar()); AdvanceChar());
// Extract, consume, and return the NCName
string name = CurrentSubstring();
ConsumeToken();
return name;
}
else
{
return null;
}
}
private void TokenizeNumber()
{
XPathTokenID id = XPathTokenID.Integer;
// Read all the digits
for (; XPathCharTypes.IsDigit(this.ch); AdvanceChar());
if (this.ch == '.')
{
AdvanceChar();
if (XPathCharTypes.IsDigit(this.ch))
{
id = XPathTokenID.Decimal;
// Read all the digits after the decimal point
for (; XPathCharTypes.IsDigit(this.ch); AdvanceChar());
}
}
PutbackChar();
// The converted double
double d = QueryValueModel.Double(CurrentSubstring());
// flip the sign if we're negative
token.Set(id, d);
}
private void TokenizeLiteral(char c)
{
// Consume the opening quote
ConsumeToken();
// Advance over all characters that are not the closing quote
AdvanceChar();
while (this.ch != c)
{
// Watch for an unclosed literal
if (this.ch == char.MinValue)
{
PutbackChar();
ThrowError(QueryCompileError.InvalidLiteral, CurrentSubstring());
}
AdvanceChar();
}
// Put back the closing quote
PutbackChar();
// Grab the literal string
token.Set(XPathTokenID.Literal, CurrentSubstring());
// Read the closing quote
AdvanceChar();
}
private bool IsSpecialPrev()
{
// The first lexer special case is when there was a previous token and it
// wasn't '@', '::', '(', '[', ',', an operator, or a named operator
return (this.previousID != XPathTokenID.Unknown) &&
(this.previousID != XPathTokenID.AtSign) &&
(this.previousID != XPathTokenID.DblColon) &&
(this.previousID != XPathTokenID.LParen) &&
(this.previousID != XPathTokenID.LBracket) &&
(this.previousID != XPathTokenID.Comma) &&
(this.previousID & XPathTokenID.Operator) == 0 &&
(this.previousID & XPathTokenID.NamedOperator) == 0;
}
private XPathTokenID GetNamedOperator(XPathParser.QName qname)
{
// Named operators can't have prefixes
if (qname.Prefix.Length != 0)
{
ThrowError(QueryCompileError.InvalidOperatorName, qname.Prefix + ":" + qname.Name);
}
// Make sure the type is 'NamedOperator'
XPathTokenID id = GetNamedType(qname.Name);
if (this.resolveKeywords && (id & XPathTokenID.NamedOperator) == 0)
{
ThrowError(QueryCompileError.UnsupportedOperator, this.previousID.ToString() + "->" + qname.Name);
}
return id;
}
private XPathTokenID GetAxisName(XPathParser.QName qname)
{
// Axes can't have prefixes
if (qname.Prefix.Length != 0)
{
ThrowError(QueryCompileError.InvalidAxisSpecifier, qname.Prefix + ":" + qname.Name);
}
// Make sure the type is 'Axis'
XPathTokenID id = GetNamedType(qname.Name);
if (this.resolveKeywords && (id & XPathTokenID.Axis) == 0)
{
ThrowError(QueryCompileError.UnsupportedAxis, qname.Name);
}
return id;
}
private XPathTokenID GetNodeTypeOrFunction(XPathParser.QName qname)
{
XPathTokenID id = GetNamedType(qname.Name);
// If it's not a node type, it's lexed as a function
if ((id & XPathTokenID.NodeType) == 0)
{
id = XPathTokenID.Function;
}
else if (qname.Prefix.Length > 0)
{
// Node types don't have prefixes
ThrowError(QueryCompileError.InvalidNodeType, qname.Prefix + ":" + qname.Name);
}
return id;
}
private XPathTokenID GetNamedType(string name)
{
// Get the named type if one exists
if (this.resolveKeywords && namedTypes.ContainsKey(name))
{
return (XPathTokenID)namedTypes[name];
}
else
{
return XPathTokenID.Unknown;
}
}
private void ThrowError(QueryCompileError err, string msg)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new QueryCompileException(err, msg));
}
}
}