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); }