mcs/class/Mono.GetOptions/Mono.GetOptions/OptionDetails.cs

   1 //
   2 // OptionDetails.cs
   3 //
   4 // Author: Rafael Teixeira (rafaelteixeirabr@hotmail.com)
   5 //
   6 // (C) 2002 Rafael Teixeira
   7 //
   8
   9 //
  10 // Permission is hereby granted, free of charge, to any person obtaining
  11 // a copy of this software and associated documentation files (the
  12 // "Software"), to deal in the Software without restriction, including
  13 // without limitation the rights to use, copy, modify, merge, publish,
  14 // distribute, sublicense, and/or sell copies of the Software, and to
  15 // permit persons to whom the Software is furnished to do so, subject to
  16 // the following conditions:
  17 //
  18 // The above copyright notice and this permission notice shall be
  19 // included in all copies or substantial portions of the Software.
  20 //
  21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  24 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  25 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  27 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28 //
  29
  30 using System;
  31 using System.Collections;
  32 using System.IO;
  33 using System.Reflection;
  34
  35 namespace Mono.GetOptions
  36 {
  37         public enum WhatToDoNext
  38         {
  39                 AbandonProgram,
  40                 GoAhead
  41         }
  42
  43         internal enum OptionProcessingResult
  44         {
  45                 NotThisOption,
  46                 OptionAlone,
  47                 OptionConsumedParameter
  48         }
  49
  50         internal class OptionDetails : IComparable
  51         {
  52                 public string ShortForm;
  53                 public string LongForm;
  54                 public string AlternateForm;
  55                 public string ShortDescription;
  56                 public bool NeedsParameter;
  57                 public int MaxOccurs; // negative means there is no limit
  58                 public int Occurs;
  59                 public bool BooleanOption;
  60                 public Options OptionBundle;
  61                 public MemberInfo MemberInfo;
  62                 public ArrayList Values;
  63                 public System.Type ParameterType;
  64                 public string paramName = null;
  65
  66                 private string ExtractParamName(string shortDescription)
  67                 {
  68                         int whereBegins = shortDescription.IndexOf("{");
  69                         if (whereBegins < 0)
  70                                 paramName = "PARAM";
  71                         else {
  72                                 int whereEnds = shortDescription.IndexOf("}");
  73                                 if (whereEnds < whereBegins)
  74                                         whereEnds = shortDescription.Length+1;
  75
  76                                 paramName = shortDescription.Substring(whereBegins + 1, whereEnds - whereBegins - 1);
  77                                 shortDescription =
  78                                         shortDescription.Substring(0, whereBegins) +
  79                                         paramName +
  80                                         shortDescription.Substring(whereEnds + 1);
  81                         }
  82                         return shortDescription;
  83                 }
  84
  85                 public string ParamName
  86                 {
  87                         get
  88                         {
  89                                 return paramName;
  90                         }
  91                 }
  92
  93                 public static bool Verbose = false;
  94
  95                 private OptionsParsingMode parsingMode { get { return this.OptionBundle.ParsingMode; } }
  96
  97                 private string linuxLongPrefix {
  98                         get {
  99                                 return (((parsingMode & OptionsParsingMode.GNU_DoubleDash) == OptionsParsingMode.GNU_DoubleDash)? "--":"-");
 100                         }
 101                 }
 102
 103                 public string DefaultForm
 104                 {
 105                         get {
 106                                 string shortPrefix = "-";
 107                                 string longPrefix = linuxLongPrefix;
 108                                 if (parsingMode == OptionsParsingMode.Windows) {
 109                                         shortPrefix = "/";
 110                                         longPrefix = "/";
 111                                 }
 112                                 if (this.ShortForm != string.Empty)
 113                                         return shortPrefix+this.ShortForm;
 114                                 else
 115                                         return longPrefix+this.LongForm;
 116                         }
 117                 }
 118
 119                 public override string ToString()
 120                 {
 121                         string optionHelp;
 122                         // TODO: Yet not that good
 123                         string shortPrefix;
 124                         string longPrefix;
 125                         bool hasLongForm = (this.LongForm != null && this.LongForm != string.Empty);
 126                         if(this.OptionBundle.ParsingMode == OptionsParsingMode.Windows)
 127                         {
 128                                 shortPrefix = "/";
 129                                 longPrefix = "/";
 130                         }
 131                         else
 132                         {
 133                                 shortPrefix = "-";
 134                                 longPrefix = linuxLongPrefix;
 135                         }
 136                         optionHelp = "  ";
 137                         optionHelp += (this.ShortForm != string.Empty) ? shortPrefix+this.ShortForm+" " : "   ";
 138                         optionHelp += hasLongForm ? longPrefix+this.LongForm : "";
 139                         if (NeedsParameter)
 140                         {
 141                                 if (hasLongForm)
 142                                         optionHelp += ":";
 143                                 optionHelp += ParamName;
 144                         }
 145                         optionHelp = optionHelp.PadRight(32) + " ";
 146                         optionHelp += this.ShortDescription;
 147                         if (this.AlternateForm != string.Empty && this.AlternateForm != null)
 148                                 optionHelp += " [/"+this.AlternateForm + "]";
 149                         return optionHelp;
 150                 }
 151
 152                 private static System.Type TypeOfMember(MemberInfo memberInfo)
 153                 {
 154                         if ((memberInfo.MemberType == MemberTypes.Field && memberInfo is FieldInfo))
 155                                 return ((FieldInfo)memberInfo).FieldType;
 156
 157                         if ((memberInfo.MemberType == MemberTypes.Property && memberInfo is PropertyInfo))
 158                                 return ((PropertyInfo)memberInfo).PropertyType;
 159
 160                         if ((memberInfo.MemberType == MemberTypes.Method && memberInfo is MethodInfo))
 161                         {
 162                                 if (((MethodInfo)memberInfo).ReturnType.FullName != typeof(WhatToDoNext).FullName)
 163                                         throw new NotSupportedException("Option method must return '" + typeof(WhatToDoNext).FullName + "'");
 164
 165                                 ParameterInfo[] parameters = ((MethodInfo)memberInfo).GetParameters();
 166                                 if ((parameters == null) || (parameters.Length == 0))
 167                                         return null;
 168                                 else
 169                                         return parameters[0].ParameterType;
 170                         }
 171
 172                         throw new NotSupportedException("'" + memberInfo.MemberType + "' memberType is not supported");
 173                 }
 174
 175                 public OptionDetails(MemberInfo memberInfo, OptionAttribute option, Options optionBundle)
 176                 {
 177                         this.ShortForm = ("" + option.ShortForm).Trim();
 178                         if (option.LongForm == null)
 179                                 this.LongForm = string.Empty;
 180                         else
 181                                 this.LongForm = (option.LongForm == string.Empty)? memberInfo.Name:option.LongForm;
 182                         this.AlternateForm = option.AlternateForm;
 183                         this.ShortDescription = ExtractParamName(option.ShortDescription);
 184                         this.Occurs = 0;
 185                         this.OptionBundle = optionBundle;
 186                         this.BooleanOption = false;
 187                         this.MemberInfo = memberInfo;
 188                         this.NeedsParameter = false;
 189                         this.Values = null;
 190                         this.MaxOccurs = 1;
 191                         this.ParameterType = TypeOfMember(memberInfo);
 192
 193                         if (this.ParameterType != null)
 194                         {
 195                                 if (this.ParameterType.FullName != "System.Boolean")
 196                                 {
 197                                         if (this.LongForm.IndexOf(':') >= 0)
 198                                                 throw new InvalidOperationException("Options with an embedded colon (':') in their visible name must be boolean!!! [" +
 199                                                                         this.MemberInfo.ToString() + " isn't]");
 200
 201                                         this.NeedsParameter = true;
 202
 203                                         if (option.MaxOccurs != 1)
 204                                         {
 205                                                 if (this.ParameterType.IsArray)
 206                                                 {
 207                                                         this.Values = new ArrayList();
 208                                                         this.MaxOccurs = option.MaxOccurs;
 209                                                 }
 210                                                 else
 211                                                 {
 212                                                         if (this.MemberInfo is MethodInfo || this.MemberInfo is PropertyInfo)
 213                                                                 this.MaxOccurs = option.MaxOccurs;
 214                                                         else
 215                                                                 throw new InvalidOperationException("MaxOccurs set to non default value (" + option.MaxOccurs + ") for a [" +
 216                                                                                         this.MemberInfo.ToString() + "] option");
 217                                                 }
 218                                         }
 219                                 }
 220                                 else
 221                                 {
 222                                         this.BooleanOption = true;
 223                                         if (option.MaxOccurs != 1)
 224                                         {
 225                                                 if (this.MemberInfo is MethodInfo || this.MemberInfo is PropertyInfo)
 226                                                         this.MaxOccurs = option.MaxOccurs;
 227                                                 else
 228                                                         throw new InvalidOperationException("MaxOccurs set to non default value (" + option.MaxOccurs + ") for a [" +
 229                                                                                 this.MemberInfo.ToString() + "] option");
 230                                         }
 231                                 }
 232                         }
 233                 }
 234
 235                 internal string Key
 236                 {
 237                         get { return this.ShortForm + this.LongForm; }
 238                 }
 239
 240                 int IComparable.CompareTo(object other)
 241                 {
 242                         return Key.CompareTo(((OptionDetails)other).Key);
 243                 }
 244
 245                 public void TransferValues()
 246                 {
 247                         if (Values != null)
 248                         {
 249                                 if (MemberInfo is FieldInfo)
 250                                 {
 251                                         ((FieldInfo)MemberInfo).SetValue(OptionBundle, Values.ToArray(ParameterType.GetElementType()));
 252                                         return;
 253                                 }
 254
 255                                 if (MemberInfo is PropertyInfo)
 256                                 {
 257                                         ((PropertyInfo)MemberInfo).SetValue(OptionBundle, Values.ToArray(ParameterType.GetElementType()), null);
 258                                         return;
 259                                 }
 260
 261                                 if ((WhatToDoNext)((MethodInfo)MemberInfo).Invoke(OptionBundle, new object[] { Values.ToArray(ParameterType.GetElementType()) }) == WhatToDoNext.AbandonProgram)
 262                                         System.Environment.Exit(1);
 263                         }
 264                 }
 265
 266                 private void Occurred(int howMany)
 267                 {
 268                         Occurs += howMany;
 269
 270                         if (MaxOccurs > 0 && Occurs > MaxOccurs)
 271                                 throw new IndexOutOfRangeException("Option " + ShortForm + " can be used at most " + MaxOccurs + " times");
 272                 }
 273
 274                 private void DoIt(bool setValue)
 275                 {
 276                         if (!NeedsParameter)
 277                         {
 278                                 Occurred(1);
 279
 280                                 if (Verbose)
 281                                         Console.WriteLine("<" + this.LongForm + "> set to [true]");
 282
 283                                 if (MemberInfo is FieldInfo)
 284                                 {
 285                                         ((FieldInfo)MemberInfo).SetValue(OptionBundle, setValue);
 286                                         return;
 287                                 }
 288                                 if (MemberInfo is PropertyInfo)
 289                                 {
 290                                         ((PropertyInfo)MemberInfo).SetValue(OptionBundle, setValue, null);
 291                                         return;
 292                                 }
 293                                 if ((WhatToDoNext)((MethodInfo)MemberInfo).Invoke(OptionBundle, null) == WhatToDoNext.AbandonProgram)
 294                                         System.Environment.Exit(1);
 295
 296                                 return;
 297                         }
 298                 }
 299
 300                 private void DoIt(string parameterValue)
 301                 {
 302                         if (parameterValue == null)
 303                                 parameterValue = "";
 304
 305                         string[] parameterValues = parameterValue.Split(',');
 306
 307                         Occurred(parameterValues.Length);
 308
 309                         foreach (string parameter in parameterValues)
 310                         {
 311
 312                                 object convertedParameter = null;
 313
 314                                 if (Verbose)
 315                                         Console.WriteLine("<" + this.LongForm + "> set to [" + parameter + "]");
 316
 317                                 if (Values != null && parameter != null) {
 318                                         try {
 319                                                 convertedParameter = Convert.ChangeType(parameter, ParameterType.GetElementType());
 320                                         } catch (Exception ex) {
 321                                                 Console.WriteLine(String.Format("The value '{0}' is not convertible to the appropriate type '{1}' for the {2} option", parameter, ParameterType.GetElementType().Name, DefaultForm));
 322                                         }
 323                                         Values.Add(convertedParameter);
 324                                         continue;
 325                                 }
 326
 327                                 if (parameter != null) {
 328                                         try {
 329                                                 convertedParameter = Convert.ChangeType(parameter, ParameterType);
 330                                         } catch (Exception ex) {
 331                                                 Console.WriteLine(String.Format("The value '{0}' is not convertible to the appropriate type '{1}' for the {2} option", parameter, ParameterType.Name, DefaultForm));
 332                                                 continue;
 333                                         }
 334                                 }
 335
 336                                 if (MemberInfo is FieldInfo) {
 337                                         ((FieldInfo)MemberInfo).SetValue(OptionBundle, convertedParameter);
 338                                         continue;
 339                                 }
 340
 341                                 if (MemberInfo is PropertyInfo) {
 342                                         ((PropertyInfo)MemberInfo).SetValue(OptionBundle, convertedParameter, null);
 343                                         continue;
 344                                 }
 345
 346                                 if ((WhatToDoNext)((MethodInfo)MemberInfo).Invoke(OptionBundle, new object[] { convertedParameter }) == WhatToDoNext.AbandonProgram)
 347                                         System.Environment.Exit(1);
 348                         }
 349                 }
 350
 351                 private bool IsThisOption(string arg)
 352                 {
 353                         if (arg != null && arg != string.Empty)
 354                         {
 355                                 arg = arg.TrimStart('-', '/');
 356                                 return (arg == ShortForm || arg == LongForm || arg == AlternateForm);
 357                         }
 358                         return false;
 359                 }
 360
 361                 public OptionProcessingResult ProcessArgument(string arg, string nextArg)
 362                 {
 363                         if (IsThisOption(arg))
 364                         {
 365                                 if (!NeedsParameter)
 366                                 {
 367                                         DoIt(true); // in preparation for vbc-like booleans
 368                                         return OptionProcessingResult.OptionAlone;
 369                                 }
 370                                 else
 371                                 {
 372                                         DoIt(nextArg);
 373                                         return OptionProcessingResult.OptionConsumedParameter;
 374                                 }
 375                         }
 376
 377                         if (IsThisOption(arg + ":" + nextArg))
 378                         {
 379                                 DoIt(true);
 380                                 return OptionProcessingResult.OptionConsumedParameter;
 381                         }
 382
 383                         return OptionProcessingResult.NotThisOption;
 384                 }
 385         }
 386 }