Mercurial
comparison third_party/sqlite3/Replace.cs @ 167:589bab390fb4
[ThirdParty] Added sqlite3 to the third_party.
| author | MrJuneJune <me@mrjunejune.com> |
|---|---|
| date | Mon, 19 Jan 2026 16:28:45 -0800 |
| parents | |
| children |
comparison
equal
deleted
inserted
replaced
| 166:78ea8d5ccc87 | 167:589bab390fb4 |
|---|---|
| 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 } |