mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
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
1056 lines
42 KiB
C#
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));
|
|
}
|
|
}
|
|
}
|