private IEnumerable <XamlNode> ReadMemberNode(XamlDomMember memberNode) { if (memberNode.Items != null && memberNode.Items.Count > 0) { yield return(XamlNode.GetStartMember(memberNode)); foreach (var itemNode in memberNode.Items) { var objectNode = itemNode as XamlDomObject; IEnumerable <XamlNode> enumerable; if (objectNode != null) { enumerable = ReadObjectNode(objectNode); } else { enumerable = ReadValueNode(itemNode as XamlDomValue); } foreach (var node in enumerable) { yield return(node); } } yield return(XamlNode.GetEndMember(memberNode)); } }
public void WriteNode(XamlNode node) { Guard.ThrowIfNull(node, nameof(node)); switch (node.NodeType) { case XamlNodeType.None: break; case XamlNodeType.StartObject: startObjectWriter.WriteStartObject(node.XamlType); break; case XamlNodeType.EndObject: WriteEndObject(); break; case XamlNodeType.StartMember: startMemberWriter.WriteStartMember(node.Member); break; case XamlNodeType.EndMember: WriteEndMember(); break; case XamlNodeType.Value: valueWriter.WriteValue(node.Value); break; case XamlNodeType.GetObject: getObjectWriter.WriteGetObject(); break; case XamlNodeType.NamespaceDeclaration: WriteNamespace(node.NamespaceDeclaration); break; default: throw new InvalidOperationException($"Cannot handle this kind of node type: {node.NodeType}"); } }
// =================== Logic Functions ======================== private XamlNode Logic_LineInfo() { LineInfo lineInfo = new LineInfo(LineNumber, LinePosition); XamlNode lineInfoNode = new XamlNode(lineInfo); return(lineInfoNode); }
public void Process(XamlNode node) { Command command; switch (node.NodeType) { case XamlNodeType.NamespaceDeclaration: command = new NamespaceDeclarationCommand(this, node.NamespaceDeclaration); break; case XamlNodeType.StartObject: command = new StartObjectCommand(this, node.XamlType, rootInstance); break; case XamlNodeType.StartMember: command = new StartMemberCommand(this, GetMember(node.Member)); break; case XamlNodeType.Value: command = new ValueCommand(this, (string)node.Value); break; case XamlNodeType.EndObject: command = new EndObjectCommand(this); break; case XamlNodeType.EndMember: command = new EndMemberCommand(this, topDownMemberValueContext); break; case XamlNodeType.GetObject: command = new GetObjectCommand(this); break; default: throw new InvalidOperationException(); } command.Execute(); }
private XamlNode Logic_Text() { string text = _tokenizer.TokenText; XamlNode textNode = new XamlNode(XamlNodeType.Value, text); return(textNode); }
public IEnumerable <XamlNode> P_StartElement() { if (this._xamlScanner.NodeType != ScannerNodeType.ELEMENT) { throw new XamlUnexpectedParseException(this._xamlScanner, this._xamlScanner.NodeType, System.Xaml.SR.Get("StartElementRuleException")); } yield return(this.Logic_StartObject(this._xamlScanner.Type, this._xamlScanner.Namespace)); this._xamlScanner.Read(); if (this.ProvideLineInfo) { yield return(this.Logic_LineInfo()); } while (this._xamlScanner.NodeType == ScannerNodeType.DIRECTIVE) { IEnumerator <XamlNode> enumerator = this.LogicStream_Attribute().GetEnumerator(); while (enumerator.MoveNext()) { XamlNode current = enumerator.Current; yield return(current); } this._xamlScanner.Read(); if (this.ProvideLineInfo) { yield return(this.Logic_LineInfo()); } } }
private IEnumerable <XamlNode> LogicStream_Attribute() { XamlMember propertyAttribute = this._xamlScanner.PropertyAttribute; XamlText propertyAttributeText = this._xamlScanner.PropertyAttributeText; if (this._xamlScanner.IsCtorForcingMember) { this._context.CurrentForcedToUseConstructor = true; } XamlNode iteratorVariable2 = new XamlNode(XamlNodeType.StartMember, propertyAttribute); yield return(iteratorVariable2); if (propertyAttributeText.LooksLikeAMarkupExtension) { MePullParser iteratorVariable3 = new MePullParser(this._context); foreach (XamlNode iteratorVariable4 in iteratorVariable3.Parse(propertyAttributeText.Text, this.LineNumber, this.LinePosition)) { yield return(iteratorVariable4); } } else { XamlNode iteratorVariable5 = new XamlNode(XamlNodeType.Value, propertyAttributeText.AttributeText); yield return(iteratorVariable5); } yield return(new XamlNode(XamlNodeType.EndMember)); }
public IEnumerable <XamlNode> P_PropertyElement() { ScannerNodeType nodeType = this._xamlScanner.NodeType; switch (nodeType) { case ScannerNodeType.PROPERTYELEMENT: { IEnumerator <XamlNode> enumerator = this.P_NonemptyPropertyElement().GetEnumerator(); while (enumerator.MoveNext()) { XamlNode current = enumerator.Current; yield return(current); } break; } default: throw new XamlUnexpectedParseException(this._xamlScanner, nodeType, System.Xaml.SR.Get("PropertyElementRuleException")); foreach (XamlNode iteratorVariable1 in this.P_EmptyPropertyElement()) { yield return(iteratorVariable1); } break; } }
/// <summary> /// It seems like BamlReader will always output 'x:Key' as last property. However, it must be specified as attribute in valid .xaml, so we move it to the front /// of the attribute list. /// </summary> void MoveXKeyToFront(XamlNode node) { foreach (XamlNode child in node.Children) { MoveXKeyToFront(child); } XamlObjectNode obj = node as XamlObjectNode; if (obj != null && obj.Children.Count > 0) { XamlMemberNode memberNode = obj.Children[obj.Children.Count - 1] as XamlMemberNode; if (memberNode != null && memberNode.Member == XamlLanguage.Key) { // move memberNode in front of the first member node: for (int i = 0; i < obj.Children.Count; i++) { if (obj.Children[i] is XamlMemberNode) { obj.Children.Insert(i, memberNode); obj.Children.RemoveAt(obj.Children.Count - 1); break; } } } } }
private IEnumerable <XamlNode> LogicStream_Attribute() { XamlMember property = _xamlScanner.PropertyAttribute; XamlText text = _xamlScanner.PropertyAttributeText; if (_xamlScanner.IsCtorForcingMember) { _context.CurrentForcedToUseConstructor = true; } XamlNode startProperty = new XamlNode(XamlNodeType.StartMember, property); yield return(startProperty); if (text.LooksLikeAMarkupExtension) { MePullParser me = new MePullParser(_context); foreach (XamlNode node in me.Parse(text.Text, LineNumber, LinePosition)) { yield return(node); } } else { XamlNode textNode = new XamlNode(XamlNodeType.Value, text.AttributeText); yield return(textNode); } yield return(new XamlNode(XamlNodeType.EndMember)); }
private XamlNode Logic_StartPositionalParameters() { _context.CurrentMember = XamlLanguage.PositionalParameters; XamlNode startProperty = new XamlNode(XamlNodeType.StartMember, XamlLanguage.PositionalParameters); return(startProperty); }
/// <summary> /// Convert from Xaml read by a token reader into baml being written /// out by a record writer. The context gives mapping information. /// </summary> #if !PBTCOMPILER //CASRemoval:[StrongNameIdentityPermission(SecurityAction.InheritanceDemand, PublicKey = Microsoft.Internal.BuildInfo.WCP_PUBLIC_KEY_STRING)] #endif internal virtual void ConvertXamlToBaml ( XamlReaderHelper tokenReader, ParserContext context, XamlNode xamlNode, BamlRecordWriter bamlWriter) { throw new InvalidOperationException(SR.Get(SRID.InvalidDeSerialize)); }
/// <summary> /// Convert from Xaml read by a token reader into baml being written /// out by a record writer. The context gives mapping information. /// </summary> #if !PBTCOMPILER //CASRemoval:[StrongNameIdentityPermission(SecurityAction.InheritanceDemand, PublicKey = Microsoft.Internal.BuildInfo.WCP_PUBLIC_KEY_STRING)] #endif internal virtual void ConvertXamlToBaml( XamlReaderHelper tokenReader, ParserContext context, XamlNode xamlNode, BamlRecordWriter bamlWriter) { throw new InvalidOperationException(SR.Get(SRID.InvalidDeSerialize)); }
public ReaderDelegate(XamlSchemaContext schemaContext, XamlNodeNextDelegate next, bool hasLineInfo) : base(schemaContext) { _nextDelegate = next; _currentNode = new XamlNode(XamlNode.InternalNodeType.StartOfStream); _currentLineInfo = null; _hasLineInfo = hasLineInfo; }
private XamlNode Logic_PrefixDefinition() { string prefix = _xamlScanner.Prefix; string xamlNs = _xamlScanner.Namespace; XamlNode addNs = new XamlNode(XamlNodeType.NamespaceDeclaration, new NamespaceDeclaration(xamlNs, prefix)); return(addNs); }
private void Initialize(XmlReader givenXmlReader, XamlSchemaContext schemaContext, XamlTextReaderSettings settings) { XmlReader myXmlReader; if (givenXmlReader == null) { throw new ArgumentNullException("XmlReader is null"); } _mergedSettings = (settings == null) ? new XamlTextReaderSettings() : new XamlTextReaderSettings(settings); //Wrap the xmlreader with a XmlCompatReader instance to apply MarkupCompat rules. if (!_mergedSettings.SkipXmlCompatibilityProcessing) { XmlCompatibilityReader mcReader = new XmlCompatibilityReader(givenXmlReader, new IsXmlNamespaceSupportedCallback(IsXmlNamespaceSupported) ); myXmlReader = mcReader; } else { // Don't wrap the xmlreader with XmlCompatReader. // Useful for uses where users want to keep mc: content in the XamlNode stream. // Or have already processed the markup compat and want that extra perf. // We need to go make sure the parser thinks it knows mc: uri, // in case SkipXmlCompatibilityProcessing is true... likely won't work yet. myXmlReader = givenXmlReader; } // Pick up the XmlReader settings to override the "settings" defaults. if (!String.IsNullOrEmpty(myXmlReader.BaseURI)) { _mergedSettings.BaseUri = new Uri(myXmlReader.BaseURI); } if (myXmlReader.XmlSpace == XmlSpace.Preserve) { _mergedSettings.XmlSpacePreserve = true; } if (!String.IsNullOrEmpty(myXmlReader.XmlLang)) { _mergedSettings.XmlLang = myXmlReader.XmlLang; } if (schemaContext == null) { schemaContext = new XamlSchemaContext(); } _endOfStreamNode = new InternalNode(InternalNodeType.EndOfStream); _context = (XamlParserContext)XamlContext.CreateContext(UsageMode.Parser, schemaContext, _mergedSettings.LocalAssembly, false /*ignoreCanConvert*/); XamlScanner xamlScanner = new XamlScanner(_context, myXmlReader, _mergedSettings); XamlPullParser parser = new XamlPullParser(_context, xamlScanner, _mergedSettings); _nodeStream = new NodeStreamSorter(_context, parser, _mergedSettings); _current = _endOfStreamNode; // user must call Read() before using properties. }
/// <summary> /// Convert from Xaml read by a token reader into a live /// object tree. The context gives mapping information. /// </summary> //CASRemoval:[StrongNameIdentityPermission(SecurityAction.InheritanceDemand, PublicKey = Microsoft.Internal.BuildInfo.WCP_PUBLIC_KEY_STRING)] internal virtual void ConvertXamlToObject( XamlReaderHelper tokenReader, ReadWriteStreamManager streamManager, ParserContext context, XamlNode xamlNode, BamlRecordReader reader) { throw new InvalidOperationException(SR.Get(SRID.InvalidDeSerialize)); }
/// <summary> /// Convert from Xaml read by a token reader into a live /// object tree. The context gives mapping information. /// </summary> //CASRemoval:[StrongNameIdentityPermission(SecurityAction.InheritanceDemand, PublicKey = Microsoft.Internal.BuildInfo.WCP_PUBLIC_KEY_STRING)] internal virtual void ConvertXamlToObject ( XamlReaderHelper tokenReader, ReadWriteStreamManager streamManager, ParserContext context, XamlNode xamlNode, BamlRecordReader reader) { throw new InvalidOperationException(SR.Get(SRID.InvalidDeSerialize)); }
public XamlNode GetNextNode() { if (nodeQueue.Count != 0) { XamlNode x = (XamlNode)nodeQueue[0]; nodeQueue.RemoveAt(0); return(x); } while (reader.Read()) { Debug.WriteLine("XamlParser: NOW PARSING: " + reader.NodeType + "; " + reader.Name + "; " + reader.Value); if (goneTooFar()) { throw new XamlParseException(reader.LineNumber, reader.LinePosition, "Too far: " + reader.NodeType + ", " + reader.Name); } if (currentState() != null && currentState().type == CurrentType.Code) { processElementInCodeState(); continue; } switch (reader.NodeType) { case XmlNodeType.ProcessingInstruction: parsePI(); break; case XmlNodeType.Element: parseElement(); break; case XmlNodeType.EndElement: parseEndElement(); break; case XmlNodeType.Text: parseText(); break; case XmlNodeType.Whitespace: case XmlNodeType.Comment: // skip whitespace and comments break; default: throw new XamlParseException(reader.LineNumber, reader.LinePosition, "Unknown element type " + reader.NodeType); } if (nodeQueue.Count != 0) { XamlNode x = (XamlNode)nodeQueue[0]; nodeQueue.RemoveAt(0); return(x); } } return(null); }
private XamlNode Logic_StartObject(XamlType xamlType, string xamlNamespace) { _context.PushScope(); _context.CurrentType = xamlType; _context.CurrentTypeNamespace = xamlNamespace; XamlNode startObj = new XamlNode(XamlNodeType.StartObject, xamlType); return(startObj); }
private XamlNode Logic_StartMember() { XamlMember member = _tokenizer.TokenProperty; _context.CurrentMember = member; XamlNode startMember = new XamlNode(XamlNodeType.StartMember, member); return(startMember); }
private XamlNode Logic_StartItemsProperty(XamlType collectionType) { _context.CurrentMember = XamlLanguage.Items; _context.CurrentInContainerDirective = true; var startProperty = new XamlNode(XamlNodeType.StartMember, XamlLanguage.Items); //SetLineInfo(startProperty); // No line number info for implicit properties. return(startProperty); }
private XamlNode Logic_StartGetObjectFromMember(XamlType realType) { _context.PushScope(); _context.CurrentType = realType; _context.CurrentInCollectionFromMember = true; var startObj = new XamlNode(XamlNodeType.GetObject); return(startObj); }
private XamlNode Logic_StartInitProperty(XamlType ownerType) { var initProperty = XamlLanguage.Initialization; _context.CurrentMember = initProperty; var startProperty = new XamlNode(XamlNodeType.StartMember, initProperty); // SetLineInfo(startProperty); // No line number info for implicit properties. return(startProperty); }
private static bool NodeHasSameType(XamlType oldType, XamlNode node) { var xamlType = node.XamlType; if (xamlType != null) { var nodeHasSameType = xamlType.Equals(oldType); return nodeHasSameType; } return false; }
private XamlNode Logic_EndObject() { XamlType xamlType = _context.CurrentType; _context.PopScope(); _context.CurrentPreviousChildType = xamlType; XamlNode endObj = new XamlNode(XamlNodeType.EndObject); return(endObj); }
private string getKeyFromNode(XamlNode n) { // we know that n is a XamlElementStartNode, but don't need that knowledge if (n is XamlKeyElementStartNode) { return(((XamlKeyElementStartNode)n).key); } else { return(null); } }
private XamlNode Logic_StartContentProperty(XamlMember property) { if (property == null) { property = XamlLanguage.UnknownContent; } _context.CurrentMember = property; var startProperty = new XamlNode(XamlNodeType.StartMember, property); // SetLineInfo(startProperty); // No line number info for objects from members. return(startProperty); }
public override bool Read() { if (_nodeStream.MoveNext()) { _current = _nodeStream.Current; } else { _current = _endOfStreamNode; } return(!IsEof); }
XamlNode getNextNode(object p) { MethodInfo getter = p.GetType().GetMethod("GetNextNode"); Assert.IsTrue(getter != null, "Couldn't get next-node-getter"); try { XamlNode n = (XamlNode)getter.Invoke(p, null); Assert.IsTrue(n != null, "Couldn't get next node"); return(n); } catch (TargetInvocationException ex) { throw ex.InnerException; } }
private IEnumerable <XamlNode> P_MarkupExtension(Found f) { if (this.Expect(MeTokenType.Open, "MarkupExtension ::= @'{' Expr '}'")) { this.NextToken(); if (this._tokenizer.Token != MeTokenType.TypeName) { this.SetBrokenRuleString("MarkupExtension ::= '{' @TYPENAME (Arguments)? '}'"); } else { XamlType tokenType = this._tokenizer.TokenType; yield return(this.Logic_StartElement(tokenType, this._tokenizer.Namespace)); this.NextToken(); Found iteratorVariable1 = new Found(); switch (this._tokenizer.Token) { case MeTokenType.PropertyName: case MeTokenType.String: case MeTokenType.QuotedMarkupExtension: case MeTokenType.Open: { IEnumerator <XamlNode> enumerator = this.P_Arguments(iteratorVariable1).GetEnumerator(); while (enumerator.MoveNext()) { XamlNode current = enumerator.Current; yield return(current); } break; } default: this.SetBrokenRuleString("MarkupExtension ::= '{' TYPENAME @(Arguments)? '}'"); break; yield return(this.Logic_EndObject()); this.NextToken(); f.found = true; break; } if (iteratorVariable1.found && this.Expect(MeTokenType.Close, "MarkupExtension ::= '{' TYPENAME (Arguments)? @'}'")) { yield return(this.Logic_EndObject()); f.found = true; this.NextToken(); } } } }
// ================================================ private XamlNode Logic_StartElement(XamlType xamlType, string xamlNamespace) { _context.PushScope(); _context.CurrentType = xamlType; _context.CurrentTypeNamespace = xamlNamespace; _context.InitLongestConstructor(xamlType); _context.InitBracketCharacterCacheForType(xamlType); _context.CurrentBracketModeParseParameters = new BracketModeParseParameters(_context); var startObj = new XamlNode(XamlNodeType.StartObject, xamlType); return(startObj); }
void RemoveConnectionIds(XamlNode node, Dictionary <int, EventRegistration[]> eventMappings, XamlSchemaContext context) { foreach (XamlNode child in node.Children) { RemoveConnectionIds(child, eventMappings, context); } XamlObjectNode obj = node as XamlObjectNode; if (obj != null && obj.Children.Count > 0) { var removableNodes = new List <XamlMemberNode>(); var addableNodes = new List <XamlMemberNode>(); foreach (XamlMemberNode memberNode in obj.Children.OfType <XamlMemberNode>()) { if (memberNode.Member == XamlLanguage.ConnectionId && memberNode.Children.Single() is XamlValueNode) { var value = memberNode.Children.Single() as XamlValueNode; int id; if (value.Value is string && int.TryParse(value.Value as string, out id) && eventMappings.ContainsKey(id)) { var map = eventMappings[id]; foreach (var entry in map) { if (entry.IsAttached) { var type = context.GetXamlType(Type.GetType(entry.AttachSourceType)); var member = new XamlMemberNode(new XamlMember(entry.EventName, type, true)); member.Children.Add(new XamlValueNode(entry.MethodName)); addableNodes.Add(member); } else { var member = new XamlMemberNode(obj.Type.GetMember(entry.EventName)); member.Children.Add(new XamlValueNode(entry.MethodName)); addableNodes.Add(member); } } removableNodes.Add(memberNode); } } } foreach (var rnode in removableNodes) { node.Children.Remove(rnode); } node.Children.InsertRange(node.Children.Count > 1 ? node.Children.Count - 1 : 0, addableNodes); } }
private XamlNode Logic_StartMember(XamlMember member) { _context.CurrentMember = member; if (_xamlScanner.IsCtorForcingMember) { _context.CurrentForcedToUseConstructor = true; } XamlType memberXamlType = member.Type; _context.CurrentInContainerDirective = member.IsDirective && (memberXamlType != null && (memberXamlType.IsCollection || memberXamlType.IsDictionary)); var startMember = new XamlNode(XamlNodeType.StartMember, member); return(startMember); }
/// <summary> /// Convert from Xaml read by a token reader into baml being written /// out by a record writer. The context gives mapping information. /// </summary> internal override void ConvertXamlToBaml ( XamlReaderHelper tokenReader, ParserContext context, XamlNode xamlNode, BamlRecordWriter bamlWriter) { TemplateXamlParser templateParser = new TemplateXamlParser(tokenReader, context); templateParser.ParserHooks = _parserHooks; templateParser.BamlRecordWriter = bamlWriter; // Process the xamlNode that is passed in so that the <Template> element is written to baml templateParser.WriteElementStart((XamlElementStartNode)xamlNode); // Parse the entire Template section now, writing everything out directly to BAML. templateParser.Parse(); }
/// <summary> /// Convert from Xaml read by a token reader into baml being written /// out by a record writer. The context gives mapping information. /// </summary> internal override void ConvertXamlToBaml( XamlReaderHelper tokenReader, ParserContext context, XamlNode xamlNode, BamlRecordWriter bamlWriter) { TemplateXamlParser templateParser = new TemplateXamlParser(tokenReader, context); templateParser.ParserHooks = _parserHooks; templateParser.BamlRecordWriter = bamlWriter; // Process the xamlNode that is passed in so that the <Template> element is written to baml templateParser.WriteElementStart((XamlElementStartNode)xamlNode); // Parse the entire Template section now, writing everything out directly to BAML. templateParser.Parse(); }
internal override ParserAction LoadNode(XamlNode tokenNode) { switch (tokenNode.TokenType) { case XamlNodeType.DocumentStart : { // A single ParserHooks might be used to parse multiple bamls. // We need to clear the comments list at the begining of each baml. _commentList.Clear(); _currentComment = new LocalizationComment(); return ParserAction.Normal; } case XamlNodeType.DefAttribute : { XamlDefAttributeNode node = (XamlDefAttributeNode) tokenNode; if (node.Name == XamlReaderHelper.DefinitionUid) { _currentComment.Uid = node.Value; } return ParserAction.Normal; } case XamlNodeType.Property : { XamlPropertyNode node = (XamlPropertyNode) tokenNode; // When this parer hook is invoked, comments is always output to a seperate file. if (LocComments.IsLocCommentsProperty(node.TypeFullName, node.PropName)) { // try parse the value. Exception will be thrown if not valid. LocComments.ParsePropertyComments(node.Value); _currentComment.Comments = node.Value; return ParserAction.Skip; // skips outputing this node to baml } if ( _directivesToFile == LocalizationDirectivesToLocFile.All && LocComments.IsLocLocalizabilityProperty(node.TypeFullName, node.PropName)) { // try parse the value. Exception will be thrown if not valid. LocComments.ParsePropertyLocalizabilityAttributes(node.Value); _currentComment.Attributes = node.Value; return ParserAction.Skip; // skips outputing this node to baml } return ParserAction.Normal; } case XamlNodeType.EndAttributes : { FlushCommentToList(ref _currentComment); return ParserAction.Normal; } case XamlNodeType.DocumentEnd : { // // When reaching document end, we output all the comments we have collected // so far into a localization comment file. If the parsing was aborted in // MarkupCompilePass1, we would not out the incomplete set of comments because // it will not reach document end. // if (_commentList.Count > 0) { string absoluteOutputPath = _compiler.TargetPath + _compiler.SourceFileInfo.RelativeSourceFilePath + SharedStrings.LocExtension; MemoryStream memStream = new MemoryStream(); // TaskFileService.WriteFile adds BOM for UTF8 Encoding, thus don't add here // when creating XmlTextWriter. using (XmlTextWriter writer = new XmlTextWriter(memStream, new UTF8Encoding(false))) { // output XML for each piece of comment writer.Formatting = Formatting.Indented; writer.WriteStartElement(LocComments.LocResourcesElement); writer.WriteAttributeString(LocComments.LocFileNameAttribute, _compiler.SourceFileInfo.RelativeSourceFilePath); foreach (LocalizationComment comment in _commentList) { writer.WriteStartElement(LocComments.LocCommentsElement); writer.WriteAttributeString(LocComments.LocCommentIDAttribute, comment.Uid); if (comment.Attributes != null) { writer.WriteAttributeString(LocComments.LocLocalizabilityAttribute, comment.Attributes); } if (comment.Comments != null) { writer.WriteAttributeString(LocComments.LocCommentsAttribute, comment.Comments); } writer.WriteEndElement(); } writer.WriteEndElement(); writer.Flush(); _compiler.TaskFileService.WriteFile(memStream.ToArray(), absoluteOutputPath); } } return ParserAction.Normal; } default: { return ParserAction.Normal; } } }
// Helper to write out the baml record, with line numbers obtained from // the associated xaml node. private void WriteAndReleaseRecord( BamlRecord bamlRecord, XamlNode xamlNode) { int lineNumber = xamlNode != null ? xamlNode.LineNumber : 0; int linePosition = xamlNode != null ? xamlNode.LinePosition : 0; // If we are currently parsing a deferable content section, then queue // up the records for later writing if (_deferLoadingSupport && _deferElementDepth > 0) { if (InStaticResourceSection) { // Gather all the BamlRecords within the StaticResource section _staticResourceRecordList.Add(new ValueDeferRecord(bamlRecord, lineNumber, linePosition)); } else { ValueDeferRecord deferRec = new ValueDeferRecord(bamlRecord, lineNumber, linePosition); if (_deferEndOfStartReached) { // If we are starting/ending a complex property, and we are at the same // depth as the defered element, then track a mode so that we write to // the _deferElement array instead of the key/value arrays. if(_deferElementDepth == 1 && xamlNode is XamlPropertyComplexStartNode) { _deferComplexPropertyDepth++; } if(_deferComplexPropertyDepth > 0) { _deferElement.Add(deferRec); if(_deferElementDepth == 1 && xamlNode is XamlPropertyComplexEndNode) { _deferComplexPropertyDepth--; } } else if (_deferKeyCollecting) { ((KeyDeferRecord)_deferKeys[_deferKeys.Count-1]).RecordList.Add(deferRec); } else { _deferValues.Add(deferRec); } } else { _deferElement.Add(deferRec); } } } else { WriteBamlRecord(bamlRecord, lineNumber, linePosition); BamlRecordManager.ReleaseWriteRecord(bamlRecord); } }
private static bool IsMarkupExtension(XamlNode node) { Fx.Assert(node != null, "node != null"); return node.Type != null && node.Type.IsMarkupExtension; }
/// <summary> /// Override of the main switch statement that processes the xaml nodes. /// </summary> /// <remarks> /// We need to control when cleanup is done and when the calling parse loop /// is exited, so do this here. /// </remarks> internal override void ProcessXamlNode( XamlNode xamlNode, ref bool cleanup, ref bool done) { switch(xamlNode.TokenType) { // Ignore some types of xaml nodes, since they are not // relevent to template parsing. case XamlNodeType.DocumentStart: case XamlNodeType.DocumentEnd: break; case XamlNodeType.ElementEnd: base.ProcessXamlNode(xamlNode, ref cleanup, ref done); // If we're at the depth that we started out, then we must be done. In that case quit // and restore the XamlParser that the token reader was using before parsing templates. if (_styleModeStack.Depth == 0) { done = true; // Stop the template parse cleanup = false; // Don't close the stream TokenReader.ControllingXamlParser = _previousXamlParser; } break; case XamlNodeType.PropertyArrayStart: case XamlNodeType.PropertyArrayEnd: case XamlNodeType.DefTag: ThrowException(SRID.TemplateTagNotSupported, xamlNode.TokenType.ToString(), xamlNode.LineNumber, xamlNode.LinePosition); break; #if PBTCOMPILER case XamlNodeType.EndAttributes: // if there's a DataType present but no x:Key, write out // the key now based on the DataType if (_dataTypePropertyNode != null && _dataTypePropertyNodeDepth == _styleModeStack.Depth) { if (!_defNameFound) { WriteDataTypeKey(_dataTypePropertyNode); } _dataTypePropertyNode = null; _dataTypePropertyNodeDepth = -1; } base.ProcessXamlNode(xamlNode, ref cleanup, ref done); break; #endif // Most nodes are handled by the base XamlParser by creating a // normal BamlRecord. default: base.ProcessXamlNode(xamlNode, ref cleanup, ref done); break; } }
private static bool RaisesLevel(XamlNode current) { return current.NodeType.ToString().Contains("Start") || current.NodeType == XamlNodeType.GetObject; }
void XamlNode_OnAttribute (XamlNode node, XamlAttribute ai) { if (!(CurrentElement is XamlObjectElement)) return; if (IsStaticResourceElement ()) return; currentNode = ai; ParseAttribute (CurrentElement as XamlObjectElement, ai); currentNode = node; }
/// <summary> /// Big switch to handle all the records. /// </summary> /// <param name="xamlNode"> Node received from TokenReader to process</param> /// <param name="cleanup"> True if end of stream reached and document is /// totally finished and should be closed </param> /// <param name="done"> True if done processing and want to exit. Doesn't /// necessarily mean document is finished (see cleanup) </param> internal virtual void ProcessXamlNode( XamlNode xamlNode, ref bool cleanup, ref bool done) { switch(xamlNode.TokenType) { case XamlNodeType.DocumentStart: XamlDocumentStartNode xamlDocumentStartNode = (XamlDocumentStartNode) xamlNode; WriteDocumentStart(xamlDocumentStartNode); break; case XamlNodeType.DocumentEnd: XamlDocumentEndNode xamlEndDocumentNode = (XamlDocumentEndNode) xamlNode; cleanup = true; done = true; WriteDocumentEnd(xamlEndDocumentNode); break; case XamlNodeType.ElementStart: XamlElementStartNode xamlElementNode = (XamlElementStartNode) xamlNode; WriteElementStart(xamlElementNode); break; case XamlNodeType.ElementEnd: XamlElementEndNode xamlEndElementNode = (XamlElementEndNode) xamlNode; WriteElementEnd(xamlEndElementNode); break; case XamlNodeType.UnknownTagStart: XamlUnknownTagStartNode xamlUnknownTagStartNode = (XamlUnknownTagStartNode) xamlNode; WriteUnknownTagStart(xamlUnknownTagStartNode); break; case XamlNodeType.UnknownTagEnd: XamlUnknownTagEndNode xamlUnknownTagEndNode = (XamlUnknownTagEndNode) xamlNode; WriteUnknownTagEnd(xamlUnknownTagEndNode); break; case XamlNodeType.XmlnsProperty: XamlXmlnsPropertyNode xamlXmlnsPropertyNode = (XamlXmlnsPropertyNode) xamlNode; WriteNamespacePrefix(xamlXmlnsPropertyNode); break; case XamlNodeType.Property: XamlPropertyNode xamlPropertyNode = (XamlPropertyNode) xamlNode; if (xamlPropertyNode.AttributeUsage == BamlAttributeUsage.RuntimeName) { _parserContext.XamlTypeMapper.ValidateNames( xamlPropertyNode.Value, xamlPropertyNode.LineNumber, xamlPropertyNode.LinePosition); } WriteProperty(xamlPropertyNode); break; case XamlNodeType.PropertyWithExtension: XamlPropertyWithExtensionNode xamlPropertyWithExtensionNode = (XamlPropertyWithExtensionNode)xamlNode; WritePropertyWithExtension(xamlPropertyWithExtensionNode); break; case XamlNodeType.PropertyWithType: XamlPropertyWithTypeNode xamlPropertyWithTypeNode = (XamlPropertyWithTypeNode) xamlNode; WritePropertyWithType(xamlPropertyWithTypeNode); break; case XamlNodeType.UnknownAttribute: XamlUnknownAttributeNode xamlUnknownAttributeNode = (XamlUnknownAttributeNode) xamlNode; WriteUnknownAttribute(xamlUnknownAttributeNode); break; case XamlNodeType.PropertyComplexStart: XamlPropertyComplexStartNode xamlPropertyComplexStartNode = (XamlPropertyComplexStartNode) xamlNode; WritePropertyComplexStart(xamlPropertyComplexStartNode); break; case XamlNodeType.PropertyComplexEnd: XamlPropertyComplexEndNode xamlPropertyComplexEndNode = (XamlPropertyComplexEndNode) xamlNode; WritePropertyComplexEnd(xamlPropertyComplexEndNode); break; case XamlNodeType.LiteralContent: XamlLiteralContentNode xamlLiteralContentNode = (XamlLiteralContentNode) xamlNode; WriteLiteralContent(xamlLiteralContentNode); break; case XamlNodeType.Text: XamlTextNode xamlTextNode = (XamlTextNode) xamlNode; WriteText(xamlTextNode); break; case XamlNodeType.ClrEvent: XamlClrEventNode xamlClrEventNode = (XamlClrEventNode) xamlNode; WriteClrEvent(xamlClrEventNode); break; case XamlNodeType.PropertyArrayStart: XamlPropertyArrayStartNode xamlPropertyArrayStartNode = (XamlPropertyArrayStartNode) xamlNode; WritePropertyArrayStart(xamlPropertyArrayStartNode); break; case XamlNodeType.PropertyArrayEnd: XamlPropertyArrayEndNode xamlPropertyArrayEndNode = (XamlPropertyArrayEndNode) xamlNode; WritePropertyArrayEnd(xamlPropertyArrayEndNode); break; case XamlNodeType.PropertyIListStart: XamlPropertyIListStartNode xamlPropertyIListStartNode = (XamlPropertyIListStartNode) xamlNode; WritePropertyIListStart(xamlPropertyIListStartNode); break; case XamlNodeType.PropertyIListEnd: XamlPropertyIListEndNode xamlPropertyIListEndNode = (XamlPropertyIListEndNode) xamlNode; WritePropertyIListEnd(xamlPropertyIListEndNode); break; case XamlNodeType.PropertyIDictionaryStart: XamlPropertyIDictionaryStartNode xamlPropertyIDictionaryStartNode = (XamlPropertyIDictionaryStartNode) xamlNode; WritePropertyIDictionaryStart(xamlPropertyIDictionaryStartNode); break; case XamlNodeType.PropertyIDictionaryEnd: XamlPropertyIDictionaryEndNode xamlPropertyIDictionaryEndNode = (XamlPropertyIDictionaryEndNode) xamlNode; WritePropertyIDictionaryEnd(xamlPropertyIDictionaryEndNode); break; case XamlNodeType.DefTag: XamlDefTagNode xamlDefTagNode = (XamlDefTagNode) xamlNode; WriteDefTag(xamlDefTagNode); break; case XamlNodeType.DefKeyTypeAttribute: XamlDefAttributeKeyTypeNode xamlDefAttributeKeyTypeNode = (XamlDefAttributeKeyTypeNode) xamlNode; WriteDefAttributeKeyType(xamlDefAttributeKeyTypeNode); break; case XamlNodeType.DefAttribute: XamlDefAttributeNode xamlDefAttributeNode = (XamlDefAttributeNode) xamlNode; if (xamlDefAttributeNode.AttributeUsage == BamlAttributeUsage.RuntimeName) { _parserContext.XamlTypeMapper.ValidateNames( xamlDefAttributeNode.Value, xamlDefAttributeNode.LineNumber, xamlDefAttributeNode.LinePosition); } WriteDefAttributeCore(xamlDefAttributeNode); break; case XamlNodeType.PresentationOptionsAttribute: XamlPresentationOptionsAttributeNode xamlPresentationOptionsAttributeNode = (XamlPresentationOptionsAttributeNode) xamlNode; WritePresentationOptionsAttribute(xamlPresentationOptionsAttributeNode); break; case XamlNodeType.PIMapping: XamlPIMappingNode xamlPIMappingNode = (XamlPIMappingNode) xamlNode; WritePIMapping(xamlPIMappingNode); break; // The following tokens that are used primarily by the markup compiler case XamlNodeType.EndAttributes: XamlEndAttributesNode xamlEndAttributesNode = (XamlEndAttributesNode) xamlNode; // if first tag and haven't alredy set the ParseMode // set it to synchronous. if (0 == xamlEndAttributesNode.Depth) { if (XamlParseMode == XamlParseMode.Uninitialized) { XamlParseMode = XamlParseMode.Synchronous; } } WriteEndAttributes(xamlEndAttributesNode); break; case XamlNodeType.KeyElementStart: XamlKeyElementStartNode xamlKeyElementStartNode = (XamlKeyElementStartNode) xamlNode; WriteKeyElementStart(xamlKeyElementStartNode); break; case XamlNodeType.KeyElementEnd: XamlKeyElementEndNode xamlKeyElementEndNode = (XamlKeyElementEndNode) xamlNode; WriteKeyElementEnd(xamlKeyElementEndNode); break; case XamlNodeType.ConstructorParametersEnd: XamlConstructorParametersEndNode xamlConstructorParametersEndNode = (XamlConstructorParametersEndNode) xamlNode; WriteConstructorParametersEnd(xamlConstructorParametersEndNode); break; case XamlNodeType.ConstructorParametersStart: XamlConstructorParametersStartNode xamlConstructorParametersStartNode = (XamlConstructorParametersStartNode) xamlNode; WriteConstructorParametersStart(xamlConstructorParametersStartNode); break; case XamlNodeType.ContentProperty: XamlContentPropertyNode xamlContentPropertyNode = (XamlContentPropertyNode)xamlNode; WriteContentProperty(xamlContentPropertyNode); break; case XamlNodeType.ConstructorParameterType: XamlConstructorParameterTypeNode xamlConstructorParameterTypeNode = (XamlConstructorParameterTypeNode)xamlNode; WriteConstructorParameterType(xamlConstructorParameterTypeNode); break; default: Debug.Assert(false,"Unknown Xaml Token."); break; } }
/// <summary> /// Override of the main switch statement that processes the xaml nodes. /// </summary> /// <remarks> /// We need to control when cleanup is done and when the calling parse loop /// is exited, so do this here. /// </remarks> internal override void ProcessXamlNode( XamlNode xamlNode, ref bool cleanup, ref bool done) { switch(xamlNode.TokenType) { // Ignore some types of xaml nodes, since they are not // relevent to style parsing. case XamlNodeType.DocumentStart: case XamlNodeType.DocumentEnd: break; case XamlNodeType.ElementEnd: base.ProcessXamlNode(xamlNode, ref cleanup, ref done); // If we're at the depth that we started out, then we must be done. In that case quit // and restore the XamlParser that the token reader was using before parsing styles. if (_styleModeStack.Depth == 0) { done = true; // Stop the style parse cleanup = false; // Don't close the stream TokenReader.ControllingXamlParser = _previousXamlParser; } break; case XamlNodeType.PropertyArrayStart: case XamlNodeType.PropertyArrayEnd: case XamlNodeType.DefTag: ThrowException(SRID.StyleTagNotSupported, xamlNode.TokenType.ToString(), xamlNode.LineNumber, xamlNode.LinePosition); break; // Most nodes are handled by the base XamlParser by creating a // normal BamlRecord. default: base.ProcessXamlNode(xamlNode, ref cleanup, ref done); break; } }
public object Parse (XamlNode node) { try { node.Parse (XamlNode_OnElementStart, XamlNode_OnElementEnd, XamlNode_OnAttribute); } catch (XamlParseException pe) { Console.WriteLine ("Exception while parsing string ({0}:{1})", pe.LineNumber, pe.LinePosition); Console.WriteLine (pe); Console.WriteLine ("string:"); Console.WriteLine (node.OuterXml); throw pe; } catch (Exception e) { Console.WriteLine ("Exception while parsing string:"); Console.WriteLine (e); Console.WriteLine ("string:"); Console.WriteLine (node.OuterXml); throw ParseException ("Caught exception: {0}", e.Message); } XamlObjectElement obj = top_element as XamlObjectElement; if (obj == null) { // We actually return the type of the property here // or the object that it wraps return null; } return obj.Object; }
private MemberInfo GetPropertyOrEventInfo(XamlNode xamlNode, ref string member) { // Strip off namespace prefix from the event or property name and // map this to an xmlnamespace. Also extract the class name, if present string prefix = string.Empty; string target = member; string propOrEvent = member; int dotIndex = member.LastIndexOf('.'); if (-1 != dotIndex) { target = propOrEvent.Substring(0, dotIndex); member = propOrEvent.Substring(dotIndex + 1); } int colonIndex = target.IndexOf(':'); if (-1 != colonIndex) { // If using .net then match against the class. prefix = target.Substring(0, colonIndex); if (-1 == dotIndex) { member = target.Substring(colonIndex + 1); } } string xmlNamespace = TokenReader.XmlReader.LookupNamespace(prefix); Type targetType = null; // Get the type associated with the property or event from the XamlTypeMapper and // use this to resolve the property or event into an EventInfo, PropertyInfo // or MethodInfo if (-1 != dotIndex) { targetType = XamlTypeMapper.GetTypeFromBaseString(target, ParserContext, false); } else if (_styleTargetTypeString != null) { targetType = XamlTypeMapper.GetTypeFromBaseString(_styleTargetTypeString, ParserContext, false); target = _styleTargetTypeString; } else if (_styleTargetTypeType != null) { targetType = _styleTargetTypeType; target = targetType.Name; } MemberInfo memberInfo = null; if (targetType != null) { string objectName = propOrEvent; memberInfo = XamlTypeMapper.GetClrInfo( _inEventSetter, targetType, xmlNamespace, member, ref objectName) as MemberInfo; } if (memberInfo != null) { if (!_inEventSetter) { PropertyInfo pi = memberInfo as PropertyInfo; if (pi != null) { // For trigger condition only allow if public or internal getter if (_inSetterDepth < 0 && _styleModeStack.Mode == StyleMode.TriggerBase) { if (!XamlTypeMapper.IsAllowedPropertyGet(pi)) { ThrowException(SRID.ParserCantSetTriggerCondition, pi.Name, xamlNode.LineNumber, xamlNode.LinePosition); } } else // for general Setters check prop setters { if (!XamlTypeMapper.IsAllowedPropertySet(pi)) { ThrowException(SRID.ParserCantSetAttribute, "Property Setter", pi.Name, "set", xamlNode.LineNumber, xamlNode.LinePosition); } } } } } // local properties and events will be added to the baml in pass2 of the compilation. // so don't throw now. else #if PBTCOMPILER if (!IsLocalPass1) #endif { if (targetType != null) { ThrowException(SRID.StyleNoPropOrEvent, (_inEventSetter ? "Event" : "Property"), member, targetType.FullName, xamlNode.LineNumber, xamlNode.LinePosition); } else { ThrowException(SRID.StyleNoTarget, (_inEventSetter ? "Event" : "Property"), member, xamlNode.LineNumber, xamlNode.LinePosition); } } return memberInfo; }
/// <summary> /// Called by parser after it determines what node type for /// the XML Node and has tokenized the xml node content. /// </summary> /// <remarks> /// Node types are Resources, Code: Element Object, properties, events etc. /// The return value is a ParserAction value which indicates if the parser /// should: continue normal processing; skip this node and any children /// </remarks> internal virtual ParserAction LoadNode(XamlNode tokenNode) { return ParserAction.Normal; }
public XamlDebuggerXmlReader(XamlReader underlyingReader, IXamlLineInfo xamlLineInfo, TextReader textReader) { this.underlyingReader = underlyingReader; this.xamlLineInfo = xamlLineInfo; this.xmlReaderWithSourceLocation = new XmlReaderWithSourceLocation(textReader); this.initializationValueRanges = new Dictionary<XamlNode, DocumentRange>(); // Parse the XML at once to get all the locations we wanted. while (this.xmlReaderWithSourceLocation.Read()) { } this.schemaContext = underlyingReader.SchemaContext; this.objectDeclarationRecords = new Stack<XamlNode>(); this.bufferedXamlNodes = new Queue<XamlNode>(); this.current = this.CreateCurrentNode(); this.SourceLocationFound += XamlDebuggerXmlReader.SetSourceLocation; }
public XamlParsingContext() { root = new XamlRootNode(); }
/// <summary> /// Инициализирует новый экземпляр класса <see cref="T:System.Object"/>. /// </summary> public XamlNamespaceResolver(XamlNode node) { this.node = node; }
/// <summary> /// If there are ParserHooks, call it with the current xamlNode and perform /// as directed by the callback. /// </summary> private void SetParserAction(XamlNode xamlNode) { // if no ParserHooks then process as normal if (null == ParserHooks) { ParserAction = ParserAction.Normal; return; } // if ParserHooks want to skip the current node and its children, // check for end of scope where it asked to be skipped. if (ParserAction == ParserAction.Skip) { if (xamlNode.Depth <= SkipActionDepthCount && xamlNode.TokenType == SkipActionToken) { // We found the end token at the correct depth. Reset the depth count // so that in the next call we won't skip calling the ParserHooks. Don't // reset the ParserAction since we want to skip this end token. SkipActionDepthCount = -1; SkipActionToken = XamlNodeType.Unknown; return; } else if (SkipActionDepthCount >= 0) { return; } } // If we get to here, the ParserHooks want to be called. ParserAction = ParserHooks.LoadNode(xamlNode); // if the ParserHooks want to skip the current node and its children then // set the callback depth so that we'll know when to start processing again. if (ParserAction == ParserAction.Skip) { // For tokens with no scope (eg = attributes), don't set the depth so // that we will only skip once Debug.Assert(SkipActionDepthCount == -1); int tokenIndex = ((IList)XamlNode.ScopeStartTokens).IndexOf(xamlNode.TokenType); if (tokenIndex != -1) { SkipActionDepthCount = xamlNode.Depth; SkipActionToken = XamlNode.ScopeEndTokens[tokenIndex]; } } }
public VisualizationNode(XamlNode xamlNode) { this.XamlNode = xamlNode; this.Children = new Collection<VisualizationNode>(); }
private string getKeyFromNode(XamlNode n) { // we know that n is a XamlElementStartNode, but don't need that knowledge if (n is XamlKeyElementStartNode) return ((XamlKeyElementStartNode)n).key; else return null; }
public XamlNodeStackItem (XamlNode node, JToken token) { Node = node; JToken = token; }
private static bool LowersLevel(XamlNode current) { return current.NodeType.ToString().Contains("End"); }
void XamlNode_OnElementEnd (XamlNode node) { reader = node; ParseEndElement (); }
// // CommonElementStartProcessing // // This is used by WriteElementStart and WriteUnknownTagStart. It is used // to keep style mode up-to-date. // private void CommonElementStartProcessing (XamlNode xamlNode, Type elementType, ref StyleMode mode) { if (mode == StyleMode.Base && _styleModeStack.Depth > 0 ) { if (_templateRootCount++ > 0) { ThrowException(SRID.TemplateNoMultipleRoots, (elementType == null ? "Unknown tag" : elementType.Name), xamlNode.LineNumber, xamlNode.LinePosition); } // Validate that the root is an FE or FCE. If the type is unknown (and internal type), we'll // catch this during template instantiation. if (elementType != null && !KnownTypes.Types[(int)KnownElements.FrameworkElement].IsAssignableFrom(elementType) && !KnownTypes.Types[(int)KnownElements.FrameworkContentElement].IsAssignableFrom(elementType)) { ThrowException(SRID.TemplateInvalidRootElementTag, elementType.ToString(), xamlNode.LineNumber, xamlNode.LinePosition); } mode = StyleMode.VisualTree; } }
void XamlNode_OnElementStart (XamlNode node) { reader = node; currentNode = (IXamlNode) node; switch (node.NodeType) { case XmlNodeType.Element: Log ("Next node: {0}", reader.Name); ParseElement (); break; case XmlNodeType.Text: Log ("Next node: {0}", reader.Name); ParseText (); break; case XmlNodeType.Whitespace: Log ("Next node: {0}", reader.Name); ParseWhitespace (); break; case XmlNodeType.SignificantWhitespace: Log ("Next node: {0}", reader.Name); ParseSignificantWhitespace (); break; } }
private static XamlNode CreateCurrentNode(XamlReader xamlReader, IXamlLineInfo xamlLineInfo) { XamlNode currentNode = new XamlNode { Namespace = xamlReader.Namespace, NodeType = xamlReader.NodeType, Type = xamlReader.Type, Member = xamlReader.Member, Value = xamlReader.Value, LineNumber = xamlLineInfo.LineNumber, LinePosition = xamlLineInfo.LinePosition, }; return currentNode; }
internal XamlDebuggerXmlReader(TextReader underlyingTextReader, XamlSchemaContext schemaContext, Assembly localAssembly) { UnitTestUtility.Assert(underlyingTextReader != null, "underlyingTextReader should not be null and is ensured by caller."); this.xmlReaderWithSourceLocation = new XmlReaderWithSourceLocation(underlyingTextReader); this.underlyingReader = new XamlXmlReader(this.xmlReaderWithSourceLocation, schemaContext, new XamlXmlReaderSettings { ProvideLineInfo = true, LocalAssembly = localAssembly }); this.xamlLineInfo = (IXamlLineInfo)this.underlyingReader; UnitTestUtility.Assert(this.xamlLineInfo.HasLineInfo, "underlyingReader is constructed with the ProvideLineInfo option above."); this.schemaContext = schemaContext; this.objectDeclarationRecords = new Stack<XamlNode>(); this.initializationValueRanges = new Dictionary<XamlNode, DocumentRange>(); this.bufferedXamlNodes = new Queue<XamlNode>(); this.current = this.CreateCurrentNode(); this.SourceLocationFound += XamlDebuggerXmlReader.SetSourceLocation; }