tools/mono-xmltool/xmltool.cs

   1 using System;
   2 using System.IO;
   3 using System.Text;
   4 using System.Xml;
   5 using System.Xml.Schema;
   6 using System.Xml.Xsl;
   7 using System.Xml.XPath;
   8 #if !TARGET_JVM && !MSNET
   9 using Commons.Xml.Nvdl;
  10 using Commons.Xml.Relaxng;
  11 using Commons.Xml.Relaxng.Rnc;
  12 #endif
  13 using XSchema = System.Xml.Schema.XmlSchema;
  14
  15 namespace Commons.Xml.Relaxng
  16 {
  17         public class Driver
  18         {
  19                 public static void Main (string [] args)
  20                 {
  21                         try {
  22                                 Run (args);
  23                         } catch (Exception ex) {
  24                                 if (Environment.GetEnvironmentVariable ("MONO_XMLTOOL_ERROR_DETAILS") == "yes")
  25                                         Console.Error.WriteLine (ex);
  26                                 else
  27                                         Console.Error.WriteLine (ex.Message);
  28                         }
  29                 }
  30
  31                 static void Usage ()
  32                 {
  33                         Console.Error.WriteLine (@"
  34 Usage: mono-xmltool [options]
  35
  36 options:
  37
  38         --validate [*.rng | *.rnc | *.nvdl | *.xsd] [instances]
  39         --validate-rng relax-ng-grammar-xml [instances]
  40         --validate-rnc relax-ng-compact-grammar-file [instances]
  41         --validate-nvdl nvdl-script-xml [instances]
  42         --validate-xsd xml-schema [instances]
  43         --validate-xsd2 xml-schema [instances] (in .NET 2.0 validator)
  44         --validate-dtd instances
  45         --transform stylesheet instance-xml [output-xml]
  46         --prettyprint [source] [result]
  47
  48 environment variable that affects behavior:
  49
  50         MONO_XMLTOOL_ERROR_DETAILS = yes : to get exception details.
  51 ");
  52                 }
  53
  54                 static void Run (string [] args)
  55                 {
  56                         if (args.Length == 0) {
  57                                 Usage ();
  58                                 return;
  59                         }
  60
  61                         switch (args [0]) {
  62                         default:
  63                         case "--help":
  64                                 Usage ();
  65                                 return;
  66 #if !TARGET_JVM && !MSNET
  67                         case "--validate":
  68                                 ValidateAuto (args);
  69                                 return;
  70                         case "--validate-rnc":
  71                                 ValidateRelaxngCompact (args);
  72                                 return;
  73                         case "--validate-rng":
  74                                 ValidateRelaxngXml (args);
  75                                 return;
  76                         case "--validate-nvdl":
  77                                 ValidateNvdl (args);
  78                                 return;
  79 #endif
  80                         case "--validate-xsd2":
  81                                 ValidateXsd2 (args);
  82                                 return;
  83                         case "--validate-xsd":
  84                                 ValidateXsd (args);
  85                                 return;
  86                         case "--validate-dtd":
  87                                 ValidateDtd (args);
  88                                 return;
  89                         case "--transform":
  90                                 Transform (args);
  91                                 return;
  92                         case "--prettyprint":
  93                                 PrettyPrint (args);
  94                                 return;
  95                         }
  96                 }
  97
  98 #if !TARGET_JVM && !MSNET
  99                 static void ValidateAuto (string [] args)
 100                 {
 101                         if (args.Length < 1) {
 102                                 Usage ();
 103                                 return;
 104                         }
 105
 106                         if (args [1].EndsWith ("rng"))
 107                                 ValidateRelaxngXml (args);
 108                         else if (args [1].EndsWith ("rnc"))
 109                                 ValidateRelaxngCompact (args);
 110                         else if (args [1].EndsWith ("nvdl"))
 111                                 ValidateNvdl (args);
 112                         else if (args [1].EndsWith ("xsd"))
 113                                 ValidateXsd (args);
 114                 }
 115
 116                 static void ValidateRelaxngXml (string [] args)
 117                 {
 118                         XmlReader xr = new XmlTextReader (args [1]);
 119                         RelaxngPattern p = RelaxngPattern.Read (xr);
 120                         xr.Close ();
 121                         ValidateRelaxng (p, args);
 122                 }
 123
 124                 static void ValidateRelaxngCompact (string [] args)
 125                 {
 126                         StreamReader sr = new StreamReader (args [1]);
 127                         RelaxngPattern p = RncParser.ParseRnc (sr, null, Path.GetFullPath (args [1]));
 128                         sr.Close ();
 129                         ValidateRelaxng (p, args);
 130                 }
 131
 132                 static void ValidateRelaxng (RelaxngPattern p, string [] args)
 133                 {
 134                         p.Compile ();
 135
 136                         if (args.Length < 2)
 137                                 return;
 138
 139                         for (int i = 2; i < args.Length; i++) {
 140                                 XmlTextReader xtr = new XmlTextReader (args [i]);
 141                                 RelaxngValidatingReader vr =
 142                                         new RelaxngValidatingReader (xtr, p);
 143                                 if (Environment.GetEnvironmentVariable ("MONO_XMLTOOL_ERROR_DETAILS") == "yes")
 144                                         vr.ReportDetails = true;
 145                                 else
 146                                         vr.InvalidNodeFound += delegate (XmlReader source, string message) {
 147                                                 IXmlLineInfo li = source as IXmlLineInfo;
 148                                                 Console.WriteLine ("ERROR: {0} (at {1} line {2} column {3})",
 149                                                         message,
 150                                                         source.BaseURI,
 151                                                         li != null && li.HasLineInfo () ? li.LineNumber : 0,
 152                                                         li != null && li.HasLineInfo () ? li.LinePosition : 0);
 153                                                 return true;
 154                                         };
 155
 156                                 while (!vr.EOF)
 157                                         vr.Read ();
 158                         }
 159                 }
 160
 161                 static void ValidateNvdl (string [] args)
 162                 {
 163                         XmlTextReader nvdlxtr = new XmlTextReader (args [1]);
 164                         NvdlRules nvdl = NvdlReader.Read (nvdlxtr);
 165                         nvdlxtr.Close ();
 166                         for (int i = 2; i < args.Length; i++) {
 167                                 XmlTextReader xtr = new XmlTextReader (args [i]);
 168                                 NvdlValidatingReader nvr = new NvdlValidatingReader (xtr, nvdl);
 169                                 while (!nvr.EOF)
 170                                         nvr.Read ();
 171                                 xtr.Close ();
 172                         }
 173                 }
 174 #endif
 175
 176                 static void ValidateXsd (string [] args)
 177                 {
 178                         XmlTextReader schemaxml = new XmlTextReader (args [1]);
 179                         XSchema xsd = XSchema.Read (schemaxml, null);
 180                         schemaxml.Close ();
 181                         xsd.Compile (null);
 182                         for (int i = 2; i < args.Length; i++) {
 183                                 XmlTextReader xtr = new XmlTextReader (args [i]);
 184                                 XmlValidatingReader xvr = new XmlValidatingReader (xtr);
 185                                 xvr.Schemas.Add (xsd);
 186                                 while (!xvr.EOF)
 187                                         xvr.Read ();
 188                                 xvr.Close ();
 189                         }
 190                 }
 191
 192                 static void ValidateXsd2 (string [] args)
 193                 {
 194                         XmlReaderSettings s = new XmlReaderSettings ();
 195                         s.ValidationType = ValidationType.Schema;
 196                         s.Schemas.Add (null, args [1]);
 197                         for (int i = 2; i < args.Length; i++) {
 198                                 XmlReader xr = XmlReader.Create (args [i], s);
 199                                 while (!xr.EOF)
 200                                         xr.Read ();
 201                                 xr.Close ();
 202                         }
 203                 }
 204
 205                 static void ValidateDtd (string [] args)
 206                 {
 207                         for (int i = 1; i < args.Length; i++) {
 208                                 XmlValidatingReader xvr = new XmlValidatingReader (
 209                                         new XmlTextReader (args [i]));
 210                                 xvr.ValidationType = ValidationType.DTD;
 211                                 xvr.EntityHandling = EntityHandling.ExpandEntities;
 212                                 while (!xvr.EOF)
 213                                         xvr.Read ();
 214                                 xvr.Close ();
 215                         }
 216                 }
 217
 218                 static void Transform (string [] args)
 219                 {
 220                         XslTransform t = new XslTransform ();
 221                         t.Load (args [1]);
 222                         TextWriter output = args.Length > 3 ?
 223                                 File.CreateText (args [3]) : Console.Out;
 224                         t.Transform (new XPathDocument (args [2], XmlSpace.Preserve), null, output, null);
 225                         output.Close ();
 226                 }
 227
 228                 static void PrettyPrint (string [] args)
 229                 {
 230                         XmlTextReader r = null;
 231                         if (args.Length > 1)
 232                                 r = new XmlTextReader (args [1]);
 233                         else
 234                                 r = new XmlTextReader (Console.In);
 235                         r.WhitespaceHandling = WhitespaceHandling.Significant;
 236                         XmlTextWriter w = null;
 237                         if (args.Length > 2)
 238                                 w = new XmlTextWriter (args [1], Encoding.UTF8);
 239                         else
 240                                 w = new XmlTextWriter (Console.Out);
 241                         w.Formatting = Formatting.Indented;
 242
 243                         r.Read ();
 244                         while (!r.EOF)
 245                                 w.WriteNode (r, false);
 246                         r.Close ();
 247                         w.Close ();
 248                 }
 249         }
 250 }
 251