Program options class.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@235 91177308-0d34-0410-b5e6-96231b3b80d8

lib/Support/Makefile

@@ -0,0 +1,12 @@
+LEVEL = ../..
+
+DIRS  = 
+
+LIBRARYNAME = support
+
+## List source files in link order
+Source  = \
+	  ProgramOption.o \
+	  ProgramOptions.o
+
+include $(LEVEL)/Makefile.common

support/lib/Support/Makefile

@@ -0,0 +1,12 @@
+LEVEL = ../..
+
+DIRS  = 
+
+LIBRARYNAME = support
+
+## List source files in link order
+Source  = \
+	  ProgramOption.o \
+	  ProgramOptions.o
+
+include $(LEVEL)/Makefile.common

support/lib/Support/ProgramOption.cpp

@@ -0,0 +1,138 @@
+// $Id$
+//***************************************************************************
+//
+// File:
+//    ProgramOption.C
+//
+// Purpose:
+//    General representations for a program option.
+//
+// History:
+//    08/08/95 - adve  - created in the dHPF compiler
+//    11/26/96 - adve  - EvalOpt now returns #args consumed, or -1 for error
+//    07/15/01 - vadve - Copied to LLVM system and modified
+//
+//**************************************************************************/
+
+//************************** System Include Files **************************/
+
+#include <assert.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string>
+
+//*************************** User Include Files ***************************/
+
+#include "llvm/Support/ProgramOption.h"
+
+//********************** Local Variable Definitions ************************/
+
+//************************ Class Implementations ***************************/
+
+
+//**************************************************************************/
+
+StringOption::StringOption(const char* _argString,
+			   const char* _helpMesg,
+			   const char* _initValue, 
+			   bool _append)
+  : ProgramOption(_argString, _helpMesg),
+    value(_initValue),
+    append(_append) 
+{}
+
+int
+StringOption::EvalOpt(const char* optarg)
+{
+  if (optarg == (char*) NULL)
+    return -1;			// flag the error
+  
+  if (this->append)
+    value += optarg;
+  else
+    value = optarg;
+  
+  optionSpecified = true;
+  return 1;				// one additional argument consumed
+}
+
+
+//**************************************************************************/
+
+FlagOption::FlagOption(const char* _argString,
+		       const char* _helpMesg,
+		       bool _initValue)
+  : ProgramOption(_argString, _helpMesg, 0),
+    value(_initValue)
+{}
+
+int
+FlagOption::EvalOpt(const char* optarg)
+{
+  if (strcmp(optarg, "0") == 0) {
+    value = false;
+    return 1;				// one additional argument consumed
+  }
+  else {
+    value = true; 
+    return 0;				// zero ... consumed
+  }
+}
+
+//**************************************************************************/
+
+RealValuedOption::RealValuedOption(const char* _argString,
+				   const char* _helpMesg,
+				   double _initValue)
+  : ProgramOption(_argString, _helpMesg),
+    value(_initValue)
+{}
+
+int
+RealValuedOption::EvalOpt(const char* optarg)
+{
+  if (optarg == (char*) NULL)
+    return -1;
+    
+  char* lastCharScanned = NULL;
+  value = strtod(optarg, &lastCharScanned);
+  if (! (*lastCharScanned == '\0'))	// look for incorrect or partially
+    return -1;				// correct numerical argument
+  
+  optionSpecified = true;
+  return 1;
+}
+
+char*
+RealValuedOption::GetTextValue() const
+{
+  char buffer[40];
+  sprintf(buffer, "%f", value);
+  return strdup(buffer);
+}
+
+//**************************************************************************/
+
+IntegerValuedOption::IntegerValuedOption(const char* _argString,
+					 const char* _helpMesg,
+					 int _initValue)
+  : RealValuedOption(_argString, _helpMesg, (double) _initValue)
+{}
+
+int
+IntegerValuedOption::Value() const
+{
+  double realValue = RealValuedOption::Value();
+  assert(realValue == (int) realValue);
+  return (int) realValue;
+}
+
+char*
+IntegerValuedOption::GetTextValue() const
+{
+  char buffer[40];
+  sprintf(buffer, "%d", Value());
+  return strdup(buffer);
+}
+
+//**************************************************************************/

support/lib/Support/ProgramOptions.cpp

@@ -0,0 +1,249 @@
+// $Id$
+//***************************************************************************
+//
+// File:
+//    ProgramOptions.C
+//
+// Purpose:
+//    General options processing for any program.
+//
+// History:
+//    08/08/95 - adve  - created in the dHPF compiler
+//    10/10/96 - mpal, dbaker - converted to const member functions.
+//    11/26/96 - adve  - fixed to handle options that consume 0+ arguments
+//    07/15/01 - vadve - Copied to LLVM system and modified
+//
+//**************************************************************************/
+
+//************************** System Include Files **************************/
+
+#include <iostream.h>
+#include <assert.h>
+#include <string.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string>
+#ifndef MAXINT
+#define MAXINT	((1 << sizeof(int)-1) - 1)
+#endif
+
+//*************************** User Include Files ***************************/
+
+#include "llvm/Support/ProgramOptions.h"
+#include "llvm/Support/ProgramOption.h"
+#include "llvm/Support/StringUtils.h" 
+
+
+//************************** Method Definitions ****************************/
+
+ProgramOptions::ProgramOptions(int _argc,
+			       const char* _argv[],
+			       const char* _envp[])
+  : optionRegistry(),
+    argc(_argc),
+    argv(_argv),
+    envp(_envp),
+    argsConsumed(0)
+{}
+
+const char*
+ProgramOptions::StringOptionValue(const char* optString) const
+{
+    const StringOption* handler = (const StringOption*) OptionHandler(optString);
+    return (handler == NULL) ? NULL : handler->Value();
+}
+
+bool
+ProgramOptions::FlagOptionValue(const char* optString) const
+{
+    const FlagOption* handler = (const FlagOption*) OptionHandler(optString);
+    return (handler == NULL) ? false : handler->Value();
+}
+
+double
+ProgramOptions::RealOptionValue(const char* optString) const
+{
+    const RealValuedOption* handler =
+	(const RealValuedOption*) OptionHandler(optString);
+    return (handler == NULL) ? MAXFLOAT : handler->Value();
+}
+
+int
+ProgramOptions::IntOptionValue(const char* optString) const
+{
+    const IntegerValuedOption* handler =
+	(const IntegerValuedOption*) OptionHandler(optString);
+    return (handler == NULL) ? MAXINT : handler->Value();
+}
+
+bool
+ProgramOptions::OptionSpecified(const char* optString) const
+{
+    const ProgramOption* handler = OptionHandler(optString);
+    return handler->OptionSpecified();
+}
+
+const char* 
+ProgramOptions::ProgramName() const
+{
+    return argv[0];
+}
+
+int
+ProgramOptions::NumberOfOtherOptions() const
+{
+   return argc - argsConsumed;
+} 
+
+const char*
+ProgramOptions::OtherOption(int i) const
+{
+   i += argsConsumed;
+   assert(i >= 0 && i < argc);
+   return argv[i];
+}
+
+const char**
+ProgramOptions::GetOriginalArgs() const
+{
+   return argv;
+}
+
+vector<char*>
+ProgramOptions::GetDescription() const
+{  
+  vector<char*> optDesc;
+  
+  if (optDesc.size() < (unsigned) argc)
+    {
+      for (StringMap<ProgramOption*>::const_iterator iter=optionRegistry.begin();
+	   ! (iter == optionRegistry.end());
+	   ++iter)
+	{
+	  const ProgramOption* handler = (*iter).second;
+	  optDesc.push_back(strdup(handler->ArgString()));	// 1st
+	  optDesc.push_back(strdup(handler->HelpMesg()));	// 2nd
+	  optDesc.push_back(handler->GetTextValue());		// 3rd
+	}
+    }
+  
+  return optDesc;
+}
+
+void
+ProgramOptions::Register(ProgramOption* option)
+{
+  optionRegistry[option->ArgString()] = option;
+}
+
+//----------------------------------------------------------------------
+// function ProgramOptions::ParseArgs
+// 
+// Parse command-line options until you run out of options or see
+// an unrecognized option.  `getopt' is a standard package to do this,
+// but incredibly, it limited to single-letter options.
+//
+// -- Each option can consume zero or one additional arguments of argv
+// -- "--" can be used to mark the end of options
+//	  so that a program argument can also start with "-".
+//---------------------------------------------------------------------/
+
+void
+ProgramOptions::ParseArgs(int argc,
+			  const char* argv[],
+			  const char* envp[])
+{
+  if (argc == 0) {
+    Usage();
+  }
+  // consume the program name
+  argsConsumed = 1;
+  
+  while (argsConsumed < argc)
+    {
+      const char* arg = argv[argsConsumed];
+      if (arg[0] == '-')
+	{
+	  if (strcmp(arg, "--") == 0) {	// "--" marks end of options
+	    argsConsumed++;		// consume and
+	    break;			// discontinue the for loop
+	  }
+	  ProgramOption* handler = OptionHandler(arg+1);
+	  if (handler == NULL) {
+	    cerr << "Unrecognized option: " << arg+1 << endl;
+	    Usage();
+	  }
+
+	  if (argc - argsConsumed < handler->MinExpectedArgs()) {
+	    cerr << "Option " << (char*) arg+1 << " needs "
+		 << handler->MinExpectedArgs() << " arguments" << endl;
+	    Usage();
+	  }
+
+	  argsConsumed++;  // consumed the option
+
+	  const char* nextArg = (argsConsumed < argc)? argv[argsConsumed]
+						     : "";
+	  int numAdditionalArgsConsumed = handler->EvalOpt(nextArg);
+	  if (numAdditionalArgsConsumed < 0)
+	    Usage();
+	  argsConsumed += numAdditionalArgsConsumed;
+	}
+      else
+	{
+	  break; // quit the while loop 
+	}
+    }
+  
+  ParseExtraArgs(); 
+}
+
+void
+ProgramOptions::PrintArgs(ostream& stream) const
+{
+  for (int i = 0; i < argc; i++) {
+    stream << argv[i] << " ";
+  }
+  stream << endl; 
+}
+
+
+void
+ProgramOptions::PrintOptions(ostream& stream) const
+{
+  stream << "OPTIONS:" << endl;
+  stream << "\tUse argument 0 to turn OFF a flag option: "
+	 << "-<flag_opt> 0" << endl << endl;
+    
+  for (StringMap<ProgramOption*>::const_iterator iter=optionRegistry.begin();
+       ! (iter == optionRegistry.end());
+       ++iter)
+    {
+      const ProgramOption* handler = (*iter).second;
+      
+      stream << "\t-" << handler->ArgString();
+      
+      const char* const showarg = " <arg>";
+      int i = 1;
+      for (i=1; i <= handler->MinExpectedArgs(); i++)
+	stream << showarg; 
+      
+      int numCharsPrinted = 1 + strlen(handler->ArgString())
+	+ strlen(showarg) * handler->MinExpectedArgs();
+      for (i=1; i > numCharsPrinted / 8; i--)
+	stream << "\t";
+      
+      stream << "\t" << handler->HelpMesg()
+	     << endl;
+    }
+}
+
+void
+ProgramOptions::Usage() const
+{
+  PrintUsage(cerr); 
+  exit(1); 
+}
+
+
+//**************************************************************************/