public StyleSheet(XmlProcessingInstruction pi) : this(String.Empty) { Regex re = new Regex(@"(?<name>[a-z]+)=[""'](?<value>[^""']*)[""']"); Match match = re.Match(pi.Data); while(match.Success) { string name = match.Groups["name"].Value; string val = match.Groups["value"].Value; switch(name) { case "href": _Href = val; break; case "type": _Type = val; break; case "title": _Title = val; break; case "media": _Media = new MediaList(val); break; } match = match.NextMatch(); } ownerNode = pi; }
/// <summary> /// 执行sql /// </summary> /// <param name="strSql"></param> /// <param name="strDataSet"></param> /// <returns></returns> public int ExecQuery(string strSql, ref string strDataSet, string strXSLFileName) { this.command.Connection = this.con as OracleConnection; if (this.command.Transaction == null) //没有事务,用全局事务 { this.command.Transaction = Neusoft.FrameWork.Management.PublicTrans.Trans as OracleTransaction; } this.command.CommandType = System.Data.CommandType.Text; this.command.Parameters.Clear(); this.command.CommandText = strSql + ""; try { this.TempReader1 = this.command.ExecuteReader(); XmlDocument doc = new XmlDocument(); XmlNode root; XmlElement node, row; doc.AppendChild(doc.CreateXmlDeclaration("1.0", "GB2312", "")); if (strXSLFileName != null && strXSLFileName != "") { string PI = "type='text/xsl' href='" + strXSLFileName + "'"; System.Xml.XmlProcessingInstruction xmlProcessingInstruction = doc.CreateProcessingInstruction("xml-stylesheet", PI); doc.AppendChild(xmlProcessingInstruction); } root = doc.CreateElement("Table"); doc.AppendChild(root); while (this.TempReader1.Read()) { row = doc.CreateElement("Row"); for (int i = 0; i < this.TempReader1.FieldCount; i++) { node = doc.CreateElement("Column"); node.SetAttribute("Name", this.TempReader1.GetName(i).ToString()); node.InnerText = this.TempReader1[i].ToString() + ""; row.AppendChild(node); } root.AppendChild(row); } strDataSet = doc.OuterXml; TempReader1.Close(); } catch (OracleException ex) { this.Err = "执行产生错误!" + ex.Message; this.ErrCode = strSql; this.DBErrCode = ex.Code; this.WriteErr(); return(-1); } catch (Exception ex) { this.Err = "执行语句产生错误!" + ex.Message; this.ErrorException = ex.InnerException + "+ " + ex.Source; this.ErrCode = strSql; this.WriteErr(); return(-1); } WriteDebug("执行查询sql语句!" + strSql); return(0); }
public void Print(XmlProcessingInstruction instruction) { if (SkipPI) { return; } Context.Output.Write("<?{0} {1}?>", instruction.Name, instruction.Value); }
protected override void ExecuteCore(XmlProcessingInstruction instruction) { if (instruction.ParentNode is XmlDocument) { return; } var element = instruction.OwnerDocument.CreateElement(instruction.Name); element.InnerText = instruction.Value; instruction.ParentNode.ReplaceChild(element, instruction); }
/// <summary> /// 执行sql /// </summary> /// <param name="strSql"></param> /// <param name="strDataSet"></param> /// <param name="strXSLFileName"></param> /// <param name="SettingXml"></param> /// <returns></returns> public int ExecQuery(string strSql, ref string strDataSet, string strXSLFileName, string SettingXml) { System.Data.OracleClient.OracleConnection con = new System.Data.OracleClient.OracleConnection(strConn); System.Data.OracleClient.OracleCommand command = new System.Data.OracleClient.OracleCommand(); command.Connection = con; command.CommandType = System.Data.CommandType.Text; command.Parameters.Clear(); command.CommandText = strSql + ""; try { System.Data.OracleClient.OracleDataReader TempReader1; TempReader1 = command.ExecuteReader(); XmlDocument doc = new XmlDocument(); XmlNode root; XmlElement node, row; doc.AppendChild(doc.CreateXmlDeclaration("1.0", "GB2312", "")); if (strXSLFileName != null && strXSLFileName != "") { string PI = "type='text/xsl' href='" + strXSLFileName + "'"; System.Xml.XmlProcessingInstruction xmlProcessingInstruction = doc.CreateProcessingInstruction("xml-stylesheet", PI); doc.AppendChild(xmlProcessingInstruction); } string Header = doc.OuterXml + "\n<DataSet>\n" + SettingXml; doc = new XmlDocument(); root = doc.CreateElement("Table"); doc.AppendChild(root); while (TempReader1.Read()) { row = doc.CreateElement("Row"); for (int i = 0; i < TempReader1.FieldCount; i++) { node = doc.CreateElement("Column"); node.SetAttribute("Name", TempReader1.GetName(i).ToString()); node.InnerText = TempReader1[i].ToString() + ""; row.AppendChild(node); } root.AppendChild(row); } strDataSet = Header + "\n" + doc.OuterXml + "\n</DataSet>"; TempReader1.Close(); } catch (Exception ex) { this.Err = "执行语句产生错误!" + ex.Message; this.ErrorException = ex.InnerException + "+ " + ex.Source; this.ErrCode = strSql; this.WriteErr(); return(-1); } WriteDebug("执行查询sql语句!" + strSql); return(0); }
protected override void ExecuteCore(XmlProcessingInstruction instruction) { var text = instruction.OwnerDocument.CreateTextNode(instruction.Value); instruction.ParentNode.ReplaceChild(text, instruction); }
public virtual XmlNode ImportNode(XmlNode node, bool deep) { if (node == null) { throw new NullReferenceException("Null node cannot be imported."); } switch (node.NodeType) { case XmlNodeType.Attribute: XmlAttribute srcAtt = node as XmlAttribute; XmlAttribute dstAtt = this.CreateAttribute(srcAtt.Prefix, srcAtt.LocalName, srcAtt.NamespaceURI); for (XmlNode n = srcAtt.FirstChild; n != null; n = n.NextSibling) { dstAtt.AppendChild(this.ImportNode(n, deep)); } return(dstAtt); case XmlNodeType.CDATA: return(this.CreateCDataSection(node.Value)); case XmlNodeType.Comment: return(this.CreateComment(node.Value)); case XmlNodeType.Document: throw new XmlException("Document cannot be imported."); case XmlNodeType.DocumentFragment: XmlDocumentFragment df = this.CreateDocumentFragment(); if (deep) { for (XmlNode n = node.FirstChild; n != null; n = n.NextSibling) { df.AppendChild(this.ImportNode(n, deep)); } } return(df); case XmlNodeType.DocumentType: throw new XmlException("DocumentType cannot be imported."); case XmlNodeType.Element: XmlElement src = (XmlElement)node; XmlElement dst = this.CreateElement(src.Prefix, src.LocalName, src.NamespaceURI); for (int i = 0; i < src.Attributes.Count; i++) { XmlAttribute attr = src.Attributes [i]; if (attr.Specified) // copies only specified attributes { dst.SetAttributeNode((XmlAttribute)this.ImportNode(attr, deep)); } } if (deep) { for (XmlNode n = src.FirstChild; n != null; n = n.NextSibling) { dst.AppendChild(this.ImportNode(n, deep)); } } return(dst); case XmlNodeType.EndElement: throw new XmlException("Illegal ImportNode call for NodeType.EndElement"); case XmlNodeType.EndEntity: throw new XmlException("Illegal ImportNode call for NodeType.EndEntity"); case XmlNodeType.EntityReference: return(this.CreateEntityReference(node.Name)); case XmlNodeType.None: throw new XmlException("Illegal ImportNode call for NodeType.None"); case XmlNodeType.ProcessingInstruction: XmlProcessingInstruction pi = node as XmlProcessingInstruction; return(this.CreateProcessingInstruction(pi.Target, pi.Data)); case XmlNodeType.SignificantWhitespace: return(this.CreateSignificantWhitespace(node.Value)); case XmlNodeType.Text: return(this.CreateTextNode(node.Value)); case XmlNodeType.Whitespace: return(this.CreateWhitespace(node.Value)); case XmlNodeType.XmlDeclaration: XmlDeclaration srcDecl = node as XmlDeclaration; return(this.CreateXmlDeclaration(srcDecl.Version, srcDecl.Encoding, srcDecl.Standalone)); default: throw new InvalidOperationException("Cannot import specified node type: " + node.NodeType); } }
// LoadNodeDirect does not use creator functions on XmlDocument. It is used loading nodes that are children of entity nodes, // because we do not want to let users extend these (if we would allow this, XmlDataDocument would have a problem, because // they do not know that those nodes should not be mapped). It can be also used for an optimized load path when if the // XmlDocument is not extended if XmlDocumentType and XmlDeclaration handling is added. private XmlNode LoadNodeDirect() { XmlReader r = _reader; XmlNode parent = null; do { XmlNode node = null; switch (r.NodeType) { case XmlNodeType.Element: bool fEmptyElement = _reader.IsEmptyElement; XmlElement element = new XmlElement(_reader.Prefix, _reader.LocalName, _reader.NamespaceURI, _doc); element.IsEmpty = fEmptyElement; if (_reader.MoveToFirstAttribute()) { XmlAttributeCollection attributes = element.Attributes; do { XmlAttribute attr = LoadAttributeNodeDirect(); attributes.Append(attr); // special case for load } while (r.MoveToNextAttribute()); } // recursively load all children. if (!fEmptyElement) { parent.AppendChildForLoad(element, _doc); parent = element; continue; } else { node = element; break; } case XmlNodeType.EndElement: Debug.Assert(parent.NodeType == XmlNodeType.Element); if (parent.ParentNode == null) { return parent; } parent = parent.ParentNode; continue; case XmlNodeType.EntityReference: node = LoadEntityReferenceNode(true); break; case XmlNodeType.EndEntity: continue; case XmlNodeType.Attribute: node = LoadAttributeNodeDirect(); break; case XmlNodeType.SignificantWhitespace: node = new XmlSignificantWhitespace(_reader.Value, _doc); break; case XmlNodeType.Whitespace: if (_preserveWhitespace) { node = new XmlWhitespace(_reader.Value, _doc); } else { continue; } break; case XmlNodeType.Text: node = new XmlText(_reader.Value, _doc); break; case XmlNodeType.CDATA: node = new XmlCDataSection(_reader.Value, _doc); break; case XmlNodeType.ProcessingInstruction: node = new XmlProcessingInstruction(_reader.Name, _reader.Value, _doc); break; case XmlNodeType.Comment: node = new XmlComment(_reader.Value, _doc); break; default: throw UnexpectedNodeType(_reader.NodeType); } Debug.Assert(node != null); if (parent != null) { parent.AppendChildForLoad(node, _doc); } else { return node; } } while (r.Read()); return null; }
protected override void ExecuteCore(XmlProcessingInstruction instruction) { Print(instruction); }
protected virtual void ExecuteCore(XmlProcessingInstruction instruction) { }
protected override void ExecuteCore(XmlProcessingInstruction instruction) { instruction.Value = NewGuid(); }
// Used by the ReadNode method for recursively building a DOM subtree. internal XmlNode ReadNodeInternal(XmlReader r) { switch (r.NodeType) { case XmlNodeType.Attribute: { // create the attribute XmlAttribute att = CreateAttribute (r.Prefix, r.LocalName, r.NamespaceURI); // read and append the children ReadChildren(r, att); // return the attribute return(att); } // Not reached. case XmlNodeType.CDATA: { // create the character data section XmlCDataSection cdata = CreateCDataSection(r.Value); // advance the reader to the next node r.Read(); // return the character data section return(cdata); } // Not reached. case XmlNodeType.Comment: { // create the comment XmlComment comment = CreateComment(r.Value); // advance the reader to the next node r.Read(); // return the comment return(comment); } // Not reached. case XmlNodeType.DocumentType: { // create the document type XmlDocumentType doctype = CreateDocumentType (r.Name, r["PUBLIC"], r["SYSTEM"], r.Value); // advance the reader to the next node r.Read(); // return the document type return(doctype); } // Not reached. case XmlNodeType.Element: { // create the element XmlElement elem = CreateElement (r.Prefix, r.LocalName, r.NamespaceURI); bool isEmptyElement = r.IsEmptyElement; // read the attributes while (r.MoveToNextAttribute()) { XmlAttribute att = (XmlAttribute)ReadNodeInternal(r); elem.SetAttributeNode(att); } r.MoveToElement(); // return now if there are no children if (isEmptyElement) { // advance the reader to the next node r.Read(); // return the empty element return(elem); } elem.IsEmpty = isEmptyElement; // read and append the children ReadChildren(r, elem); // return the element return(elem); } // Not reached. case XmlNodeType.DocumentFragment: case XmlNodeType.EndElement: case XmlNodeType.EndEntity: case XmlNodeType.Entity: case XmlNodeType.Notation: { // TODO // advance the reader to the next node r.Read(); // nothing to return return(null); } // Not reached. case XmlNodeType.EntityReference: { // create the entity reference XmlEntityReference er = CreateEntityReference(r.Name); // advance the reader to the next node r.Read(); // return the entity reference return(er); } // Not reached. case XmlNodeType.ProcessingInstruction: { // create the processing instruction XmlProcessingInstruction pi = CreateProcessingInstruction (r.Name, r.Value); // advance the reader to the next node r.Read(); // return the processing instruction return(pi); } // Not reached. case XmlNodeType.SignificantWhitespace: { // create the significant whitespace XmlSignificantWhitespace sws = CreateSignificantWhitespace (r.Value); // advance the reader to the next node r.Read(); // return the significant whitespace return(sws); } // Not reached. case XmlNodeType.Text: { // create the text XmlText text = CreateTextNode(r.Value); // advance the reader to the next node r.Read(); // return the text return(text); } // Not reached. case XmlNodeType.Whitespace: { // if whitespace preservation is off, skip whitespace if (!preserveWhitespace) { while (r.Read()) { if (r.NodeType != XmlNodeType.Whitespace) { return(null); } } return(null); } // create the whitespace XmlWhitespace ws = CreateWhitespace(r.Value); // advance the reader to the next node r.Read(); // return the whitespace return(ws); } // Not reached. case XmlNodeType.XmlDeclaration: { // set up the defaults String e = String.Empty; String s = String.Empty; // read the version r.MoveToNextAttribute(); // read the optional attributes if (r.MoveToNextAttribute()) { if (r.Name == "encoding") { e = r.Value; if (r.MoveToNextAttribute()) { s = r.Value; } } else { s = r.Value; } } // create the xml declaration XmlDeclaration xml = CreateXmlDeclaration("1.0", e, s); // advance the reader to the next node r.Read(); // return the xml declaration return(xml); } // Not reached. default: { throw new InvalidOperationException(/* TODO */); } // Not reached. } }
protected override void ExecuteCore(XmlProcessingInstruction instruction) { var parent = instruction.ParentNode; var clone = instruction.OwnerDocument.CreateProcessingInstruction(DoRename(instruction.Name), instruction.Value); parent.ReplaceChild(clone, instruction); }
internal DOMProcessingInstruction(XmlProcessingInstruction/*!*/ xmlProcessingInstruction) : base(ScriptContext.CurrentContext, true) { this.XmlProcessingInstruction = xmlProcessingInstruction; }
private XmlNode LoadNodeDirect() { XmlNode node2; XmlReader reader = this.reader; XmlNode parentNode = null; Label_0009: node2 = null; switch (reader.NodeType) { case XmlNodeType.Element: { bool isEmptyElement = this.reader.IsEmptyElement; XmlElement newChild = new XmlElement(this.reader.Prefix, this.reader.LocalName, this.reader.NamespaceURI, this.doc) { IsEmpty = isEmptyElement }; if (this.reader.MoveToFirstAttribute()) { XmlAttributeCollection attributes = newChild.Attributes; do { XmlAttribute attribute = this.LoadAttributeNodeDirect(); attributes.Append(attribute); } while (reader.MoveToNextAttribute()); } if (!isEmptyElement) { parentNode.AppendChildForLoad(newChild, this.doc); parentNode = newChild; goto Label_01FC; } node2 = newChild; break; } case XmlNodeType.Attribute: node2 = this.LoadAttributeNodeDirect(); break; case XmlNodeType.Text: node2 = new XmlText(this.reader.Value, this.doc); break; case XmlNodeType.CDATA: node2 = new XmlCDataSection(this.reader.Value, this.doc); break; case XmlNodeType.EntityReference: node2 = this.LoadEntityReferenceNode(true); break; case XmlNodeType.ProcessingInstruction: node2 = new XmlProcessingInstruction(this.reader.Name, this.reader.Value, this.doc); break; case XmlNodeType.Comment: node2 = new XmlComment(this.reader.Value, this.doc); break; case XmlNodeType.Whitespace: if (!this.preserveWhitespace) { goto Label_01FC; } node2 = new XmlWhitespace(this.reader.Value, this.doc); break; case XmlNodeType.SignificantWhitespace: node2 = new XmlSignificantWhitespace(this.reader.Value, this.doc); break; case XmlNodeType.EndElement: if (parentNode.ParentNode != null) { parentNode = parentNode.ParentNode; goto Label_01FC; } return parentNode; case XmlNodeType.EndEntity: goto Label_01FC; default: throw UnexpectedNodeType(this.reader.NodeType); } if (parentNode != null) { parentNode.AppendChildForLoad(node2, this.doc); } else { return node2; } Label_01FC: if (reader.Read()) { goto Label_0009; } return null; }
protected override void ExecuteCore(XmlProcessingInstruction instruction) { var element = instruction.ParentNode as XmlElement; var name = instruction.Name; if (element != null && element.Attributes[name] == null) { var attribute = instruction.OwnerDocument.CreateAttribute(name); attribute.Value = instruction.Value; element.Attributes.Append(attribute); element.RemoveChild(instruction); } }
protected override void ExecuteCore(XmlProcessingInstruction instruction) { instruction.Value = DoReplace(instruction.Value); }
public override XmlNode CloneNode (bool deep) { XmlNode n = new XmlProcessingInstruction (target, data, OwnerDocument); return n; }
private XmlNode LoadEntityChildren() { XmlNode node = null; // We do not use creator functions on XmlDocument, b/c we do not want to let users extend the nodes that are children of entity nodes (also, if we do // this, XmlDataDocument will have a problem, b/c they do not know that those nodes should not be mapped). switch (reader.NodeType) { case XmlNodeType.EndElement: case XmlNodeType.EndEntity: break; case XmlNodeType.Element: { bool fEmptyElement = reader.IsEmptyElement; XmlElement element = new XmlElement(reader.Prefix, reader.LocalName, reader.NamespaceURI, this.doc); element.IsEmpty = fEmptyElement; while (reader.MoveToNextAttribute()) { XmlAttribute attr = (XmlAttribute)LoadEntityChildren(); element.Attributes.Append(attr); } // recursively load all children. if (!fEmptyElement) { LoadEntityChildren(element); } node = element; break; } case XmlNodeType.Attribute: if (reader.IsDefault) { XmlUnspecifiedAttribute attr = new XmlUnspecifiedAttribute(reader.Prefix, reader.LocalName, reader.NamespaceURI, this.doc); LoadEntityAttributeChildren(attr); attr.SetSpecified(false); node = attr; } else { XmlAttribute attr = new XmlAttribute(reader.Prefix, reader.LocalName, reader.NamespaceURI, this.doc); LoadEntityAttributeChildren(attr); node = attr; } break; case XmlNodeType.SignificantWhitespace: node = new XmlSignificantWhitespace(reader.Value, this.doc); break; case XmlNodeType.Whitespace: if (preserveWhitespace) { node = new XmlWhitespace(reader.Value, this.doc); } else { // if preserveWhitespace is false skip all subsequent WS nodes and position on the first non-WS node do { if (!reader.Read()) { return(null); } } while (reader.NodeType == XmlNodeType.Whitespace); node = LoadEntityChildren(); // Skip WS node if preserveWhitespace is false } break; case XmlNodeType.Text: node = new XmlText(reader.Value, this.doc); break; case XmlNodeType.CDATA: node = new XmlCDataSection(reader.Value, this.doc); break; case XmlNodeType.EntityReference: { XmlEntityReference eref = new XmlEntityReference(reader.Name, this.doc); if (reader.CanResolveEntity) { reader.ResolveEntity(); LoadEntityChildren(eref); //what if eref doesn't have children at all? should we just put a Empty String text here? if (eref.ChildNodes.Count == 0) { eref.AppendChild(new XmlText("")); } } node = eref; break; } case XmlNodeType.ProcessingInstruction: node = new XmlProcessingInstruction(reader.Name, reader.Value, this.doc); break; case XmlNodeType.Comment: node = new XmlComment(reader.Value, this.doc); break; default: throw new InvalidOperationException(string.Format(Res.GetString(Res.Xdom_Load_NodeType), reader.NodeType.ToString())); } return(node); }
private void ProcessElseElement(XmlProcessingInstruction pi, IXmlProcessorEngine engine, ref StatementState state) { AssertData(pi, pi.Name == ElsifPiName); if (state == StatementState.Collect) { state = StatementState.Finished; } else if (pi.Name == ElsePiName || engine.HasFlag(pi.Data)) { if (state == StatementState.Init) { state = StatementState.Collect; } } RemoveItSelf(pi); return; }
public void InnerAndOuterXml () { pi = document.CreateProcessingInstruction ("foo", "bar"); AssertEquals (String.Empty, pi.InnerXml); AssertEquals ("<?foo bar?>", pi.OuterXml); }
private XmlNode LoadEntityChildren() { XmlNode node = null; // We do not use creator functions on XmlDocument, b/c we do not want to let users extend the nodes that are children of entity nodes (also, if we do // this, XmlDataDocument will have a problem, b/c they do not know that those nodes should not be mapped). switch (reader.NodeType) { case XmlNodeType.EndElement: case XmlNodeType.EndEntity: break; case XmlNodeType.Element: { bool fEmptyElement = reader.IsEmptyElement; XmlElement element = new XmlElement( reader.Prefix, reader.LocalName, reader.NamespaceURI, this.doc ); element.IsEmpty = fEmptyElement; while(reader.MoveToNextAttribute()) { XmlAttribute attr = (XmlAttribute) LoadEntityChildren(); element.Attributes.Append( attr ); } // recursively load all children. if (! fEmptyElement) LoadEntityChildren( element ); node = element; break; } case XmlNodeType.Attribute: if (reader.IsDefault) { XmlUnspecifiedAttribute attr = new XmlUnspecifiedAttribute( reader.Prefix, reader.LocalName, reader.NamespaceURI, this.doc ); LoadEntityAttributeChildren( attr ); attr.SetSpecified( false ); node = attr; } else { XmlAttribute attr = new XmlAttribute( reader.Prefix, reader.LocalName, reader.NamespaceURI, this.doc ); LoadEntityAttributeChildren( attr ); node = attr; } break; case XmlNodeType.SignificantWhitespace: node = new XmlSignificantWhitespace( reader.Value, this.doc ); break; case XmlNodeType.Whitespace: if ( preserveWhitespace ) node = new XmlWhitespace( reader.Value, this.doc ); else { // if preserveWhitespace is false skip all subsequent WS nodes and position on the first non-WS node do { if (! reader.Read() ) return null; } while (reader.NodeType == XmlNodeType.Whitespace); node = LoadEntityChildren(); // Skip WS node if preserveWhitespace is false } break; case XmlNodeType.Text: node = new XmlText( reader.Value, this.doc ); break; case XmlNodeType.CDATA: node = new XmlCDataSection( reader.Value, this.doc ); break; case XmlNodeType.EntityReference:{ XmlEntityReference eref = new XmlEntityReference( reader.Name, this.doc ); if ( reader.CanResolveEntity ) { reader.ResolveEntity(); LoadEntityChildren( eref ); //what if eref doesn't have children at all? should we just put a Empty String text here? if ( eref.ChildNodes.Count == 0 ) eref.AppendChild( new XmlText("") ); } node = eref; break; } case XmlNodeType.ProcessingInstruction: node = new XmlProcessingInstruction( reader.Name, reader.Value, this.doc ); break; case XmlNodeType.Comment: node = new XmlComment( reader.Value, this.doc ); break; default: throw new InvalidOperationException(string.Format(Res.GetString(Res.Xdom_Load_NodeType),reader.NodeType.ToString())); } return node; }
protected override void ExecuteCore(XmlProcessingInstruction instruction) { instruction.Value = Transform(instruction.Value); }
/// <summary> /// Constructor for CssStyleSheet /// </summary> /// <param name="pi">The XML processing instruction that references the stylesheet</param> /// <param name="origin">The type of stylesheet</param> internal CssStyleSheet(XmlProcessingInstruction pi, CssStyleSheetType origin) : base(pi) { Origin = origin; }
private void AssertData(XmlProcessingInstruction pi, bool requireData) { String data = pi.Data.Trim(); if (data == "" && requireData) { throw new XmlProcessorException("Element '{0}' must have a flag attribute", pi.Name); } else if (data != "") { if (!requireData) { throw new XmlProcessorException("Element '{0}' cannot have any attributes", pi.Name); } } }
/// <summary> /// Compares properties of a processing instruction. /// </summary> private ComparisonResult CompareProcessingInstructions(XmlProcessingInstruction control, XPathContext controlContext, XmlProcessingInstruction test, XPathContext testContext) { ComparisonResult lastResult = Compare(new Comparison(ComparisonType.PROCESSING_INSTRUCTION_TARGET, control, GetXPath(controlContext), control.Target, test, GetXPath(testContext), test.Target)); if (lastResult == ComparisonResult.CRITICAL) { return lastResult; } return Compare(new Comparison(ComparisonType.PROCESSING_INSTRUCTION_DATA, control, GetXPath(controlContext), control.Data, test, GetXPath(testContext), test.Data)); }
private XmlNode LoadNodeDirect() { XmlNode node2; XmlReader reader = this.reader; XmlNode parentNode = null; Label_0009: node2 = null; switch (reader.NodeType) { case XmlNodeType.Element: { bool isEmptyElement = this.reader.IsEmptyElement; XmlElement newChild = new XmlElement(this.reader.Prefix, this.reader.LocalName, this.reader.NamespaceURI, this.doc) { IsEmpty = isEmptyElement }; if (this.reader.MoveToFirstAttribute()) { XmlAttributeCollection attributes = newChild.Attributes; do { XmlAttribute attribute = this.LoadAttributeNodeDirect(); attributes.Append(attribute); }while (reader.MoveToNextAttribute()); } if (!isEmptyElement) { parentNode.AppendChildForLoad(newChild, this.doc); parentNode = newChild; goto Label_01FC; } node2 = newChild; break; } case XmlNodeType.Attribute: node2 = this.LoadAttributeNodeDirect(); break; case XmlNodeType.Text: node2 = new XmlText(this.reader.Value, this.doc); break; case XmlNodeType.CDATA: node2 = new XmlCDataSection(this.reader.Value, this.doc); break; case XmlNodeType.EntityReference: node2 = this.LoadEntityReferenceNode(true); break; case XmlNodeType.ProcessingInstruction: node2 = new XmlProcessingInstruction(this.reader.Name, this.reader.Value, this.doc); break; case XmlNodeType.Comment: node2 = new XmlComment(this.reader.Value, this.doc); break; case XmlNodeType.Whitespace: if (!this.preserveWhitespace) { goto Label_01FC; } node2 = new XmlWhitespace(this.reader.Value, this.doc); break; case XmlNodeType.SignificantWhitespace: node2 = new XmlSignificantWhitespace(this.reader.Value, this.doc); break; case XmlNodeType.EndElement: if (parentNode.ParentNode != null) { parentNode = parentNode.ParentNode; goto Label_01FC; } return(parentNode); case XmlNodeType.EndEntity: goto Label_01FC; default: throw UnexpectedNodeType(this.reader.NodeType); } if (parentNode != null) { parentNode.AppendChildForLoad(node2, this.doc); } else { return(node2); } Label_01FC: if (reader.Read()) { goto Label_0009; } return(null); }
protected override void ExecuteCore(XmlProcessingInstruction instruction) { var section = instruction.OwnerDocument.CreateCDataSection(instruction.Value); instruction.ParentNode.ReplaceChild(section, instruction); }
/// <summary> /// 执行sql /// </summary> /// <param name="strSql"></param> /// <param name="strDataSet"></param> /// <returns></returns> public int ExecQuery(string strSql, ref string strDataSet, string strXSLFileName) { //[2007/12/01]新增 CloseRead(); // end; //[2008/03/13] //if (reader != null) //{ // if (!reader.IsClosed) // { // reader.Close(); // } //} // end; this.command.Connection = this.con as IBM.Data.DB2.DB2Connection; this.command.CommandType = System.Data.CommandType.Text; this.command.Parameters.Clear(); this.command.CommandText = strSql + ""; try { TempReader1 = this.command.ExecuteReader(); XmlDocument doc = new XmlDocument(); XmlNode root; XmlElement node, row; doc.AppendChild(doc.CreateXmlDeclaration("1.0", "GB2312", "")); if (strXSLFileName != null && strXSLFileName != "") { string PI = "type='text/xsl' href='" + strXSLFileName + "'"; System.Xml.XmlProcessingInstruction xmlProcessingInstruction = doc.CreateProcessingInstruction("xml-stylesheet", PI); doc.AppendChild(xmlProcessingInstruction); } root = doc.CreateElement("Table"); doc.AppendChild(root); while (TempReader1.Read()) { row = doc.CreateElement("Row"); for (int i = 0; i < TempReader1.FieldCount; i++) { node = doc.CreateElement("Column"); node.SetAttribute("Name", TempReader1.GetName(i).ToString()); node.InnerText = TempReader1[i].ToString() + ""; row.AppendChild(node); } root.AppendChild(row); } strDataSet = doc.OuterXml; TempReader1.Close(); } catch (IBM.Data.DB2.DB2Exception ex) { this.Err = "执行产生错误!" + ex.Message; this.ErrCode = strSql; this.DBErrCode = 1; this.WriteErr(); return(-1); } catch (Exception ex) { this.Err = "执行语句产生错误!" + ex.Message; this.ErrorException = ex.InnerException + "+ " + ex.Source; this.ErrCode = strSql; this.WriteErr(); return(-1); } WriteDebug("执行查询sql语句!" + strSql); return(0); }
public EditProcessingInstructionName(XmlProcessingInstruction pi, NodeLabelEditEventArgs e) { this.pi = pi; this.p = this.pi.ParentNode; this.node = e.Node as XmlTreeNode; Debug.Assert(this.p != null); name = e.Label; this.newpi = pi.OwnerDocument.CreateProcessingInstruction(name, pi.Data); }
public override XmlNode CloneNode(bool deep) { XmlNode n = new XmlProcessingInstruction(target, data, OwnerDocument); return(n); }
public EditProcessingInstructionName(XmlTreeNode node, string newName) { this.pi = (XmlProcessingInstruction)node.Node; this.p = this.pi.ParentNode; this.node = node; Debug.Assert(this.p != null); name = newName; this.newpi = pi.OwnerDocument.CreateProcessingInstruction(name, pi.Data); }
protected override void ExecuteCore(XmlProcessingInstruction instruction) { instruction.ParentNode.RemoveChild(instruction); }
public void Swap(XmlProcessingInstruction op, XmlProcessingInstruction np) { this.p.InsertBefore(np, op ); this.p.RemoveChild(op); this.node.Node = np; this.node.Label = np.Target; this.node.TreeView.SelectedNode = this.node; }
// LoadNodeDirect does not use creator functions on XmlDocument. It is used loading nodes that are children of entity nodes, // because we do not want to let users extend these (if we would allow this, XmlDataDocument would have a problem, because // they do not know that those nodes should not be mapped). It can be also used for an optimized load path when if the // XmlDocument is not extended if XmlDocumentType and XmlDeclaration handling is added. private XmlNode LoadNodeDirect() { XmlReader r = _reader; XmlNode parent = null; do { XmlNode node = null; switch (r.NodeType) { case XmlNodeType.Element: bool fEmptyElement = _reader.IsEmptyElement; XmlElement element = new XmlElement(_reader.Prefix, _reader.LocalName, _reader.NamespaceURI, _doc); element.IsEmpty = fEmptyElement; if (_reader.MoveToFirstAttribute()) { XmlAttributeCollection attributes = element.Attributes; do { XmlAttribute attr = LoadAttributeNodeDirect(); attributes.Append(attr); // special case for load } while (r.MoveToNextAttribute()); } // recursively load all children. if (!fEmptyElement) { parent.AppendChildForLoad(element, _doc); parent = element; continue; } else { node = element; break; } case XmlNodeType.EndElement: Debug.Assert(parent.NodeType == XmlNodeType.Element); if (parent.ParentNode == null) { return(parent); } parent = parent.ParentNode; continue; case XmlNodeType.EntityReference: node = LoadEntityReferenceNode(true); break; case XmlNodeType.EndEntity: continue; case XmlNodeType.Attribute: node = LoadAttributeNodeDirect(); break; case XmlNodeType.SignificantWhitespace: node = new XmlSignificantWhitespace(_reader.Value, _doc); break; case XmlNodeType.Whitespace: if (_preserveWhitespace) { node = new XmlWhitespace(_reader.Value, _doc); } else { continue; } break; case XmlNodeType.Text: node = new XmlText(_reader.Value, _doc); break; case XmlNodeType.CDATA: node = new XmlCDataSection(_reader.Value, _doc); break; case XmlNodeType.ProcessingInstruction: node = new XmlProcessingInstruction(_reader.Name, _reader.Value, _doc); break; case XmlNodeType.Comment: node = new XmlComment(_reader.Value, _doc); break; default: throw UnexpectedNodeType(_reader.NodeType); } Debug.Assert(node != null); if (parent != null) { parent.AppendChildForLoad(node, _doc); } else { return(node); } }while (r.Read()); return(null); }
public DocumentInformation(XmlProcessingInstruction instruction) { Source = instruction; CurrentVersion = int.Parse(instruction.Value); }