bool option_parser::check_required() const { for (auto it = categories_.begin(); it != categories_.end(); ++it) { if (!check_required(*it)) { return false; } } return true; }
bool option_parser::parse(int argc, char * argv[]) { build_maps(); int argi = PARSE_STARTING_INDEX; while (argi < argc) { switch (type(argv[argi])) { case ARGUMENT: { parse_arguments(argc, argv, argi); return check_required(); } case SHORT_OPTION: { argi = parse_short_options(argc, argv, argi); if (argi == PARSE_ERROR) { return false; } break; } case LONG_OPTION: { argi = parse_long_option(argc, argv, argi); if (argi == PARSE_ERROR) { return false; } break; } case DELIMITER_OPTION: { parse_arguments(argc, argv, argi + 1); return check_required(); } default: { // huh. out of enumeration? assert(false); } } } return check_required(); }
bool app_arguments (int argc, char **argv, AppArgument *arguments) { int argi = 1; int order = 1; if (argc < 0) { error_code (InvalidArgument, 1); return false; } if (!argv) { error_code (InvalidArgument, 2); return false; } if (!arguments) { error_code (InvalidArgument, 3); return false; } if (!arguments_validate (arguments)) { error_code (FunctionCall, 1); return false; } set_ordinal (arguments); set_default (arguments); app_arguments_default_reset (); while (argi < argc) { if (string_begins_with (argv[argi], "-")) { if (!argument_named (argc, argv, &argi, arguments)) { error_code (FunctionCall, 2); return false; } } else { if (!argument_ordinal (argc, argv, &argi, arguments, &order)) { error_code (FunctionCall, 3); return false; } } } if (!app_arguments_default (argc, argv, arguments)) { error_code (FunctionCall, 4); return false; } if (!check_required (arguments)) { error_code (FunctionCall, 5); return false; } return true; }
static GKeyFile * get_session_keyfile (const char *session, char **actual_session, gboolean *is_fallback) { GKeyFile *keyfile; gboolean session_runnable; char *value; GError *error = NULL; *actual_session = NULL; g_debug ("fill: *** Getting session '%s'", session); keyfile = find_valid_session_keyfile (session); if (!keyfile) return NULL; session_runnable = TRUE; value = g_key_file_get_string (keyfile, GSM_KEYFILE_SESSION_GROUP, GSM_KEYFILE_RUNNABLE_KEY, NULL); if (!IS_STRING_EMPTY (value)) { g_debug ("fill: *** Launching helper '%s' to know if session is runnable", value); session_runnable = gsm_process_helper (value, GSM_RUNNABLE_HELPER_TIMEOUT, &error); if (!session_runnable) { g_warning ("Session '%s' runnable check failed: %s", session, error->message); g_clear_error (&error); } } g_free (value); if (session_runnable) { session_runnable = check_required (keyfile); } if (session_runnable) { *actual_session = g_strdup (session); if (is_fallback) *is_fallback = FALSE; return keyfile; } g_debug ("fill: *** Session is not runnable"); /* We can't run this session, so try to use the fallback */ value = g_key_file_get_string (keyfile, GSM_KEYFILE_SESSION_GROUP, GSM_KEYFILE_FALLBACK_KEY, NULL); g_key_file_free (keyfile); keyfile = NULL; if (!IS_STRING_EMPTY (value)) { if (is_fallback) *is_fallback = TRUE; keyfile = get_session_keyfile (value, actual_session, NULL); } g_free (value); return keyfile; }
/** main */ int main (int argc, char * argv[]) { const char *infilename = NULL; const char *outfilename= NULL; //opterr = 0; int c; int flag_substitute_only=UNFLAGGED; int flag_baseline_cleanup=UNFLAGGED; int flag_tagorder=UNFLAGGED; int flag_check_only=UNFLAGGED; int clean_tag=UNFLAGGED; flag_be_verbose = FLAGGED; while ((c = getopt (argc, argv, "s::cbqt::hi:o:x:")) != -1) { switch (c) { case 'h': /* help */ help(); exit (0); case 's': /* inplace file substitution (no new output file is written) */ flag_substitute_only = FLAGGED; break; case 'b': /* clean up to be baseline tiff conform */ flag_baseline_cleanup=FLAGGED; break; case 't': /* try to fix tagorder */ flag_tagorder=FLAGGED; break; case 'c': /* reports only if repair needed */ flag_check_only = FLAGGED; break; case 'q': /* disables describing messages */ flag_be_verbose = UNFLAGGED; break; case 'i': /* expects infile */ infilename=optarg; break; case 'o': /* expects outfile */ outfilename=optarg; break; case 'x': /* expects tagnumber */ clean_tag =atoi(optarg); break; case '?': /* something goes wrong */ if (optopt == 'i' || optopt == 'o' || optopt == 'x') fprintf (stderr, "Option -%c requires an argument.\n", optopt); else if (isprint (optopt)) fprintf (stderr, "Unknown option `-%c'.\n", optopt); else if (0 !=optopt) { fprintf (stderr, "Unknown option character `\\x%x'.\n", optopt); return (-1); } break; default: abort(); } } /* added additional checks */ /* TODO: add check that no inline and no check if cleantag */ if ((UNFLAGGED != clean_tag) && (clean_tag < 254) && (clean_tag > 65535)) { fprintf(stderr, "The option '-x' expects a value in range 254..65535, see '%s -h' for details\n", argv[0]); exit(FIXIT_TIFF_CMDLINE_ARGUMENTS_ERROR); } if ((FLAGGED == flag_substitute_only) && (FLAGGED == flag_check_only)) { fprintf (stderr, "The options '-s' and '-c' could not be used in combination, see '%s -h' for details\n", argv[0]); exit (FIXIT_TIFF_CMDLINE_ARGUMENTS_ERROR); } if (NULL == infilename) { fprintf (stderr, "You need to specify infile with '-i filename', see '%s -h' for details\n", argv[0]); exit (FIXIT_TIFF_MISSED_INFILE); } if ((FLAGGED!=flag_substitute_only) && (FLAGGED!=flag_check_only)) { if (NULL == outfilename) { fprintf (stderr, "You need to specify outfile with '-o outfilename', see '%s -h' for details\n", argv[0]); exit (FIXIT_TIFF_MISSED_OUTFILE); } } if (FLAGGED == flag_be_verbose) printf ("infile='%s', outfile='%s'\n", infilename, outfilename); /* check only if file is valid */ if (FLAGGED == flag_check_only) { /* exit ( check_required(infilename)); */ exit ( check_required(infilename) || check_baseline(infilename) || check_datetime(infilename) ); } /* try to fix tag order */ if (FLAGGED == flag_tagorder) { copy_file (infilename, outfilename); if (FLAGGED == flag_be_verbose) printf ("tagorder cleanup infile='%s', outfile='%s'\n", infilename, outfilename); cleanup_tagorder(outfilename); exit (FIXIT_TIFF_IS_CORRECTED); } if (UNFLAGGED != clean_tag) { /* explicite correction via source target, clean given tag */ copy_file (infilename, outfilename); if (FLAGGED == flag_be_verbose) printf ("tag cleanup infile='%s', outfile='%s'\n", infilename, outfilename); cleanup_tag(outfilename, clean_tag); exit (FIXIT_TIFF_IS_CORRECTED); } /* inplace correction */ if (FLAGGED == flag_substitute_only) { /* inplace correction */ cleanup_datetime(infilename); if (FLAGGED == flag_baseline_cleanup) { /* baseline tiff cleanup */ cleanup_baseline(infilename); } } else { /* explicite correction via source target */ copy_file (infilename, outfilename); cleanup_datetime(outfilename); if (FLAGGED == flag_baseline_cleanup) { /* baseline tiff cleanup */ if (FLAGGED == flag_be_verbose) printf ("baseline cleanup infile='%s', outfile='%s'\n", infilename, outfilename); cleanup_baseline(outfilename); } } exit (FIXIT_TIFF_IS_CORRECTED); }
void supersection_t::parse(secfile_t &inf) { std::string s; cur_type_t cur; int idx = -1; // TODO: size_t while(cur_type_t::unknown != (cur = check_string(inf, s))) // TODO: while type = inf.read_string_no_clear() ... { std::cerr << "Trying to parse section/leaf: " << s << std::endl; switch(cur) { case cur_type_t::multi: { idx = std::stoi(s); std::cerr << "Reading multi object: " << idx << "..." << std::endl; auto ptr = leaf_factory->make(); ptr->_parse(inf); multi_sections[idx] = ptr; } break; case cur_type_t::batch: { auto ptr = leaf_factory->make(); ptr->_parse(inf); multi_sections[++idx] = ptr; } break; case cur_type_t::super: super_itr->second->_parse(inf); { const auto pr = hooks.find(super_itr->second); if(pr != hooks.end()) (this->*(pr->second))(); } break; case cur_type_t::leaf: leaf_itr->second->_parse(inf); { const auto pr = hooks.find(leaf_itr->second); if(pr != hooks.end()) (this->*(pr->second))(); } break; default: throw "Impossible"; break; } } std::cerr << "Left on reading: " << s << ":" << std::endl << " - `" << s << "' is no known super section or leaf" << std::endl; if(type == type_t::multi) { std::cerr << " - `" << s << "' is no number" << std::endl; } else if(type == type_t::batch) { std::cerr << " - `" << s << "' does not match the batch string `" << batch_str << "'" << std::endl; } std::cerr << std::endl; if(!check_required() || inf.stream.eof()) inf.set_bad(); process(); }