public XmlSchema Add(string ns, XmlReader reader, System.Xml.XmlResolver resolver) { SchemaType type; if (reader == null) { throw new ArgumentNullException("reader"); } XmlNameTable nameTable = reader.NameTable; SchemaInfo schemaInfo = new SchemaInfo(); System.Xml.Schema.Parser parser = new System.Xml.Schema.Parser(SchemaType.None, nameTable, this.GetSchemaNames(nameTable), this.validationEventHandler) { XmlResolver = resolver }; try { type = parser.Parse(reader, ns); } catch (XmlSchemaException exception) { this.SendValidationEvent(exception); return(null); } if (type == SchemaType.XSD) { schemaInfo.SchemaType = SchemaType.XSD; return(this.Add(ns, schemaInfo, parser.XmlSchema, true, resolver)); } SchemaInfo xdrSchema = parser.XdrSchema; return(this.Add(ns, parser.XdrSchema, null, true, resolver)); }
internal XmlQueryContext(XmlQueryRuntime runtime, object defaultDataSource, XmlResolver dataSources, XsltArgumentList argList, WhitespaceRuleLookup wsRules) { this.runtime = runtime; this.dataSources = dataSources; this.dataSourceCache = new Hashtable(); this.argList = argList; this.wsRules = wsRules; if (defaultDataSource is XmlReader) { this.readerSettings = new QueryReaderSettings((XmlReader) defaultDataSource); } else { // Consider allowing users to set DefaultReaderSettings in XsltArgumentList // readerSettings = argList.DefaultReaderSettings; this.readerSettings = new QueryReaderSettings(new NameTable()); } if (defaultDataSource is string) { // Load the default document from a Uri this.defaultDataSource = GetDataSource(defaultDataSource as string, null); if (this.defaultDataSource == null) throw new XslTransformException(Res.XmlIl_UnknownDocument, defaultDataSource as string); } else if (defaultDataSource != null) { this.defaultDataSource = ConstructDocument(defaultDataSource, null, null); } }
/// <summary> /// Loads the XSLT file using specified path, settings and stylesheet resolver. /// </summary> /// <param name="path">The URL to the XSLT file.</param> /// <param name="settings">XSLT settings.</param> /// <param name="stylesheetResolver">The stylesheet resolver.</param> /// <returns><see cref="XslCompiledTransform" /> object that can transform the input.</returns> public virtual XslCompiledTransform LoadXslt(string path, XsltSettings settings, XmlResolver stylesheetResolver) { var xslt = new XslCompiledTransform(); xslt.Load(path, settings, stylesheetResolver); return xslt; }
public XmlReader Transform(XPathNavigator input, XsltArgumentList args, System.Xml.XmlResolver resolver) { this.CheckCommand(); Processor processor = new Processor(input, args, resolver, this._CompiledStylesheet, this._QueryStore, this._RootAction, this.debugger); return(processor.StartReader()); }
private void RecurseNode(XmlDocument doc, XmlResolver resolver, XmlNode elementNode, string xsltName) { this.ElementToHTMLPage(doc,resolver,elementNode,xsltName); foreach(XmlNode childNode in elementNode) { if(childNode.Name == "Glossary") { this.ElementToHTMLPage(doc,resolver,childNode,"Glossary.xsl"); } if(childNode.Name == "Packages") { foreach(XmlNode packageNode in childNode.ChildNodes) { this.RecurseNode(doc,resolver,packageNode,"Package.xsl"); } } if(childNode.Name == "Actors") { foreach(XmlNode actorNode in childNode.ChildNodes) { this.RecurseNode(doc,resolver,actorNode,"Actor.xsl"); } } if(childNode.Name == "UseCases") { foreach(XmlNode useCaseNode in childNode.ChildNodes) { this.RecurseNode(doc,resolver,useCaseNode,"UseCase.xsl"); } } } }
/// <summary> /// Initializes the writer to write redirected output. /// </summary> /// <remarks>Depending on the <c>method</c> attribute value, /// <c>XmlTextWriter</c> or <c>StreamWriter</c> is created. /// <c>XmlTextWriter</c> is used for outputting XML and /// <c>StreamWriter</c> - for plain text. /// </remarks> public void InitWriter(XmlResolver outResolver) { if (outResolver == null) { outResolver = new OutputResolver(Directory.GetCurrentDirectory()); } // Save current directory //storedDir = Directory.GetCurrentDirectory(); string outFile = outResolver.ResolveUri(null, href).LocalPath; DirectoryInfo dir = Directory.GetParent(outFile); if (!dir.Exists) dir.Create(); // Create writer if (method == OutputMethod.Xml) { xmlWriter = new XmlTextWriter(outFile, encoding); if (indent) xmlWriter.Formatting = Formatting.Indented; if (!omitXmlDecl) { if (standalone) xmlWriter.WriteStartDocument(true); else xmlWriter.WriteStartDocument(); } } else textWriter = new StreamWriter(outFile, false, encoding); // Set new current directory //Directory.SetCurrentDirectory(dir.ToString()); href = ""; // clean the href for the next usage }
public static CompilerErrorCollection CompileToType(XmlReader stylesheet, XsltSettings settings, XmlResolver stylesheetResolver, bool debug, TypeBuilder typeBuilder, string scriptAssemblyPath) { QilExpression expression; if (stylesheet == null) { throw new ArgumentNullException("stylesheet"); } if (typeBuilder == null) { throw new ArgumentNullException("typeBuilder"); } if (settings == null) { settings = XsltSettings.Default; } if (settings.EnableScript && (scriptAssemblyPath == null)) { throw new ArgumentNullException("scriptAssemblyPath"); } if (scriptAssemblyPath != null) { scriptAssemblyPath = Path.GetFullPath(scriptAssemblyPath); } CompilerErrorCollection errors = new Compiler(settings, debug, scriptAssemblyPath).Compile(stylesheet, stylesheetResolver, out expression).Errors; if (!errors.HasErrors) { if (GeneratedCodeCtor == null) { GeneratedCodeCtor = typeof(GeneratedCodeAttribute).GetConstructor(new Type[] { typeof(string), typeof(string) }); } typeBuilder.SetCustomAttribute(new CustomAttributeBuilder(GeneratedCodeCtor, new object[] { typeof(XslCompiledTransform).FullName, "4.0.0.0" })); new XmlILGenerator().Generate(expression, typeBuilder); } return errors; }
public void Load(IXPathNavigable stylesheet, System.Xml.XmlResolver resolver) { if (stylesheet == null) { throw new ArgumentNullException("stylesheet"); } this.Load(stylesheet.CreateNavigator(), resolver); }
public NvdlValidatingReader (XmlReader reader, NvdlRules rules, XmlResolver resolver, NvdlConfig config) : base (reader) { dispatcher = new NvdlDispatcher (new SimpleRules ( new NvdlCompileContext ( rules, config, resolver)), this); }
internal XslTransform(object debugger) { this._XmlResolver = new XmlUrlResolver(); if (debugger != null) { this.debugger = new DebuggerAddapter(debugger); } }
private void Execute(object defaultDocument, XmlResolver dataSources, XsltArgumentList argumentList, XmlSequenceWriter results) { if (dataSources == null) { dataSources = XmlNullResolver.Singleton; } this.delExec(new XmlQueryRuntime(this.staticData, defaultDocument, dataSources, argumentList, results)); }
public XmlSecureResolver ( XmlResolver resolver, Evidence evidence) { this.resolver = resolver; if (SecurityManager.SecurityEnabled) { this.permissionSet = SecurityManager.ResolvePolicy (evidence); } }
/// <summary> /// Creates XmlTransformingReader with given XmlReader, stylesheet URI, /// XsltArgumentList and Xmlresolver. /// </summary> /// <param name="parentReader">Source XML as XmlReader</param> /// <param name="transformSource">URI of the stylesheet to transform the source</param> /// <param name="args">Arguments to the transformation</param> /// <param name="resolver">XmlResolver to resolve URIs in document() function</param> public XmlTransformingReader(XmlReader parentReader, string transformSource, XsltArgumentList args, XmlResolver resolver) { XPathDocument doc = new XPathDocument(parentReader); XslTransform xslt = new XslTransform(); xslt.Load(transformSource); _outReader = xslt.Transform(doc, args, resolver); }
protected Transform () { // if (SecurityManager.SecurityEnabled) { // xmlResolver = new XmlSecureResolver (new XmlUrlResolver (), (Evidence) new Evidence ()); // } else { xmlResolver = new XmlUrlResolver (); // } }
public void Load(XPathNavigator stylesheet, System.Xml.XmlResolver resolver) { if (stylesheet == null) { throw new ArgumentNullException("stylesheet"); } this.Compile(stylesheet, resolver, null); }
public void Load(XmlReader stylesheet, System.Xml.XmlResolver resolver, Evidence evidence) { if (stylesheet == null) { throw new ArgumentNullException("stylesheet"); } this.Load(new XPathDocument(stylesheet, XmlSpace.Preserve), resolver, evidence); }
public XmlReader Transform(IXPathNavigable input, XsltArgumentList args, System.Xml.XmlResolver resolver) { if (input == null) { throw new ArgumentNullException("input"); } return(this.Transform(input.CreateNavigator(), args, resolver)); }
public Transform () { // FIXME: enable it after CAS implementation #if false // NET_1_1 xmlResolver = new XmlSecureResolver (new XmlUrlResolver (), (Evidence) new Evidence ()); #else xmlResolver = new XmlUrlResolver (); #endif }
internal CanonicalXml(XmlDocument document, XmlResolver resolver, bool includeComments) { if (document == null) throw new ArgumentNullException("document"); m_c14nDoc = new CanonicalXmlDocument(true, includeComments); m_c14nDoc.XmlResolver = resolver; m_c14nDoc.Load(new XmlNodeReader(document)); m_ancMgr = new C14NAncestralNamespaceContextManager(); }
internal ExcCanonicalXml(XmlDocument document, bool includeComments, string inclusiveNamespacesPrefixList, XmlResolver resolver) { if (document == null) throw new ArgumentNullException("document"); m_c14nDoc = new CanonicalXmlDocument(true, includeComments); m_c14nDoc.XmlResolver = resolver; m_c14nDoc.Load(new XmlNodeReader(document)); m_ancMgr = new ExcAncestralNamespaceContextManager(inclusiveNamespacesPrefixList); }
internal static XmlDocument TransformToDocument( XmlReader input, XslCompiledTransform transform, XsltArgumentList args, XmlResolver resolver ) { XmlDocument doc = new XmlDocument( ); using( XmlWriter output = doc.CreateNavigator().AppendChild() ) { transform.Transform( input, args, output, resolver ); } return doc; }
internal ExcCanonicalXml(Stream inputStream, bool includeComments, string inclusiveNamespacesPrefixList, XmlResolver resolver, string strBaseUri) { if (inputStream == null) throw new ArgumentNullException("inputStream"); m_c14nDoc = new CanonicalXmlDocument(true, includeComments); m_c14nDoc.XmlResolver = resolver; m_c14nDoc.Load(Utils.PreProcessStreamInput(inputStream, resolver, strBaseUri)); m_ancMgr = new ExcAncestralNamespaceContextManager(inclusiveNamespacesPrefixList); }
internal XmlOutput(XslTransform transform, XsltArgumentList xsltArgs, XPathNavigator navigator, XmlResolver resolverForXmlTransformed, XmlReader[] readersToClose) { _transform = transform; _xsltArgs = xsltArgs; _navigator = navigator; _resolverForXmlTransformed = resolverForXmlTransformed; _readersToClose = readersToClose; }
public Transform () #endif { if (SecurityManager.SecurityEnabled) { xmlResolver = new XmlSecureResolver (new XmlUrlResolver (), (Evidence) new Evidence ()); } else { xmlResolver = new XmlUrlResolver (); } }
public void ReadXml(XPathNavigator node, XmlResolver resolver) { if (node.NodeType == XPathNodeType.Element) { if (node.MoveToFirstAttribute()) { do { switch (node.LocalName) { case "media-type": this.MediaType = node.Value; break; case "boundary": this.Boundary = node.Value; break; } } while (node.MoveToNextAttribute()); node.MoveToParent(); } if (node.MoveToChild(XPathNodeType.Element)) { XPathHttpMultipartItem currentItem = null; do { if (node.NamespaceURI == XPathHttpClient.Namespace) { switch (node.LocalName) { case "header": if (currentItem == null) { currentItem = new XPathHttpMultipartItem(); } currentItem.Headers.Add(node.GetAttribute("name", ""), node.GetAttribute("value", "")); break; case "body": if (currentItem == null) { currentItem = new XPathHttpMultipartItem(); } currentItem.Body = new XPathHttpBody(); currentItem.Body.ReadXml(node, resolver); this.Items.Add(currentItem); currentItem = null; break; } } } while (node.MoveToNext(XPathNodeType.Element)); node.MoveToParent(); } } }
public Parser(SchemaType schemaType, XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler) { this.schemaType = schemaType; this.nameTable = nameTable; this.schemaNames = schemaNames; this.eventHandler = eventHandler; this.xmlResolver = new XmlUrlResolver(); this.processMarkup = true; this.dummyDocument = new XmlDocument(); }
public XmlValidatingReader (XmlReader reader) { sourceReader = reader; xmlTextReader = reader as XmlTextReader; if (xmlTextReader == null) resolver = new XmlUrlResolver (); entityHandling = EntityHandling.ExpandEntities; validationType = ValidationType.Auto; storedCharacters = new StringBuilder (); }
/// <summary> /// This should be a part of the I/O layer /// </summary> public static void LoadFromPath(this XslCompiledTransform xslCompiledTransform, string path, XsltSettings settings, XmlResolver stylesheetResolver) { using (C1StreamReader streamReader = new C1StreamReader(path)) { using (XmlReader xmlReader = XmlReader.Create(streamReader)) { xslCompiledTransform.Load(xmlReader, settings, stylesheetResolver); } } }
private void Compile(XPathNavigator stylesheet, System.Xml.XmlResolver resolver, Evidence evidence) { Compiler compiler = (this.Debugger == null) ? new Compiler() : new DbgCompiler(this.Debugger); NavigatorInput input = new NavigatorInput(stylesheet); compiler.Compile(input, resolver ?? XmlNullResolver.Singleton, evidence); this._CompiledStylesheet = compiler.CompiledStylesheet; this._QueryStore = compiler.QueryStore; this._RootAction = compiler.RootAction; }
public void Load(string url, System.Xml.XmlResolver resolver) { XmlTextReaderImpl reader = new XmlTextReaderImpl(url) { XmlResolver = resolver }; Evidence evidence = XmlSecureResolver.CreateEvidenceForUrl(reader.BaseURI); this.Compile(Compiler.LoadDocument(reader).CreateNavigator(), resolver, evidence); }
public EncryptedXml(XmlDocument document, Evidence evidence) { this.m_document = document; this.m_evidence = evidence; this.m_xmlResolver = null; this.m_padding = PaddingMode.ISO10126; this.m_mode = CipherMode.CBC; this.m_encoding = System.Text.Encoding.UTF8; this.m_keyNameMapping = new Hashtable(4); }
public override XmlReader CreateValidator (XmlReader reader, XmlResolver resolver) { // XmlResolver is never used. RelaxngValidatingReader rvr = new RelaxngValidatingReader ( reader, pattern); rvr.ReportDetails = true; return rvr; }
public BaseValidator(BaseValidator other) { reader = other.reader; schemaCollection = other.schemaCollection; eventHandling = other.eventHandling; nameTable = other.nameTable; schemaNames = other.schemaNames; positionInfo = other.positionInfo; xmlResolver = other.xmlResolver; baseUri = other.baseUri; elementName = other.elementName; }
internal CanonicalXml(Stream inputStream, bool includeComments, XmlResolver resolver, string strBaseUri) { if (inputStream == null) { throw new ArgumentNullException("inputStream"); } this.m_c14nDoc = new CanonicalXmlDocument(true, includeComments); this.m_c14nDoc.XmlResolver = resolver; this.m_c14nDoc.Load(System.Security.Cryptography.Xml.Utils.PreProcessStreamInput(inputStream, resolver, strBaseUri)); this.m_ancMgr = new C14NAncestralNamespaceContextManager(); }
/// <summary> /// Gets an appropriate <see cref="System.Xml.XmlReader"/> implementation /// for the supplied <see cref="System.IO.Stream"/>. /// </summary> /// <param name="stream">The XML <see cref="System.IO.Stream"/> that is going to be read.</param> /// <param name="xmlResolver"><see cref="XmlResolver"/> to be used for resolving external references</param> /// <param name="schemas">XML schemas that should be used for validation.</param> /// <param name="eventHandler">Validation event handler.</param> /// <returns> /// A validating <see cref="System.Xml.XmlReader"/> implementation. /// </returns> public static XmlReader CreateValidatingReader(Stream stream, XmlResolver xmlResolver, XmlSchemaCollection schemas, ValidationEventHandler eventHandler) { XmlValidatingReader reader = new XmlValidatingReader(new XmlTextReader(stream)); reader.XmlResolver = xmlResolver; reader.Schemas.Add(schemas); reader.ValidationType = ValidationType.Schema; if (eventHandler != null) { reader.ValidationEventHandler += eventHandler; } return reader; }
public override XmlReader CreateValidator (XmlReader reader, XmlResolver resolver) { XmlReaderSettings s = new XmlReaderSettings (); s.ValidationType = ValidationType.Schema; // do not allow inline schema and schemaLocation. s.ValidationFlags = XmlSchemaValidationFlags.ProcessIdentityConstraints; s.XmlResolver = resolver; foreach (XmlSchema schema in schemas) s.Schemas.Add (schema); return XmlReader.Create (reader, s); }
public XmlSchema Add(XmlSchema schema, System.Xml.XmlResolver resolver) { if (schema == null) { throw new ArgumentNullException("schema"); } SchemaInfo schemaInfo = new SchemaInfo { SchemaType = SchemaType.XSD }; return(this.Add(schema.TargetNamespace, schemaInfo, schema, true, resolver)); }
public BaseValidator(BaseValidator other) { this.reader = other.reader; this.schemaCollection = other.schemaCollection; this.eventHandling = other.eventHandling; this.nameTable = other.nameTable; this.schemaNames = other.schemaNames; this.positionInfo = other.positionInfo; this.xmlResolver = other.xmlResolver; this.baseUri = other.baseUri; this.elementName = other.elementName; }
public BaseValidator(BaseValidator other) { reader = other.reader; _schemaCollection = other._schemaCollection; _eventHandling = other._eventHandling; _nameTable = other._nameTable; _schemaNames = other._schemaNames; _positionInfo = other._positionInfo; _xmlResolver = other._xmlResolver; _baseUri = other._baseUri; elementName = other.elementName; }
private static void PrepareSerializer() { lock (xmlSerializerSync) { if (xmlSerializer == null) { xmlSerializer = new XmlSerializer(typeof(oval_variables)); xmlResolver = new ExtensibleXmlResourceResolver(); } } }
public void Load(XPathNavigator stylesheet, System.Xml.XmlResolver resolver, Evidence evidence) { if (stylesheet == null) { throw new ArgumentNullException("stylesheet"); } if (evidence == null) { evidence = new Evidence(); } else { new SecurityPermission(SecurityPermissionFlag.ControlEvidence).Demand(); } this.Compile(stylesheet, resolver, evidence); }
public XmlSchemaCollection(XmlNameTable nametable) { this.timeout = -1; this.isThreadSafe = true; if (nametable == null) { throw new ArgumentNullException("nametable"); } this.nameTable = nametable; this.collection = Hashtable.Synchronized(new Hashtable()); this.xmlResolver = new XmlUrlResolver(); this.isThreadSafe = true; if (this.isThreadSafe) { this.wLock = new ReaderWriterLock(); } }
public void Transform(string inputfile, string outputfile, System.Xml.XmlResolver resolver) { FileStream stream = null; try { XPathDocument document = new XPathDocument(inputfile); stream = new FileStream(outputfile, FileMode.Create, FileAccess.ReadWrite); this.Transform((IXPathNavigable)document, null, (Stream)stream, resolver); } finally { if (stream != null) { stream.Close(); } } }
public XmlSchema Add(string targetNamespace, string schemaUri) { if ((schemaUri == null) || (schemaUri.Length == 0)) { throw new ArgumentNullException("schemaUri"); } if (targetNamespace != null) { targetNamespace = XmlComplianceUtil.CDataNormalize(targetNamespace); } XmlSchema schema = null; lock (this.InternalSyncObject) { System.Xml.XmlResolver xmlResolver = this.readerSettings.GetXmlResolver(); if (xmlResolver == null) { xmlResolver = new XmlUrlResolver(); } Uri uri = xmlResolver.ResolveUri(null, schemaUri); if (this.IsSchemaLoaded(uri, targetNamespace, out schema)) { return(schema); } XmlReader reader = XmlReader.Create(schemaUri, this.readerSettings); try { schema = this.Add(targetNamespace, this.ParseSchema(targetNamespace, reader)); while (reader.Read()) { } } finally { reader.Close(); } } return(schema); }
XmlReaderSettings MakeReaderSettings(System.Xml.XmlResolver resolver, ValidationEventHandler errorHandler) { XmlReaderSettings settings = null; settings = new XmlReaderSettings(); settings.CheckCharacters = true; settings.ConformanceLevel = ConformanceLevel.Document; settings.IgnoreComments = true; settings.NameTable = _nameTable; settings.ValidationFlags = XmlSchemaValidationFlags.ReportValidationWarnings; #pragma warning disable 612, 618 settings.ValidationType = _requiresDtd == XhtmlDTDSpecification.None ? ValidationType.Auto : ValidationType.DTD; #pragma warning restore 612, 618 settings.ValidationEventHandler += errorHandler; #if NET20 || NET35 settings.ProhibitDtd = false; #else settings.DtdProcessing = DtdProcessing.Parse; #endif settings.XmlResolver = resolver; return(settings); }
private void GenerateFile() { _PollutantFile = PollutantXSLTFile; string allPollutantsfile = AllPollutantXMLFile; // Execute the transformation. XslCompiledTransform xsltNew = new XslCompiledTransform(); //xsltNew.Load(_PollutantFile); XsltSettings xsltSettings = new XsltSettings(); xsltSettings.EnableDocumentFunction = true; System.Xml.XmlResolver styleSheetResolver = null; xsltNew.Load(_PollutantFile, xsltSettings, styleSheetResolver); // Create the XsltArgumentList. XsltArgumentList argList = new XsltArgumentList(); argList.AddParam("language", "", SetLanguage()); MemoryStream ms = new MemoryStream(); xsltNew.Transform(new System.Xml.XPath.XPathDocument(allPollutantsfile), argList, ms); ms.Flush(); ms.Position = 0; StreamReader sr = new StreamReader(ms); string s = sr.ReadToEnd(); string myTest = ms.ToString(); string cacheName = HTMLFilePath(); AddToCache(cacheName, s); }
public void Transform(XPathNavigator input, XsltArgumentList args, XmlWriter output, System.Xml.XmlResolver resolver) { this.CheckCommand(); new Processor(input, args, resolver, this._CompiledStylesheet, this._QueryStore, this._RootAction, this.debugger).Execute(output); }
public XmlReaderSettings(XmlResolver resolver) { Initialize(resolver); }
public XslTransform() { this._XmlResolver = new XmlUrlResolver(); }
public XmlSecureResolver(XmlResolver resolver, string?securityUrl) { _resolver = resolver; }
public void Transform(IXPathNavigable input, XsltArgumentList args, XmlWriter output, System.Xml.XmlResolver resolver) { if (input == null) { throw new ArgumentNullException("input"); } this.Transform(input.CreateNavigator(), args, output, resolver); }
private XmlSchema Add(string ns, SchemaInfo schemaInfo, XmlSchema schema, bool compile, System.Xml.XmlResolver resolver) { int num = 0; if (schema != null) { if ((schema.ErrorCount == 0) && compile) { if (!schema.CompileSchema(this, resolver, schemaInfo, ns, this.validationEventHandler, this.nameTable, true)) { num = 1; } ns = (schema.TargetNamespace == null) ? string.Empty : schema.TargetNamespace; } num += schema.ErrorCount; } else { num += schemaInfo.ErrorCount; ns = this.NameTable.Add(ns); } if (num == 0) { XmlSchemaCollectionNode node = new XmlSchemaCollectionNode { NamespaceURI = ns, SchemaInfo = schemaInfo, Schema = schema }; this.Add(ns, node); return(schema); } return(null); }
public void Load(XmlReader stylesheet, System.Xml.XmlResolver resolver) { this.Load(new XPathDocument(stylesheet, XmlSpace.Preserve), resolver); }