void EmitNamespace(NamespaceDeclaration namespaceDeclaration)
{
// Write the namespace, filtering for duplicates in the local assembly because VS might be using it to compile itself.
if (schemaContext.IsClrNamespaceWithNoAssembly(namespaceDeclaration.Namespace))
{
// Might still need to trim a semicolon, even though it shouldn't strictly be there.
string nonassemblyQualifedNamespace = namespaceDeclaration.Namespace;
if (nonassemblyQualifedNamespace[nonassemblyQualifedNamespace.Length - 1] == ';')
{
nonassemblyQualifedNamespace = nonassemblyQualifedNamespace.Substring(0, nonassemblyQualifedNamespace.Length - 1);
namespaceDeclaration = new NamespaceDeclaration(nonassemblyQualifedNamespace, namespaceDeclaration.Prefix);
}
EmitLocalNamespace(namespaceDeclaration);
}
else if (schemaContext.IsClrNamespaceInLocalAssembly(namespaceDeclaration.Namespace))
{
string nonassemblyQualifedNamespace = schemaContext.TrimLocalAssembly(namespaceDeclaration.Namespace);
namespaceDeclaration = new NamespaceDeclaration(nonassemblyQualifedNamespace, namespaceDeclaration.Prefix);
if (this.localNamespacesWithAssemblyInfo == null)
{
this.localNamespacesWithAssemblyInfo = new List<NamespaceDeclaration>();
}
this.localNamespacesWithAssemblyInfo.Add(namespaceDeclaration);
}
else
{
base.WriteNamespace(namespaceDeclaration);
}
}
public override void WriteNamespace(NamespaceDeclaration namespaceDeclaration)
{
if (this.currentDepth == 0)
{
//we need to track every namespace alias appeared in root element to figure out right alias for MC namespace
this.rootLevelNamespaces.Add(namespaceDeclaration.Prefix);
//Remember namespaces needed to be ignored at top level so we will add ignore attribute for them when we write start object
if (NameSpaces.ShouldIgnore(namespaceDeclaration.Namespace))
{
this.namespacesToIgnore.Add(namespaceDeclaration.Prefix);
}
if (namespaceDeclaration.Namespace == NameSpaces.DebugSymbol)
{
debugSymbolNamespaceAdded = true;
}
}
EmitNamespace(namespaceDeclaration);
}
public override void WriteNamespace(NamespaceDeclaration namespaceDeclaration)
{
if (_namespaces == null)
{
_namespaces = new List<XamlDomNamespace>();
}
var nsNode = new XamlDomNamespace(namespaceDeclaration);
nsNode.StartLineNumber = _lineNumber;
nsNode.StartLinePosition = _linePosition;
nsNode.EndLineNumber = _lineNumber;
nsNode.EndLinePosition = _linePosition;
_namespaces.Add(nsNode);
}
public override void WriteNamespace(NamespaceDeclaration namespaceDeclaration)
{
this.currentState.WriteNamespace(this, namespaceDeclaration);
}
public override void WriteNamespace (NamespaceDeclaration namespaceDeclaration)
{
intl.WriteNamespace (namespaceDeclaration);
}
protected abstract void OnWriteNamespace (NamespaceDeclaration nd);
void EmitLocalNamespace(NamespaceDeclaration namespaceDeclaration)
{
if (this.emittedNamespacesInLocalAssembly == null) // lazy initialization
{
this.emittedNamespacesInLocalAssembly = new HashSet<string>();
}
// Write the namespace only once. Add() returns false if it was already there.
if (this.emittedNamespacesInLocalAssembly.Add(namespaceDeclaration.Namespace))
{
base.WriteNamespace(namespaceDeclaration);
}
}
public abstract void WriteNamespace(NamespaceDeclaration namespaceDeclaration);
public override void WriteNamespace(NamespaceDeclaration namespaceDeclaration)
{
if (this.notRewriting)
{
this.innerWriter.WriteNamespace(namespaceDeclaration);
return;
}
if (this.namespaceTable != null)
{
this.namespaceTable.AddNamespace(namespaceDeclaration);
}
this.currentState.WriteNamespace(namespaceDeclaration);
}
void DoWriteNamespace (NamespaceDeclaration nd)
{
if (String.IsNullOrEmpty (nd.Prefix))
w.WriteAttributeString ("xmlns", nd.Namespace);
else
w.WriteAttributeString ("xmlns", nd.Prefix, XamlLanguage.Xmlns2000Namespace, nd.Namespace);
}
public override void WriteNamespace (NamespaceDeclaration namespaceDeclaration)
{
if (namespaceDeclaration == null)
throw new ArgumentNullException ("namespaceDeclaration");
manager.Namespace ();
nodes.Push (namespaceDeclaration);
}
public virtual void WriteNamespace(XamlMarkupExtensionWriter writer, NamespaceDeclaration namespaceDeclaration)
{
writer.failed = true;
}
public override void WriteNamespace(NamespaceDeclaration namespaceDeclaration)
{
this.currentState.WriteNamespace(this, namespaceDeclaration);
}
protected abstract void OnWriteNamespace(NamespaceDeclaration nd);
public XamlNodeInfo(NamespaceDeclaration ns)
{
NodeType = XamlNodeType.NamespaceDeclaration;
Value = ns;
}
public override void WriteNamespace (NamespaceDeclaration ns)
{
source.Queue.Enqueue (new XamlNodeInfo (ns));
}
public override void WriteNamespace(NamespaceDeclaration namespaceDeclaration)
{
this.ThrowIfDisposed();
if (namespaceDeclaration == null)
{
throw new ArgumentNullException("namespaceDeclaration");
}
if (namespaceDeclaration.Prefix == null)
{
throw new ArgumentException(System.Xaml.SR.Get("NamespaceDeclarationPrefixCannotBeNull"));
}
if (namespaceDeclaration.Namespace == null)
{
throw new ArgumentException(System.Xaml.SR.Get("NamespaceDeclarationNamespaceCannotBeNull"));
}
this._deferringWriter.WriteNamespace(namespaceDeclaration);
if (!this._deferringWriter.Handled)
{
if (this._nextNodeMustBeEndMember)
{
string message = System.Xaml.SR.Get("ValueMustBeFollowedByEndMember");
throw this.WithLineInfo(new XamlObjectWriterException(message));
}
if ((this._context.CurrentType != null) && (this._context.CurrentProperty == null))
{
string str2 = System.Xaml.SR.Get("NoPropertyInCurrentFrame_NS", new object[] { namespaceDeclaration.Prefix, namespaceDeclaration.Namespace, this._context.CurrentType.ToString() });
throw this.WithLineInfo(new XamlObjectWriterException(str2));
}
if (this._context.CurrentType != null)
{
this._context.PushScope();
}
this._context.AddNamespacePrefix(namespaceDeclaration.Prefix, namespaceDeclaration.Namespace);
}
}
protected internal virtual void WriteNamespace(NamespaceDeclaration namespaceDeclaration)
{
CurrentWriter.WriteNamespace(namespaceDeclaration);
}
public XamlNamespaceDeclarationNode(NamespaceDeclaration @namespace)
{
this.Namespace = @namespace;
}
protected internal override void WriteNamespace(NamespaceDeclaration namespaceDeclaration)
{
if (Writer.currentDepth == 0 && !this.wroteXamlNamespace)
{
if (namespaceDeclaration.Namespace == XamlLanguage.Xaml2006Namespace)
{
this.wroteXamlNamespace = true;
}
else
{
if (this.rootLevelPrefixes == null)
{
this.rootLevelPrefixes = new HashSet<string>();
}
this.rootLevelPrefixes.Add(namespaceDeclaration.Prefix);
}
}
base.WriteNamespace(namespaceDeclaration);
}
public override void WriteNamespace(NamespaceDeclaration namespaceDeclaration)
{
this.ThrowIsDisposed();
this._addDelegate(XamlNodeType.NamespaceDeclaration, namespaceDeclaration);
}
// (prefix, namespaceUri)
private void Process_XmlnsProperty()
{
Debug.Assert(_context.CurrentFrame.XamlType != null, "BAML Xmlns record is only legal between ElementStart and ElementEnd");
Read_RecordSize();
string prefix = _binaryReader.ReadString();
string xamlNs = _binaryReader.ReadString();
xamlNs = Logic_GetFullXmlns(xamlNs);
_context.CurrentFrame.AddNamespace(prefix, xamlNs);
NamespaceDeclaration namespaceDeclaration = new NamespaceDeclaration(xamlNs, prefix);
_xamlNodesWriter.WriteNamespace(namespaceDeclaration);
// Record format:
// num of records : short
// assemblyId : short
// ...
// assemblyId : short
short recordSize = _binaryReader.ReadInt16();
if (xamlNs.StartsWith(XamlReaderHelper.MappingProtocol, StringComparison.Ordinal))
{
SkipBytes(recordSize * 2); // Each entry is 2 bytes
}
else if (recordSize > 0)
{
short[] assemblies = new short[recordSize];
for (int i = 0; i < recordSize; i++)
{
assemblies[i] = _binaryReader.ReadInt16();
}
BamlSchemaContext.AddXmlnsMapping(xamlNs, assemblies);
}
}
public void WriteNamespace (NamespaceDeclaration namespaceDeclaration)
{
if (namespaceDeclaration == null)
throw new ArgumentNullException ("namespaceDeclaration");
manager.Namespace ();
namespaces.Add (namespaceDeclaration);
OnWriteNamespace (namespaceDeclaration);
}
public override void WriteNamespace(NamespaceDeclaration namespaceDeclaration)
{
throw FxTrace.Exception.AsError(new NotImplementedException());
}
public void Clear()
{
Type = null;
Member = null;
Namespace = null;
NodeType = XamlNodeType.None;
Value = null;
LineNumber = 0;
LinePosition = 0;
}
void WritestrippedXamlNode(XamlReader reader, XamlWriter writer)
{
switch (reader.NodeType)
{
case XamlNodeType.StartObject:
XamlType xamlType = reader.Type;
if (xamlType.IsUnknown)
{
IList<XamlType> typeArgs = UpdateTypeArgs(xamlType.TypeArguments, reader.SchemaContext);
string xmlns = XamlBuildTaskServices.UpdateClrNamespaceUriWithLocalAssembly(xamlType.PreferredXamlNamespace, this.localAssemblyName);
xamlType = new XamlType(xmlns, xamlType.Name, typeArgs, reader.SchemaContext);
}
writer.WriteStartObject(xamlType);
break;
case XamlNodeType.StartMember:
XamlMember member = reader.Member;
if (member.IsUnknown && !member.IsDirective)
{
string xmlns = XamlBuildTaskServices.UpdateClrNamespaceUriWithLocalAssembly(member.DeclaringType.PreferredXamlNamespace, this.localAssemblyName);
XamlType memberXamlType = new XamlType(xmlns, member.DeclaringType.Name, member.DeclaringType.TypeArguments, reader.SchemaContext);
member = new XamlMember(member.Name, memberXamlType, member.IsAttachable);
}
writer.WriteStartMember(member);
break;
case XamlNodeType.NamespaceDeclaration:
NamespaceDeclaration ns = new NamespaceDeclaration(
XamlBuildTaskServices.UpdateClrNamespaceUriWithLocalAssembly(reader.Namespace.Namespace, this.localAssemblyName),
reader.Namespace.Prefix);
writer.WriteNamespace(ns);
break;
case XamlNodeType.GetObject:
case XamlNodeType.EndObject:
case XamlNodeType.EndMember:
case XamlNodeType.Value:
case XamlNodeType.None:
writer.WriteNode(reader);
break;
default:
Debug.Fail("Unrecognized XamlNodeType value" + reader.NodeType.ToString());
break;
}
}
protected override void OnWriteNamespace (NamespaceDeclaration nd)
{
// nothing to do here.
}
bool CheckNextNamespace ()
{
do {
if (r.NamespaceURI == XamlLanguage.Xmlns2000Namespace) {
current = new NamespaceDeclaration (r.Value, r.Prefix == "xmlns" ? r.LocalName : String.Empty);
node_type = XamlNodeType.NamespaceDeclaration;
return true;
}
} while (r.MoveToNextAttribute ());
return false;
}
public virtual void WriteNamespace(XamlMarkupExtensionWriter writer, NamespaceDeclaration namespaceDeclaration)
{
writer.failed = true;
}
public override void WriteNamespace (NamespaceDeclaration namespaceDeclaration)
{
if (namespaceDeclaration == null)
throw new ArgumentNullException ("namespaceDeclaration");
manager.Namespace ();
// FIXME: find out what to do.
}
public static void WriteNamespace(this XamlWriter writer, NamespaceDeclaration namespaceDeclaration, IXamlLineInfo lineInfo)
{
PropagateLineInfo(writer, lineInfo);
writer.WriteNamespace(namespaceDeclaration);
}
// We need to special-case the XML namespace because it is always in scope,
// but can't actually be written to XML.
static bool IsXmlNamespace(NamespaceDeclaration namespaceDecl)
{
return namespaceDecl.Prefix == xmlPrefix && namespaceDecl.Namespace == XamlLanguage.Xml1998Namespace;
}
public void AddNamespace(NamespaceDeclaration xamlNamespace)
{
this.tempNamespaceList.Add(xamlNamespace);
this.namespacesCache = null;
}
public override void WriteNamespace(NamespaceDeclaration namespaceDeclaration)
{
if (m_attachedPropertyDepth > 0)
{
return;
}
InnerWriter.WriteNamespace(namespaceDeclaration);
}
public override void WriteNamespace(NamespaceDeclaration namespaceDeclaration)
{
if (namespaceDeclaration.Prefix == "x")
{
this.xamlLanguageNamespaceWritten = true;
}
this.underlyingWriter.WriteNamespace(namespaceDeclaration);
}
public override void WriteNamespace(NamespaceDeclaration namespaceDeclaration)
{
ThrowIsDisposed();
_addDelegate(XamlNodeType.NamespaceDeclaration, namespaceDeclaration);
}
