tesseract  3.03
/usr/local/google/home/jbreiden/tesseract-ocr-read-only/training/commandlineflags.cpp
Go to the documentation of this file.
00001 #include "commandlineflags.h"
00002 
00003 #ifdef USE_STD_NAMESPACE
00004 
00005 namespace tesseract {
00006 bool IntFlagExists(const char* flag_name, inT32* value) {
00007   STRING full_flag_name("FLAGS_");
00008   full_flag_name += flag_name;
00009   GenericVector<IntParam*> empty;
00010   IntParam *p = ParamUtils::FindParam<IntParam>(
00011       full_flag_name.string(), GlobalParams()->int_params, empty);
00012   if (p == NULL) return false;
00013   *value = (inT32)(*p);
00014   return true;
00015 }
00016 
00017 bool DoubleFlagExists(const char* flag_name, double* value) {
00018   STRING full_flag_name("FLAGS_");
00019   full_flag_name += flag_name;
00020   GenericVector<DoubleParam*> empty;
00021   DoubleParam *p = ParamUtils::FindParam<DoubleParam>(
00022       full_flag_name.string(), GlobalParams()->double_params, empty);
00023   if (p == NULL) return false;
00024   *value = static_cast<double>(*p);
00025   return true;
00026 }
00027 
00028 bool BoolFlagExists(const char* flag_name, bool* value) {
00029   STRING full_flag_name("FLAGS_");
00030   full_flag_name += flag_name;
00031   GenericVector<BoolParam*> empty;
00032   BoolParam *p = ParamUtils::FindParam<BoolParam>(
00033       full_flag_name.string(), GlobalParams()->bool_params, empty);
00034   if (p == NULL) return false;
00035   *value = (BOOL8)(*p);
00036   return true;
00037 }
00038 
00039 bool StringFlagExists(const char* flag_name, const char** value) {
00040   STRING full_flag_name("FLAGS_");
00041   full_flag_name += flag_name;
00042   GenericVector<StringParam*> empty;
00043   StringParam *p = ParamUtils::FindParam<StringParam>(
00044       full_flag_name.string(), GlobalParams()->string_params, empty);
00045   *value = (p != NULL) ? p->string() : NULL;
00046   return p != NULL;
00047 }
00048 
00049 
00050 void SetIntFlagValue(const char* flag_name, const inT32 new_val) {
00051   STRING full_flag_name("FLAGS_");
00052   full_flag_name += flag_name;
00053   GenericVector<IntParam*> empty;
00054   IntParam *p = ParamUtils::FindParam<IntParam>(
00055       full_flag_name.string(), GlobalParams()->int_params, empty);
00056   ASSERT_HOST(p != NULL);
00057   p->set_value(new_val);
00058 }
00059 
00060 void SetDoubleFlagValue(const char* flag_name, const double new_val) {
00061   STRING full_flag_name("FLAGS_");
00062   full_flag_name += flag_name;
00063   GenericVector<DoubleParam*> empty;
00064   DoubleParam *p = ParamUtils::FindParam<DoubleParam>(
00065       full_flag_name.string(), GlobalParams()->double_params, empty);
00066   ASSERT_HOST(p != NULL);
00067   p->set_value(new_val);
00068 }
00069 
00070 void SetBoolFlagValue(const char* flag_name, const bool new_val) {
00071   STRING full_flag_name("FLAGS_");
00072   full_flag_name += flag_name;
00073   GenericVector<BoolParam*> empty;
00074   BoolParam *p = ParamUtils::FindParam<BoolParam>(
00075       full_flag_name.string(), GlobalParams()->bool_params, empty);
00076   ASSERT_HOST(p != NULL);
00077   p->set_value(new_val);
00078 }
00079 
00080 void SetStringFlagValue(const char* flag_name, const char* new_val) {
00081   STRING full_flag_name("FLAGS_");
00082   full_flag_name += flag_name;
00083   GenericVector<StringParam*> empty;
00084   StringParam *p = ParamUtils::FindParam<StringParam>(
00085       full_flag_name.string(), GlobalParams()->string_params, empty);
00086   ASSERT_HOST(p != NULL);
00087   p->set_value(STRING(new_val));
00088 }
00089 
00090 bool SafeAtoi(const char* str, int* val) {
00091   char *endptr = NULL;
00092   *val = strtol(str, &endptr, 10);
00093   return endptr != NULL && *endptr == '\0';
00094 }
00095 
00096 bool SafeAtod(const char* str, double* val) {
00097   char *endptr = NULL;
00098   *val = strtod(str, &endptr);
00099   return endptr != NULL && *endptr == '\0';
00100 }
00101 
00102 void PrintCommandLineFlags() {
00103   const char* kFlagNamePrefix = "FLAGS_";
00104   const int kFlagNamePrefixLen = strlen(kFlagNamePrefix);
00105   for (int i = 0; i < GlobalParams()->int_params.size(); ++i) {
00106     if (!strncmp(GlobalParams()->int_params[i]->name_str(),
00107                  kFlagNamePrefix, kFlagNamePrefixLen)) {
00108       tprintf("  --%s  %s  (type:int default:%d)\n",
00109               GlobalParams()->int_params[i]->name_str() + kFlagNamePrefixLen,
00110               GlobalParams()->int_params[i]->info_str(),
00111               inT32(*(GlobalParams()->int_params[i])));
00112     }
00113   }
00114   for (int i = 0; i < GlobalParams()->double_params.size(); ++i) {
00115     if (!strncmp(GlobalParams()->double_params[i]->name_str(),
00116                  kFlagNamePrefix, kFlagNamePrefixLen)) {
00117       tprintf("  --%s  %s  (type:double default:%g)\n",
00118               GlobalParams()->double_params[i]->name_str() + kFlagNamePrefixLen,
00119               GlobalParams()->double_params[i]->info_str(),
00120               static_cast<double>(*(GlobalParams()->double_params[i])));
00121     }
00122   }
00123   for (int i = 0; i < GlobalParams()->bool_params.size(); ++i) {
00124     if (!strncmp(GlobalParams()->bool_params[i]->name_str(),
00125                  kFlagNamePrefix, kFlagNamePrefixLen)) {
00126       tprintf("  --%s  %s  (type:bool default:%s)\n",
00127               GlobalParams()->bool_params[i]->name_str() + kFlagNamePrefixLen,
00128               GlobalParams()->bool_params[i]->info_str(),
00129               (BOOL8(*(GlobalParams()->bool_params[i])) ? "true" : "false"));
00130     }
00131   }
00132   for (int i = 0; i < GlobalParams()->string_params.size(); ++i) {
00133     if (!strncmp(GlobalParams()->string_params[i]->name_str(),
00134                  kFlagNamePrefix, kFlagNamePrefixLen)) {
00135       tprintf("  --%s  %s  (type:string default:%s)\n",
00136               GlobalParams()->string_params[i]->name_str() + kFlagNamePrefixLen,
00137               GlobalParams()->string_params[i]->info_str(),
00138               GlobalParams()->string_params[i]->string());
00139     }
00140   }
00141 }
00142 
00143 
00144 void ParseCommandLineFlags(const char* usage,
00145                            int* argc, char*** argv,
00146                            const bool remove_flags) {
00147   unsigned int i = 1;
00148   for (i = 1; i < *argc; ++i) {
00149     const char* current_arg = (*argv)[i];
00150     // If argument does not start with a hyphen then break.
00151     if (current_arg[0] != '-') {
00152       break;
00153     }
00154     // Position current_arg after startings hyphens. We treat a sequence of
00155     // consecutive hyphens of any length identically.
00156     while (*current_arg == '-') {
00157       ++current_arg;
00158     }
00159     // If this is asking for usage, print the help message and abort.
00160     if (!strcmp(current_arg, "help") ||
00161         !strcmp(current_arg, "helpshort")) {
00162       tprintf("USAGE: %s\n", usage);
00163       PrintCommandLineFlags();
00164       exit(0);
00165     }
00166     // Find the starting position of the value if it was specified in this
00167     // string.
00168     const char* equals_position = strchr(current_arg, '=');
00169     const char* rhs = NULL;
00170     if (equals_position != NULL) {
00171       rhs = equals_position + 1;
00172     }
00173     // Extract the flag name.
00174     STRING lhs;
00175     if (equals_position == NULL) {
00176       lhs = current_arg;
00177     } else {
00178       lhs.assign(current_arg, equals_position - current_arg);
00179     }
00180     if (!lhs.length()) {
00181       tprintf("ERROR: Bad argument: %s\n", (*argv)[i]);
00182       exit(1);
00183     }
00184 
00185     // Find the flag name in the list of global flags.
00186     // inT32 flag
00187     inT32 int_val;
00188     if (IntFlagExists(lhs.string(), &int_val)) {
00189       if (rhs != NULL) {
00190         if (!strlen(rhs)) {
00191           // Bad input of the format --int_flag=
00192           tprintf("ERROR: Bad argument: %s\n", (*argv)[i]);
00193           exit(1);
00194         }
00195         if (!SafeAtoi(rhs, &int_val)) {
00196           tprintf("ERROR: Could not parse int from %s in flag %s\n",
00197                   rhs, (*argv)[i]);
00198           exit(1);
00199         }
00200       } else {
00201         // We need to parse the next argument
00202         if (i + 1 >= *argc) {
00203           tprintf("ERROR: Could not find value argument for flag %s\n",
00204                   lhs.string());
00205           exit(1);
00206         } else {
00207           ++i;
00208           if (!SafeAtoi((*argv)[i], &int_val)) {
00209             tprintf("ERROR: Could not parse inT32 from %s\n", (*argv)[i]);
00210             exit(1);
00211           }
00212         }
00213       }
00214       SetIntFlagValue(lhs.string(), int_val);
00215       continue;
00216     }
00217 
00218     // double flag
00219     double double_val;
00220     if (DoubleFlagExists(lhs.string(), &double_val)) {
00221       if (rhs != NULL) {
00222         if (!strlen(rhs)) {
00223           // Bad input of the format --double_flag=
00224           tprintf("ERROR: Bad argument: %s\n", (*argv)[i]);
00225           exit(1);
00226         }
00227         if (!SafeAtod(rhs, &double_val)) {
00228           tprintf("ERROR: Could not parse double from %s in flag %s\n",
00229                   rhs, (*argv)[i]);
00230           exit(1);
00231         }
00232       } else {
00233         // We need to parse the next argument
00234         if (i + 1 >= *argc) {
00235           tprintf("ERROR: Could not find value argument for flag %s\n",
00236                   lhs.string());
00237           exit(1);
00238         } else {
00239           ++i;
00240           if (!SafeAtod((*argv)[i], &double_val)) {
00241             tprintf("ERROR: Could not parse double from %s\n", (*argv)[i]);
00242             exit(1);
00243           }
00244         }
00245       }
00246       SetDoubleFlagValue(lhs.string(), double_val);
00247       continue;
00248     }
00249 
00250     // Bool flag. Allow input forms --flag (equivalent to --flag=true),
00251     // --flag=false, --flag=true, --flag=0 and --flag=1
00252     bool bool_val;
00253     if (BoolFlagExists(lhs.string(), &bool_val)) {
00254       if (rhs == NULL) {
00255         // --flag form
00256         bool_val = true;
00257       } else {
00258         if (!strlen(rhs)) {
00259           // Bad input of the format --bool_flag=
00260           tprintf("ERROR: Bad argument: %s\n", (*argv)[i]);
00261           exit(1);
00262         }
00263         if (!strcmp(rhs, "false") || !strcmp(rhs, "0")) {
00264           bool_val = false;
00265         } else if (!strcmp(rhs, "true") || !strcmp(rhs, "1")) {
00266           bool_val = true;
00267         } else {
00268           tprintf("ERROR: Could not parse bool from flag %s\n", (*argv)[i]);
00269           exit(1);
00270         }
00271       }
00272       SetBoolFlagValue(lhs.string(), bool_val);
00273       continue;
00274     }
00275 
00276     // string flag
00277     const char* string_val;
00278     if (StringFlagExists(lhs.string(), &string_val)) {
00279       if (rhs != NULL) {
00280         string_val = rhs;
00281       } else {
00282         // Pick the next argument
00283         if (i + 1 >= *argc) {
00284           tprintf("ERROR: Could not find string value for flag %s\n",
00285                   lhs.string());
00286           exit(1);
00287         } else {
00288           string_val = (*argv)[++i];
00289         }
00290       }
00291       SetStringFlagValue(lhs.string(), string_val);
00292       continue;
00293     }
00294 
00295     // Flag was not found. Exit with an error message.
00296     tprintf("ERROR: Non-existent flag %s\n", (*argv)[i]);
00297     exit(1);
00298   }  // for each argv
00299   if (remove_flags) {
00300     (*argv)[i - 1] = (*argv)[0];
00301     (*argv) += (i - 1);
00302     (*argc) -= (i - 1);
00303   }
00304 }
00305 }  // namespace tesseract
00306 
00307 #else
00308 
00309 #include "base/init_google.h"
00310 
00311 namespace tesseract {
00312 void ParseCommandLineFlags(const char* usage,
00313                            int* argc, char*** argv,
00314                            const bool remove_flags) {
00315   InitGoogle(usage, argc, argv, remove_flags);
00316 }
00317 }  // namespace tesseract
00318 
00319 #endif
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines