tesseract
3.03
|
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