tool/Replace.cs

   1 /*
   2 ** 2016 February 26
   3 **
   4 ** The author disclaims copyright to this source code.  In place of
   5 ** a legal notice, here is a blessing:
   6 **
   7 **    May you do good and not evil.
   8 **    May you find forgiveness for yourself and forgive others.
   9 **    May you share freely, never taking more than you give.
  10 **
  11 *************************************************************************
  12 ** This file contains C# code to perform regular expression replacements
  13 ** using the standard input and output channels.
  14 */
  15
  16 using System;
  17 using System.Diagnostics;
  18 using System.IO;
  19 using System.Reflection;
  20 using System.Runtime.InteropServices;
  21 using System.Text.RegularExpressions;
  22
  23 ///////////////////////////////////////////////////////////////////////////////
  24
  25 #region Assembly Metadata
  26 [assembly: AssemblyTitle("Replace Tool")]
  27 [assembly: AssemblyDescription("Replace text using standard input/output.")]
  28 [assembly: AssemblyCompany("SQLite Development Team")]
  29 [assembly: AssemblyProduct("SQLite")]
  30 [assembly: AssemblyCopyright("Public Domain")]
  31 [assembly: ComVisible(false)]
  32 [assembly: Guid("95a0513f-8863-48cd-a76f-cb80868cb578")]
  33 [assembly: AssemblyVersion("1.0.*")]
  34
  35 #if DEBUG
  36 [assembly: AssemblyConfiguration("Debug")]
  37 #else
  38 [assembly: AssemblyConfiguration("Release")]
  39 #endif
  40 #endregion
  41
  42 ///////////////////////////////////////////////////////////////////////////////
  43
  44 namespace Replace
  45 {
  46     /// <summary>
  47     /// This enumeration is used to represent all the possible exit codes from
  48     /// this tool.
  49     /// </summary>
  50     internal enum ExitCode
  51     {
  52         /// <summary>
  53         /// The file download was a success.
  54         /// </summary>
  55         Success = 0,
  56
  57         /// <summary>
  58         /// The command line arguments are missing (i.e. null).  Generally,
  59         /// this should not happen.
  60         /// </summary>
  61         MissingArgs = 1,
  62
  63         /// <summary>
  64         /// The wrong number of command line arguments was supplied.
  65         /// </summary>
  66         WrongNumArgs = 2,
  67
  68         /// <summary>
  69         /// The "matchingOnly" flag could not be converted to a value of the
  70         /// <see cref="Boolean"/> type.
  71         /// </summary>
  72         BadMatchingOnlyFlag = 3,
  73
  74         /// <summary>
  75         /// An exception was caught in <see cref="Main" />.  Generally, this
  76         /// should not happen.
  77         /// </summary>
  78         Exception = 4
  79     }
  80
  81     ///////////////////////////////////////////////////////////////////////////
  82
  83     internal static class Replace
  84     {
  85         #region Private Support Methods
  86         /// <summary>
  87         /// This method displays an error message to the console and/or
  88         /// displays the command line usage information for this tool.
  89         /// </summary>
  90         /// <param name="message">
  91         /// The error message to display, if any.
  92         /// </param>
  93         /// <param name="usage">
  94         /// Non-zero to display the command line usage information.
  95         /// </param>
  96         private static void Error(
  97             string message,
  98             bool usage
  99             )
 100         {
 101             if (message != null)
 102                 Console.WriteLine(message);
 103
 104             string fileName = Path.GetFileName(
 105                 Process.GetCurrentProcess().MainModule.FileName);
 106
 107             Console.WriteLine(String.Format(
 108                 "usage: {0} <regExPattern> <regExSubSpec> <matchingOnly>",
 109                 fileName));
 110         }
 111         #endregion
 112
 113         ///////////////////////////////////////////////////////////////////////
 114
 115         #region Program Entry Point
 116         /// <summary>
 117         /// This is the entry-point for this tool.  It handles processing the
 118         /// command line arguments, reading from the standard input channel,
 119         /// replacing any matching lines of text, and writing to the standard
 120         /// output channel.
 121         /// </summary>
 122         /// <param name="args">
 123         /// The command line arguments.
 124         /// </param>
 125         /// <returns>
 126         /// Zero upon success; non-zero on failure.  This will be one of the
 127         /// values from the <see cref="ExitCode" /> enumeration.
 128         /// </returns>
 129         private static int Main(
 130             string[] args
 131             )
 132         {
 133             //
 134             // NOTE: Sanity check the command line arguments.
 135             //
 136             if (args == null)
 137             {
 138                 Error(null, true);
 139                 return (int)ExitCode.MissingArgs;
 140             }
 141
 142             if (args.Length != 3)
 143             {
 144                 Error(null, true);
 145                 return (int)ExitCode.WrongNumArgs;
 146             }
 147
 148             try
 149             {
 150                 //
 151                 // NOTE: Create a regular expression from the first command
 152                 //       line argument.  Then, grab the replacement string,
 153                 //       which is the second argument.
 154                 //
 155                 Regex regEx = new Regex(args[0]);
 156                 string replacement = args[1];
 157
 158                 //
 159                 // NOTE: Attempt to convert the third argument to a boolean.
 160                 //
 161                 bool matchingOnly;
 162
 163                 if (!bool.TryParse(args[2], out matchingOnly))
 164                 {
 165                     Error(null, true);
 166                     return (int)ExitCode.BadMatchingOnlyFlag;
 167                 }
 168
 169                 //
 170                 // NOTE: Grab the standard input and output channels from the
 171                 //       console.
 172                 //
 173                 TextReader inputTextReader = Console.In;
 174                 TextWriter outputTextWriter = Console.Out;
 175
 176                 //
 177                 // NOTE: Loop until end-of-file is hit on the standard input
 178                 //       stream.
 179                 //
 180                 while (true)
 181                 {
 182                     //
 183                     // NOTE: Read a line from the standard input channel.  If
 184                     //       null is returned here, there is no more input and
 185                     //       we are done.
 186                     //
 187                     string inputLine = inputTextReader.ReadLine();
 188
 189                     if (inputLine == null)
 190                         break;
 191
 192                     //
 193                     // NOTE: Perform regular expression replacements on this
 194                     //       line, if any.  Then, write the modified line to
 195                     //       the standard output channel.
 196                     //
 197                     string outputLine = regEx.Replace(inputLine, replacement);
 198
 199                     if (!matchingOnly || !String.Equals(
 200                             inputLine, outputLine, StringComparison.Ordinal))
 201                     {
 202                         outputTextWriter.WriteLine(outputLine);
 203                     }
 204                 }
 205
 206                 //
 207                 // NOTE: At this point, everything has succeeded.
 208                 //
 209                 return (int)ExitCode.Success;
 210             }
 211             catch (Exception e)
 212             {
 213                 //
 214                 // NOTE: An exception was caught.  Report it via the console
 215                 //       and return failure.
 216                 //
 217                 Error(e.ToString(), false);
 218                 return (int)ExitCode.Exception;
 219             }
 220         }
 221         #endregion
 222     }
 223 }