"Fossies" - the Fresh Open Source Software Archive

Member "sqlite-autoconf-3320300/Replace.cs" (18 Jun 2020, 7272 Bytes) of package /linux/misc/sqlite-autoconf-3320300.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C# source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "Replace.cs" see the Fossies "Dox" file reference documentation.

    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 }