mcs/tools/resx2sr/resx2sr.cs

   1 //
   2 // resx2sr.cs
   3 //
   4 // Authors:
   5 //      Marek Safar  <marek.safar@gmail.com>
   6 //
   7 // Copyright (C) 2016 Xamarin Inc (http://www.xamarin.com)
   8 //
   9 // Permission is hereby granted, free of charge, to any person obtaining
  10 // a copy of this software and associated documentation files (the
  11 // "Software"), to deal in the Software without restriction, including
  12 // without limitation the rights to use, copy, modify, merge, publish,
  13 // distribute, sublicense, and/or sell copies of the Software, and to
  14 // permit persons to whom the Software is furnished to do so, subject to
  15 // the following conditions:
  16 //
  17 // The above copyright notice and this permission notice shall be
  18 // included in all copies or substantial portions of the Software.
  19 //
  20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  24 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27 //
  28
  29 /*
  30  * When making any changes to this tool, please be aware that these are not
  31  * automatically tested by a Jenkins job, so you need to do that manually.
  32  *
  33  * You need to do the following:
  34  *
  35  * 1.) Build the tool with the `build` profile
  36  *     $ make PROFILE=build -C mcs/tools/resx2sr
  37  *
  38  * 2.) Update the SR in corlib:
  39  *     $ make -C mcs/class/corlib update-corefx-sr
  40  *
  41  * 3.) Look at the output by doing a `git diff` and also building the code.
  42  *
  43  * 4.) Search for 'RESX_RESOURCE_STRING' and `RESX_EXTRA_ARGUMENTS` in all BCL Makefiles:
  44  *     $ git grep RESX_RESOURCE_STRING mcs/class
  45  *     $ git grep 'RESX_EXTRA_ARGUMENTS' mcs/class
  46  *
  47  * 5.) As a minimum, repeat steps 2.) and 3.) for each directory containing `RESX_EXTRA_ARGUMENTS`.
  48  *     (at the moment, this is only corlib, but please check with `git grep` to make sure).
  49  *
  50  * 6.) To test the tool in `--existing` mode, check out `System.Web.Services`, you can do something
  51  *     like this:
  52  *
  53  *         RESX_EXTRA_ARGUMENTS = --in=corefx/SR.template.cs --name=System.Web.Services.Res --existing
  54  *         RESX_RESOURCE_STRING = ../referencesource/System.Web.Services/System.Web.Services.txt
  55  *
  56  * If you have any questions about the process, please ask me and I'll be glad to help.
  57  *
  58  * December 7th, 2018
  59  * Martin Baulig (mabaul@microsoft.com)
  60  *
  61  */
  62
  63 using System;
  64 using System.IO;
  65 using System.Collections.Generic;
  66 using System.Resources;
  67 using System.ComponentModel.Design;
  68 using System.Text.RegularExpressions;
  69 using Mono.Options;
  70
  71 public class Program
  72 {
  73         class CmdOptions
  74         {
  75                 public bool ShowHelp { get; set; }
  76                 public string OutputFile { get; set; }
  77                 public bool ExistingOnly { get; set; }
  78                 public bool WarnConstantMismatch { get; set; }
  79         }
  80
  81         internal static List<string> InputFiles;
  82         internal static Dictionary<string, object> ExistingKeys;
  83
  84         public static int Main (string[] args)
  85         {
  86                 var options = new CmdOptions ();
  87
  88                 InputFiles = new List<string> ();
  89                 ExistingKeys = new Dictionary<string, object> ();
  90
  91                 string className = "SR";
  92
  93                 var p = new OptionSet () {
  94                         { "o|out=", "Specifies output file name",
  95                                 v => options.OutputFile = v },
  96                         { "i|in=", "Specifies input file name",
  97                                 v => InputFiles.Add (v) },
  98                         { "n|name=", "Name for generated class, default is 'SR'",
  99                                 v => className = v },
 100                         { "h|help",  "Display available options",
 101                                 v => options.ShowHelp = v != null },
 102                         { "e|existing", "Only update existing values, do not add keys",
 103                                 v => options.ExistingOnly = true
 104                         }, { "warn-mismatch", "Warn about constant mismatches",
 105                                 v => options.WarnConstantMismatch = true
 106                         }
 107                 };
 108
 109                 List<string> extra;
 110                 try {
 111                         extra = p.Parse (args);
 112                 } catch (OptionException e) {
 113                         Console.WriteLine (e.Message);
 114                         Console.WriteLine ("Try 'resx2sr -help' for more information.");
 115                         return 1;
 116                 }
 117
 118                 if (options.ShowHelp) {
 119                         ShowHelp (p);
 120                         return 0;
 121                 }
 122
 123                 if (extra.Count < 1) {
 124                         ShowHelp (p);
 125                         return 2;
 126                 }
 127
 128                 if (!LoadInputFiles ())
 129                         return 4;
 130
 131                 var resxStrings = new List<Tuple<string, string, string>> ();
 132                 if (!LoadStrings (resxStrings, extra))
 133                         return 3;
 134
 135                 GenerateFile (className, resxStrings, options);
 136
 137                 return 0;
 138         }
 139
 140         static void ShowHelp (OptionSet p)
 141         {
 142                 Console.WriteLine ("Usage: resx2sr [options] input-files");
 143                 Console.WriteLine ("Generates C# file with string constants from resource file");
 144                 Console.WriteLine ();
 145                 Console.WriteLine ("Options:");
 146                 p.WriteOptionDescriptions (Console.Out);
 147         }
 148
 149         static void GenerateFile (string className, List<Tuple<string, string, string>> txtStrings, CmdOptions options)
 150         {
 151 //              var outputFile = options.OutputFile ?? "SR.cs";
 152
 153                 using (var str = options.OutputFile == null ? Console.Out : new StreamWriter (options.OutputFile)) {
 154                         str.WriteLine ("//");
 155                         str.WriteLine ("// This file was generated by resx2sr tool");
 156                         str.WriteLine ("//");
 157                         str.WriteLine ();
 158
 159                         int nsIdx = className.LastIndexOf ('.');
 160                         if (nsIdx > 0) {
 161                                 str.WriteLine ($"namespace {className.Substring (0, nsIdx)}");
 162                                 str.WriteLine ("{");
 163                                 className = className.Substring (nsIdx+1);
 164                         }
 165
 166                         str.WriteLine ($"partial class {className}");
 167                         str.WriteLine ("{");
 168
 169                         var dict = new Dictionary<string, string> ();
 170
 171                         foreach (var entry in txtStrings) {
 172
 173                                 var value = ToCSharpString (entry.Item2);
 174                                 string found;
 175                                 if (dict.TryGetValue (entry.Item1, out found)) {
 176                                         if (found == value || !options.WarnConstantMismatch)
 177                                                 continue;
 178
 179                                         // The same entry was found with different values in multiple input files.
 180                                         Console.Error.WriteLine ($"Constant value mismatch for {entry.Item1}:\n\tOld: {found}\n\tNew: {value}");
 181                                         continue;
 182                                 }
 183
 184                                 // Always add to list of seen keys.
 185                                 dict.Add (entry.Item1, value);
 186
 187                                 // The following conditional could be simplified to one line, but I belive
 188                                 // it is easier to understand what it does by writing it verbosely like this.
 189                                 if (options.ExistingOnly) {
 190                                         // We read in all entries, then update the strings of the existing ones,
 191                                         // so skip the non-existing ones.
 192                                         if (!ExistingKeys.ContainsKey (entry.Item1))
 193                                                 continue;
 194                                 } else {
 195                                         // In this mode of operation, we pass some existing files via `--in=`,
 196                                         // so we skip the existing ones.
 197                                         if (ExistingKeys.ContainsKey (entry.Item1))
 198                                                 continue;
 199                                 }
 200
 201                                 str.Write ($"\tpublic const string {entry.Item1} = \"{value}\";");
 202
 203                                 if (!string.IsNullOrEmpty (entry.Item3))
 204                                         str.Write (" // {entry.Item3}");
 205
 206                                 str.WriteLine ();
 207                         }
 208
 209                         if (options.ExistingOnly) {
 210                                 // Add any keys that we missed from the input files.
 211                                 foreach (var v in ExistingKeys.Keys) {
 212                                         if (!dict.ContainsKey (v)) {
 213                                                 str.WriteLine ($"\tinternal const string {v} = \"{v}\";");
 214                                         }
 215                                 }
 216                         }
 217
 218                         str.WriteLine ("}");
 219
 220                         if (nsIdx > 0) {
 221                                 str.WriteLine ("}");
 222                         }
 223                 }
 224         }
 225
 226         static string ToCSharpString (string str)
 227         {
 228                 str = str.Replace ("\n", "\\n");
 229
 230                 return str.Replace ("\\", "\\\\").Replace ("\"", "\\\"");
 231         }
 232
 233         static bool LoadStrings (List<Tuple<string, string, string>> resourcesStrings, List<string> files)
 234         {
 235                 var keys = new Dictionary<string, string> ();
 236                 foreach (var fileName in files) {
 237                         if (!File.Exists (fileName)) {
 238                                 Console.Error.WriteLine ($"Error reading resource file '{fileName}'");
 239                                 return false;
 240                         }
 241
 242                         if (string.Equals (Path.GetExtension (fileName), ".txt", StringComparison.OrdinalIgnoreCase)) {
 243                                 resourcesStrings.AddRange (ReadTextResources (fileName));
 244                         } else {
 245                                 resourcesStrings.AddRange (ReadResxFile (fileName));
 246                         }
 247                 }
 248
 249                 return true;
 250         }
 251
 252         static IEnumerable<Tuple<string,string,string>> ReadResxFile (string fileName)
 253         {
 254                 var rr = new ResXResourceReader (fileName);
 255                 rr.UseResXDataNodes = true;
 256                 var dict = rr.GetEnumerator ();
 257                 while (dict.MoveNext ()) {
 258                         var node = (ResXDataNode)dict.Value;
 259                         yield return Tuple.Create (node.Name, (string) node.GetValue ((ITypeResolutionService)null), node.Comment);
 260                 }
 261         }
 262
 263         static IEnumerable<Tuple<string,string,string>> ReadTextResources (string fileName)
 264         {
 265                 foreach (var line in File.ReadAllLines (fileName)) {
 266                         if (line.Length == 0 || line[0] == ';') {
 267                                 continue;
 268                         }
 269                         var idx = line.IndexOf ('=');
 270                         if (idx < 1) {
 271                                 Console.Error.WriteLine ($"Error reading resource file '{fileName}'");
 272                                 continue;
 273                         }
 274                         yield return Tuple.Create (line.Substring (0, idx), line.Substring (idx+1), (string)null);
 275                 }
 276         }
 277
 278         static bool LoadInputFiles ()
 279         {
 280                 var reg = new Regex (@"\s*public const string (\w+)\s+=\s+");
 281                 var keys = new Dictionary<string, string> ();
 282                 foreach (var fileName in InputFiles) {
 283                         if (!File.Exists (fileName)) {
 284                                 Console.Error.WriteLine ($"Error reading input file '{fileName}'");
 285                                 return false;
 286                         }
 287
 288                         using (var reader = new StreamReader (fileName)) {
 289                                 string line;
 290                                 while ((line = reader.ReadLine ()) != null) {
 291                                         var match = reg.Match (line);
 292                                         if (!match.Success)
 293                                                 continue;
 294
 295                                         var key = match.Groups[1].Value;
 296                                         ExistingKeys[key] = null;
 297                                 }
 298                         }
 299                 }
 300
 301                 return true;
 302         }
 303 }