Filters/HtmlAgilityPack/tools.cs

   1 // HtmlAgilityPack V1.0
   2
   3 /*
   4 Copyright (C) 2003 Simon Mourier <simonm@microsoft.com>
   5 All rights reserved.
   6
   7 Redistribution and use in source and binary forms, with or without
   8 modification, are permitted provided that the following conditions
   9 are met:
  10 1. Redistributions of source code must retain the above copyright
  11    notice, this list of conditions and the following disclaimer.
  12 2. Redistributions in binary form must reproduce the above copyright
  13    notice, this list of conditions and the following disclaimer in the
  14    documentation and/or other materials provided with the distribution.
  15 3. The name of the author may not be used to endorse or promote products
  16    derived from this software without specific prior written permission.
  17
  18 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  19 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  20 OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  21 IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  22 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  23 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  27 THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28 */
  29
  30 using System;
  31 using System.Diagnostics;
  32 using System.IO;
  33
  34 namespace HtmlAgilityPack
  35 {
  36         internal struct IOLibrary
  37         {
  38                 internal static void MakeWritable(string path)
  39                 {
  40                         if (!File.Exists(path))
  41                                 return;
  42                         File.SetAttributes(path, File.GetAttributes(path) & ~FileAttributes.ReadOnly);
  43                 }
  44
  45                 internal static void CopyAlways(string source, string target)
  46                 {
  47                         if (!File.Exists(source))
  48                                 return;
  49                         Directory.CreateDirectory(Path.GetDirectoryName(target));
  50                         MakeWritable(target);
  51                         File.Copy(source, target, true);
  52                 }
  53         }
  54
  55         internal struct HtmlLibrary
  56         {
  57                 [Conditional("DEBUG")]
  58                 internal static void GetVersion(ref string version)
  59                 {
  60                         System.Diagnostics.StackFrame sf = new System.Diagnostics.StackFrame(1, true);
  61                         version = sf.GetMethod().DeclaringType.Assembly.GetName().Version.ToString();
  62                 }
  63
  64                 [Conditional("DEBUG")]
  65                 [Conditional("TRACE")]
  66                 internal static void Trace(object Value)
  67                 {
  68                         // category is the method
  69                         string name = null;
  70                         GetCurrentMethodName(2, ref name);
  71                         System.Diagnostics.Trace.WriteLine(Value, name);
  72                 }
  73
  74                 [Conditional("DEBUG")]
  75                 [Conditional("TRACE")]
  76                 internal static void TraceStackFrame(int steps)
  77                 {
  78                         string name = null;
  79                         GetCurrentMethodName(2, ref name);
  80                         string trace = "";
  81                         for(int i=1;i<steps;i++)
  82                         {
  83                                 System.Diagnostics.StackFrame sf = new System.Diagnostics.StackFrame(i, true);
  84                                 trace += sf.ToString();
  85                         }
  86                         System.Diagnostics.Trace.WriteLine(trace, name);
  87                         System.Diagnostics.Trace.WriteLine("");
  88                 }
  89
  90                 [Conditional("DEBUG")]
  91                 internal static void GetCurrentMethodName(ref string name)
  92                 {
  93                         name = null;
  94                         GetCurrentMethodName(2, ref name);
  95                 }
  96
  97                 [Conditional("DEBUG")]
  98                 internal static void GetCurrentMethodName(int skipframe, ref string name)
  99                 {
 100                         StackFrame sf = new StackFrame(skipframe, true);
 101                         name = sf.GetMethod().DeclaringType.Name + "." + sf.GetMethod().Name;
 102                 }
 103
 104         }
 105
 106         internal class HtmlCmdLine
 107         {
 108                 static internal bool Help;
 109
 110                 static HtmlCmdLine()
 111                 {
 112                         Help = false;
 113                         ParseArgs();
 114                 }
 115
 116                 internal static string GetOption(string name, string def)
 117                 {
 118                         string p = def;
 119                         string[] args = Environment.GetCommandLineArgs();
 120                         for (int i=1;i<args.Length;i++)
 121                         {
 122                                 GetStringArg(args[i], name, ref p);
 123                         }
 124                         return p;
 125                 }
 126
 127                 internal static string GetOption(int index, string def)
 128                 {
 129                         string p = def;
 130                         string[] args = Environment.GetCommandLineArgs();
 131                         int j = 0;
 132                         for (int i=1;i<args.Length;i++)
 133                         {
 134                                 if (GetStringArg(args[i], ref p))
 135                                 {
 136                                         if (index==j)
 137                                                 return p;
 138                                         else
 139                                                 p = def;
 140                                         j++;
 141                                 }
 142                         }
 143                         return p;
 144                 }
 145
 146                 internal static bool GetOption(string name, bool def)
 147                 {
 148                         bool p = def;
 149                         string[] args = Environment.GetCommandLineArgs();
 150                         for (int i=1;i<args.Length;i++)
 151                         {
 152                                 GetBoolArg(args[i], name, ref p);
 153                         }
 154                         return p;
 155                 }
 156
 157                 internal static int GetOption(string name, int def)
 158                 {
 159                         int p = def;
 160                         string[] args = Environment.GetCommandLineArgs();
 161                         for (int i=1;i<args.Length;i++)
 162                         {
 163                                 GetIntArg(args[i], name, ref p);
 164                         }
 165                         return p;
 166                 }
 167
 168                 private static void ParseArgs()
 169                 {
 170                         string[] args = Environment.GetCommandLineArgs();
 171                         for (int i=1;i<args.Length;i++)
 172                         {
 173                                 // help
 174                                 GetBoolArg(args[i], "?", ref Help);
 175                                 GetBoolArg(args[i], "h", ref Help);
 176                                 GetBoolArg(args[i], "help", ref Help);
 177                         }
 178                 }
 179
 180                 private static bool GetStringArg(string Arg, ref string ArgValue)
 181                 {
 182                         if (('/'==Arg[0]) || ('-'==Arg[0]))
 183                                 return false;
 184                         ArgValue = Arg;
 185                         return true;
 186                 }
 187
 188                 private static void GetStringArg(string Arg, string Name, ref string ArgValue)
 189                 {
 190                         if (Arg.Length<(Name.Length+3)) // -name:x is 3 more than name
 191                                 return;
 192                         if (('/'!=Arg[0]) && ('-'!=Arg[0]))     // not a param
 193                                 return;
 194                         if (Arg.Substring(1, Name.Length).ToLower()==Name.ToLower())
 195                                 ArgValue = Arg.Substring(Name.Length+2, Arg.Length-Name.Length-2);
 196                 }
 197
 198                 private static void GetBoolArg(string Arg, string Name, ref bool ArgValue)
 199                 {
 200                         if (Arg.Length<(Name.Length+1)) // -name is 1 more than name
 201                                 return;
 202                         if (('/'!=Arg[0]) && ('-'!=Arg[0]))     // not a param
 203                                 return;
 204                         if (Arg.Substring(1, Name.Length).ToLower()==Name.ToLower())
 205                                 ArgValue = true;
 206                 }
 207
 208                 private static void GetIntArg(string Arg, string Name, ref int ArgValue)
 209                 {
 210                         if (Arg.Length<(Name.Length+3)) // -name:12 is 3 more than name
 211                                 return;
 212                         if (('/'!=Arg[0]) && ('-'!=Arg[0]))     // not a param
 213                                 return;
 214                         if (Arg.Substring(1, Name.Length).ToLower()==Name.ToLower())
 215                         {
 216                                 try
 217                                 {
 218                                         ArgValue = Convert.ToInt32(Arg.Substring(Name.Length+2, Arg.Length-Name.Length-2));
 219                                 }
 220                                 catch
 221                                 {
 222                                 }
 223
 224                         }
 225                 }
 226         }
 227
 228         internal class HtmlConsoleListener: System.Diagnostics.TraceListener
 229         {
 230                 public override void WriteLine(string Message)
 231                 {
 232                         Write(Message + "\n");
 233                 }
 234
 235                 public override void Write(string Message)
 236                 {
 237                         Write(Message, "");
 238                 }
 239
 240                 public override void Write(string Message, string Category)
 241                 {
 242                         Console.Write("T:" + Category + ": " + Message);
 243                 }
 244
 245                 public override void WriteLine(string Message, string Category)
 246                 {
 247                         Write(Message + "\n", Category);
 248                 }
 249         }
 250
 251 }