// argument is uri, not an xml fragment.
internal XmlTextReader (bool dummy, XmlResolver resolver, string url, XmlNodeType fragType, XmlParserContext context)
{
- if (resolver == null)
+ if (resolver == null) {
+#if MOONLIGHT
+ resolver = new XmlXapResolver ();
+#else
resolver = new XmlUrlResolver ();
-
+#endif
+ }
this.XmlResolver = resolver;
string uriString;
Stream stream = GetStreamFromUrl (url, out uriString);
private Stream GetStreamFromUrl (string url, out string absoluteUriString)
{
+#if NET_2_1
+ if (url == null)
+ throw new ArgumentNullException ("url");
+ if (url.Length == 0)
+ throw new ArgumentException ("url");
+#endif
Uri uri = resolver.ResolveUri (null, url);
absoluteUriString = uri != null ? uri.ToString () : String.Empty;
return resolver.GetEntity (uri, null, typeof (Stream)) as Stream;
get { return readState == ReadState.EndOfFile; }
}
-#if !NET_2_1
public override bool HasValue {
get { return cursorToken.Value != null; }
}
-#endif
public override bool IsDefault {
// XmlTextReader does not expand default attributes.
}
public override XmlNameTable NameTable {
- get { return parserContext.NameTable; }
+ get { return nameTable; }
}
public override XmlNodeType NodeType {
#if NET_2_0
public IDictionary<string, string> GetNamespacesInScope (XmlNamespaceScope scope)
{
- return parserContext.NamespaceManager.GetNamespacesInScope (scope);
+ return nsmgr.GetNamespacesInScope (scope);
}
IDictionary<string, string> IXmlNamespaceResolver.GetNamespacesInScope (XmlNamespaceScope scope)
private string LookupNamespace (string prefix, bool atomizedNames)
{
- string s = parserContext.NamespaceManager.LookupNamespace (
+ string s = nsmgr.LookupNamespace (
prefix, atomizedNames);
return s == String.Empty ? null : s;
}
public string LookupPrefix (string ns, bool atomizedName)
{
- return parserContext.NamespaceManager.LookupPrefix (ns, atomizedName);
+ return nsmgr.LookupPrefix (ns, atomizedName);
}
#endif
curNodePeekIndex = peekCharsIndex;
preserveCurrentTag = true;
nestLevel = 0;
+ ClearValueBuffer ();
if (startNodeType == XmlNodeType.Attribute) {
if (currentAttribute == 0)
return more;
}
-#if !NET_2_1
public override bool ReadAttributeValue ()
{
if (readState == ReadState.Initial && startNodeType == XmlNodeType.Attribute) {
else
return false;
}
-#endif
public int ReadBase64 (byte [] buffer, int offset, int length)
{
Clear ();
}
-#if !NET_2_1
public override void ResolveEntity ()
{
// XmlTextReader does not resolve entities.
throw new InvalidOperationException ("XmlTextReader cannot resolve external entities.");
}
-#endif
#if NET_2_0
[MonoTODO] // FIXME: Implement, for performance improvement
internal void FillXmlns ()
{
if (Object.ReferenceEquals (Prefix, XmlNamespaceManager.PrefixXmlns))
- Reader.parserContext.NamespaceManager.AddNamespace (LocalName, Value);
+ Reader.nsmgr.AddNamespace (LocalName, Value);
else if (Object.ReferenceEquals (Name, XmlNamespaceManager.PrefixXmlns))
- Reader.parserContext.NamespaceManager.AddNamespace (String.Empty, Value);
+ Reader.nsmgr.AddNamespace (String.Empty, Value);
}
internal void FillNamespace ()
private int attributeCount;
private XmlParserContext parserContext;
+ private XmlNameTable nameTable;
+ private XmlNamespaceManager nsmgr;
private ReadState readState;
private bool disallowReset;
// These values are never re-initialized.
private bool namespaces = true;
private WhitespaceHandling whitespaceHandling = WhitespaceHandling.All;
+#if MOONLIGHT
+ private XmlResolver resolver = new XmlXapResolver ();
+#else
private XmlResolver resolver = new XmlUrlResolver ();
+#endif
private bool normalization = false;
private bool checkCharacters;
String.Empty,
XmlSpace.None);
}
+ nameTable = parserContext.NameTable;
+ nameTable = nameTable != null ? nameTable : new NameTable ();
+ nsmgr = parserContext.NamespaceManager;
+ nsmgr = nsmgr != null ? nsmgr : new XmlNamespaceManager (nameTable);
if (url != null && url.Length > 0) {
+#if NET_2_1
+ Uri uri = new Uri (url, UriKind.RelativeOrAbsolute);
+#else
Uri uri = null;
try {
+#if NET_2_0
+ uri = new Uri (url, UriKind.RelativeOrAbsolute);
+#else
uri = new Uri (url);
+#endif
} catch (Exception) {
string path = Path.GetFullPath ("./a");
uri = new Uri (new Uri (path), url);
}
+#endif
parserContext.BaseURI = uri.ToString ();
}
private bool ReadContent ()
{
if (popScope) {
- parserContext.NamespaceManager.PopScope ();
+ nsmgr.PopScope ();
parserContext.PopScope ();
popScope = false;
}
throw NotWFError ("Multiple document element was detected.");
currentState = XmlNodeType.Element;
- parserContext.NamespaceManager.PushScope ();
+ nsmgr.PushScope ();
currentLinkedNodeLineNumber = line;
currentLinkedNodeLinePosition = column;
if (prefix.Length > 0)
currentToken.NamespaceURI = LookupNamespace (prefix, true);
else if (namespaces)
- currentToken.NamespaceURI = parserContext.NamespaceManager.DefaultNamespace;
+ currentToken.NamespaceURI = nsmgr.DefaultNamespace;
if (namespaces) {
if (NamespaceURI == null)
if (expected.Prefix.Length > 0)
currentToken.NamespaceURI = LookupNamespace (expected.Prefix, true);
else if (namespaces)
- currentToken.NamespaceURI = parserContext.NamespaceManager.DefaultNamespace;
+ currentToken.NamespaceURI = nsmgr.DefaultNamespace;
popScope = true;
private void AppendValueChar (int ch)
{
- if (ch < Char.MaxValue)
+ if (ch <= Char.MaxValue)
valueBuffer.Append ((char) ch);
else
AppendSurrogatePairValueChar (ch);
// FIXME: it might be optimized by the JIT later,
// AppendValueChar (ch);
{
- if (ch < Char.MaxValue)
+ if (ch <= Char.MaxValue)
valueBuffer.Append ((char) ch);
else
AppendSurrogatePairValueChar (ch);
{
IncrementAttributeToken ();
XmlAttributeTokenInfo ati = attributeTokens [currentAttribute];
- ati.Name = parserContext.NameTable.Add (name);
+ ati.Name = NameTable.Add (name);
ati.Prefix = String.Empty;
ati.NamespaceURI = String.Empty;
IncrementAttributeValueToken ();
#if NET_2_0
if (entityHandling == EntityHandling.ExpandEntities) {
string value = DTD.GenerateEntityAttributeText (entName);
- foreach (char c in value)
+ foreach (char c in (IEnumerable<char>) value)
AppendValueChar (c);
} else
#endif
// FIXME: it might be optimized by the JIT later,
// AppendValueChar (ch);
{
- if (ch < Char.MaxValue)
+ if (ch <= Char.MaxValue)
valueBuffer.Append ((char) ch);
else
AppendSurrogatePairValueChar (ch);
// FIXME: it might be optimized by the JIT later,
// AppendValueChar (ch);
{
- if (ch < Char.MaxValue)
+ if (ch <= Char.MaxValue)
valueBuffer.Append ((char) ch);
else
AppendSurrogatePairValueChar (ch);
int start = curNodePeekIndex + startOffset;
- string name = parserContext.NameTable.Add (
+ string name = NameTable.Add (
peekChars, start, length);
if (colonAt > 0) {
- prefix = parserContext.NameTable.Add (
+ prefix = NameTable.Add (
peekChars, start, colonAt);
- localName = parserContext.NameTable.Add (
+ localName = NameTable.Add (
peekChars, start + colonAt + 1, length - colonAt - 1);
} else {
prefix = String.Empty;
// AppendNameChar (ch);
{
// nameBuffer.Length is always non-0 so no need to ExpandNameCapacity () here
- if (ch < Char.MaxValue)
+ if (ch <= Char.MaxValue)
nameBuffer [nameLength++] = (char) ch;
else
AppendSurrogatePairNameChar (ch);
{
if (nameLength == nameCapacity)
ExpandNameCapacity ();
- if (ch < Char.MaxValue)
+ if (ch <= Char.MaxValue)
nameBuffer [nameLength++] = (char) ch;
else
AppendSurrogatePairNameChar (ch);
}
}
- string name = parserContext.NameTable.Add (nameBuffer, 0, nameLength);
+ string name = NameTable.Add (nameBuffer, 0, nameLength);
if (colonAt > 0) {
- prefix = parserContext.NameTable.Add (nameBuffer, 0, colonAt);
- localName = parserContext.NameTable.Add (nameBuffer, colonAt + 1, nameLength - colonAt - 1);
+ prefix = NameTable.Add (nameBuffer, 0, colonAt);
+ localName = NameTable.Add (nameBuffer, colonAt + 1, nameLength - colonAt - 1);
} else {
prefix = String.Empty;
localName = name;
return i;
default:
Advance (c);
- if (c < Char.MaxValue)
+ if (c <= Char.MaxValue)
buffer [bufIndex++] = (char) c;
else {
buffer [bufIndex++] = (char) ((c - 0x10000) / 0x400 + 0xD800);
projects / mono.git / blobdiff