自学教程：C++ usage_error函数代码示例

static voidparse_args(int argc, char **argv,           void (**test_func)(Display*, GLXDrawable)){	int i;	/* Count of parsed args, excluding -auto. */	int num_parsed_args = 0;	for (i = 1; i < argc; ++i) {		const char *arg = argv[i];		if (!strncmp(arg, "-auto", 5)) {			piglit_automatic = 1;		} else if (!strncmp(arg, "--bad-drawable", 14)) {			++num_parsed_args;			*test_func = query_bad_drawable;		} else if (!strncmp(arg, "--attr=GLX_WIDTH", 16)) {			++num_parsed_args;			*test_func = query_width;		} else if (!strncmp(arg, "--attr=GLX_HEIGHT", 17)) {			++num_parsed_args;			*test_func = query_height;		} else {		   /* Unrecognized argument. */		   usage_error();		}	}	if (num_parsed_args != 1) {	   usage_error();	}}

/* ------------------------------------------------------------------------@NAME       : bt_set_stringopts@INPUT      : metatype              options@OUTPUT     : @RETURNS    : @DESCRIPTION: Sets the string-processing options for a particular               entry metatype.  Used later on by bt_parse_* to determine              just how to post-process each particular entry.@GLOBALS    : StringOptions@CREATED    : 1997/08/24, GPW@MODIFIED   : -------------------------------------------------------------------------- */void bt_set_stringopts (bt_metatype metatype, ushort options){   if (metatype < BTE_REGULAR || metatype > BTE_MACRODEF)      usage_error ("bt_set_stringopts: illegal metatype");   if (options & ~BTO_STRINGMASK)      usage_error ("bt_set_stringopts: illegal options "                   "(must only set string option bits");   StringOptions[metatype] = options;}

gbooleanflatpak_builtin_document_unexport (int argc, char **argv,                                   GCancellable *cancellable,                                   GError **error){  g_autoptr(GOptionContext) context = NULL;  g_autoptr(GDBusConnection) session_bus = NULL;  XdpDbusDocuments *documents;  const char *file;  g_autofree char *doc_id = NULL;  context = g_option_context_new (_("FILE - Unexport a file to apps"));  g_option_context_set_translation_domain (context, GETTEXT_PACKAGE);  if (!flatpak_option_context_parse (context, options, &argc, &argv,                                     FLATPAK_BUILTIN_FLAG_NO_DIR,                                     NULL, cancellable, error))    return FALSE;  if (argc < 2)    return usage_error (context, _("FILE must be specified"), error);  if (argc > 2)    return usage_error (context, _("Too many arguments"), error);  file = argv[1];  session_bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, error);  if (session_bus == NULL)    return FALSE;  documents = xdp_dbus_documents_proxy_new_sync (session_bus, 0,                                                 "org.freedesktop.portal.Documents",                                                 "/org/freedesktop/portal/documents",                                                 NULL, error);  if (documents == NULL)    return FALSE;  if (!xdp_dbus_documents_call_lookup_sync (documents, file, &doc_id, NULL, error))    return FALSE;  if (strcmp (doc_id, "") == 0)    {      g_print (_("Not exported/n"));      return TRUE;    }  if (!xdp_dbus_documents_call_delete_sync (documents, doc_id, NULL, error))    return FALSE;  return TRUE;}

voidimpl::app::process_options(void){    assert(inited());    std::string optstr;#if defined(HAVE_GNU_GETOPT)    optstr += '+'; // Turn on POSIX behavior.#endif    optstr += ':';    {        options_set opts = options();        for (options_set::const_iterator iter = opts.begin();             iter != opts.end(); iter++) {            const option& opt = (*iter);            optstr += opt.m_character;            if (!opt.m_argument.empty())                optstr += ':';        }    }    int ch;    const int old_opterr = ::opterr;    ::opterr = 0;    while ((ch = ::getopt(m_argc, m_argv, optstr.c_str())) != -1) {        switch (ch) {            case 'h':                m_hflag = true;                break;            case ':':                throw usage_error("Option -%c requires an argument.",                                  ::optopt);            case '?':                throw usage_error("Unknown option -%c.", ::optopt);            default:                process_option(ch, ::optarg);        }    }    m_argc -= ::optind;    m_argv += ::optind;    // Clear getopt state just in case the test wants to use it.    opterr = old_opterr;    optind = 1;#if defined(HAVE_OPTRESET)    optreset = 1;#endif}

gbooleanxdg_app_builtin_build_export (int argc, char **argv, GCancellable *cancellable, GError **error){  gboolean ret = FALSE;  g_autoptr(GOptionContext) context = NULL;  g_autoptr(GFile) base = NULL;  g_autoptr(GFile) files = NULL;  g_autoptr(GFile) metadata = NULL;  g_autoptr(GFile) export = NULL;  g_autoptr(GFile) repofile = NULL;  g_autoptr(GFile) arg = NULL;  g_autoptr(GFile) root = NULL;  g_autoptr(OstreeRepo) repo = NULL;  const char *location;  const char *directory;  const char *branch;  g_autofree char *arch = NULL;  g_autofree char *full_branch = NULL;  g_autofree char *app_id = NULL;  g_autofree char *parent = NULL;  g_autofree char *commit_checksum = NULL;  g_autofree char *metadata_contents = NULL;  g_autofree char *format_size = NULL;  g_autoptr(OstreeMutableTree) mtree = NULL;  g_autoptr(GKeyFile) metakey = NULL;  gsize metadata_size;  g_autofree char *subject = NULL;  g_autofree char *body = NULL;  OstreeRepoTransactionStats stats;  OstreeRepoCommitModifier *modifier = NULL;  context = g_option_context_new ("LOCATION DIRECTORY [BRANCH] - Create a repository from a build directory");  if (!xdg_app_option_context_parse (context, options, &argc, &argv, XDG_APP_BUILTIN_FLAG_NO_DIR, NULL, cancellable, error))    goto out;  if (argc < 3)    {      usage_error (context, "LOCATION and DIRECTORY must be specified", error);      goto out;    }  location = argv[1];  directory = argv[2];  if (argc >= 4)    branch = argv[3];  else    branch = "master";  if (!xdg_app_is_valid_branch (branch))    {      xdg_app_fail (error, "'%s' is not a valid branch name", branch);      goto out;    }  base = g_file_new_for_commandline_arg (directory);  files = g_file_get_child (base, "files");  metadata = g_file_get_child (base, "metadata");  export = g_file_get_child (base, "export");

gbooleanflatpak_builtin_document_list (int argc, char **argv,                               GCancellable *cancellable,                               GError **error){  g_autoptr(GOptionContext) context = NULL;  const char *app_id = NULL;  g_autofree char *col_help = NULL;  g_autofree Column *columns = NULL;  context = g_option_context_new (_("[APPID] - List exported files"));  g_option_context_set_translation_domain (context, GETTEXT_PACKAGE);  col_help = column_help (all_columns);  g_option_context_set_description (context, col_help);  if (!flatpak_option_context_parse (context, options, &argc, &argv,                                     FLATPAK_BUILTIN_FLAG_NO_DIR,                                     NULL, cancellable, error))    return FALSE;  if (argc > 2)    return usage_error (context, _("Too many arguments"), error);  if (argc == 2)    app_id = argv[1];  columns = handle_column_args (all_columns, FALSE, opt_cols, error);  if (columns == NULL)    return FALSE;  return print_documents (app_id, columns, cancellable, error);}

gbooleanflatpak_builtin_ps (int           argc,                    char        **argv,                    GCancellable *cancellable,                    GError      **error){  g_autoptr(GOptionContext) context = NULL;  g_autofree char *col_help = NULL;  g_autofree Column *columns = NULL;  context = g_option_context_new (_(" - Enumerate running sandboxes"));  g_option_context_set_translation_domain (context, GETTEXT_PACKAGE);  col_help = column_help (all_columns);  g_option_context_set_description (context, col_help);  if (!flatpak_option_context_parse (context, options, &argc, &argv, FLATPAK_BUILTIN_FLAG_NO_DIR, NULL, cancellable, error))    return FALSE;  if (argc > 1)    {      usage_error (context, _("Extra arguments given"), error);      return FALSE;    }  columns = handle_column_args (all_columns, FALSE, opt_cols, error);  if (columns == NULL)    return FALSE;  return enumerate_instances (columns, error);}

gbooleanflatpak_builtin_delete_remote (int argc, char **argv, GCancellable *cancellable, GError **error){  g_autoptr(GOptionContext) context = NULL;  g_autoptr(FlatpakDir) dir = NULL;  const char *remote_name;  context = g_option_context_new ("NAME - Delete a remote repository");  g_option_context_add_main_entries (context, delete_options, NULL);  if (!flatpak_option_context_parse (context, NULL, &argc, &argv, 0, &dir, cancellable, error))    return FALSE;  if (argc < 2)    return usage_error (context, "NAME must be specified", error);  remote_name = argv[1];  if (!flatpak_dir_remove_remote (dir, opt_force, remote_name,                                  cancellable, error))    return FALSE;  return TRUE;}

void symex_parse_optionst::get_command_line_options(optionst &options){  if(config.set(cmdline))  {    usage_error();    exit(1);  }  if(cmdline.isset("debug-level"))    options.set_option("debug-level", cmdline.get_value("debug-level"));  if(cmdline.isset("unwindset"))    options.set_option("unwindset", cmdline.get_value("unwindset"));  // all checks supported by goto_check  GOTO_CHECK_PARSE_OPTIONS(cmdline, options);  // check assertions  if(cmdline.isset("no-assertions"))    options.set_option("assertions", false);  else    options.set_option("assertions", true);  // use assumptions  if(cmdline.isset("no-assumptions"))    options.set_option("assumptions", false);  else    options.set_option("assumptions", true);  // magic error label  if(cmdline.isset("error-label"))    options.set_option("error-label", cmdline.get_values("error-label"));}

staticatf_error_thandle_tcarg(const char *tcarg, char **tcname, enum tc_part *tcpart){    atf_error_t err;    err = atf_no_error();    *tcname = strdup(tcarg);    if (*tcname == NULL) {        err = atf_no_memory_error();        goto out;    }    char *delim = strchr(*tcname, ':');    if (delim != NULL) {        *delim = '/0';        delim++;        if (strcmp(delim, "body") == 0) {            *tcpart = BODY;        } else if (strcmp(delim, "cleanup") == 0) {            *tcpart = CLEANUP;        } else {            err = usage_error("Invalid test case part `%s'", delim);            goto out;        }    }out:    return err;}

static voidoutput_property(bool* first,                char sep,                const char* format,                const char* name,                const char* value){    if (*first)        *first = false;    else        xputc(sep, xstdout);    char c;    bool escaped = false;    while ((c = *format++)) {        if (escaped) {            if (c == '%') {                xputc('%', xstdout);            } else if (c == 'n') {                xputs(name, xstdout);            } else if (c == 'v' && value) {                xputs(value, xstdout);            } else {                usage_error("incorrect format string /"%s/"", format-2);            }            escaped = false;        } else {            if (c == '%') {                escaped = true;            } else {                xputc(c, xstdout);            }        }    }}

static voidparse_args(int *argc, char **argv,	   const char ***selected_subtests,	   size_t *num_selected_subtests){	*selected_subtests = NULL;	*num_selected_subtests = 0;	prog_name = basename(argv[0]);	if (*argc == 1) {		return;	}	if (streq(argv[1], "-h") || streq(argv[1], "--help")) {		print_usage();		exit(0);	}	/* Strip common piglit args. */	piglit_strip_arg(argc, argv, "-fbo");	piglit_strip_arg(argc, argv, "-auto");	piglit_parse_subtest_args(argc, argv, subtests, selected_subtests,			          num_selected_subtests);	if (*argc > 1) {		piglit_loge("unrecognized option: %s", argv[1]);		usage_error();	}}

gbooleaninstall_bundle (FlatpakDir *dir,                GOptionContext *context,                int argc, char **argv,                GCancellable *cancellable,                GError **error){  g_autoptr(GFile) file = NULL;  const char *filename;  g_autoptr(GBytes) gpg_data = NULL;  if (argc < 2)    return usage_error (context, "bundle filename must be specified", error);  filename = argv[1];  file = g_file_new_for_commandline_arg (filename);  if (opt_gpg_file != NULL)    {      /* Override gpg_data from file */      gpg_data = read_gpg_data (cancellable, error);      if (gpg_data == NULL)        return FALSE;    }  if (!flatpak_dir_install_bundle (dir, file, gpg_data, NULL,                                   cancellable, error))    return FALSE;  return TRUE;}

bool finalize(char *hdrs, sendip_data *headers[], sendip_data *data,				  sendip_data *pack) {	if(hdrs[strlen(hdrs)-1] != 'u') {		usage_error("Warning: RIPng should be contained in a UDP packet/n");	}	return TRUE;}

int main (int argc, char* argv[]) {	unsigned gpio;	if (argc < 3) {		usage_error();		exit(EXIT_FAILURE);	}}

staticatf_error_trun_tc(const atf_tp_t *tp, struct params *p, int *exitcode){    atf_error_t err;    err = atf_no_error();    if (!atf_tp_has_tc(tp, p->m_tcname)) {        err = usage_error("Unknown test case `%s'", p->m_tcname);        goto out;    }    if (!atf_env_has("__RUNNING_INSIDE_ATF_RUN") || strcmp(atf_env_get(        "__RUNNING_INSIDE_ATF_RUN"), "internal-yes-value") != 0)    {        print_warning("Running test cases outside of kyua(1) is unsupported");        print_warning("No isolation nor timeout control is being applied; you "                      "may get unexpected failures; see atf-test-case(4)");    }    switch (p->m_tcpart) {    case BODY:        err = atf_tp_run(tp, p->m_tcname, atf_fs_path_cstring(&p->m_resfile));        if (atf_is_error(err)) {            /* TODO: Handle error */            *exitcode = EXIT_FAILURE;            atf_error_free(err);        } else {            *exitcode = EXIT_SUCCESS;        }        break;    case CLEANUP:        err = atf_tp_cleanup(tp, p->m_tcname);        if (atf_is_error(err)) {            /* TODO: Handle error */            *exitcode = EXIT_FAILURE;            atf_error_free(err);        } else {            *exitcode = EXIT_SUCCESS;        }        break;    default:        UNREACHABLE;    }    INV(!atf_is_error(err));out:    return err;}

intmain(int argc, char **argv){	GLenum internal_format = 0;	EGLDisplay dpy;	EGLContext ctx;	bool ok;	/* Strip common piglit args. */	piglit_strip_arg(&argc, argv, "-fbo");	piglit_strip_arg(&argc, argv, "-auto");	if (argc == 2) {		if (streq(argv[1], "GL_RGBA")) {			internal_format = GL_RGBA;		} else if (streq(argv[1], "GL_DEPTH_COMPONENT24")) {			internal_format = GL_DEPTH_COMPONENT24;		}	}	if (internal_format == 0)		usage_error();	dpy = create_display();	ctx = create_context(dpy);	ok = eglMakeCurrent(dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, ctx);	if (!ok) {		piglit_loge("failed to make context current without surface");		piglit_report_result(PIGLIT_FAIL);	}	piglit_dispatch_default_init(PIGLIT_DISPATCH_ES2);	if (!piglit_is_extension_supported("GL_OES_EGL_image")) {		piglit_loge("context does not support GL_OES_EGL_image");		piglit_report_result(PIGLIT_SKIP);	}	switch (internal_format) {	case GL_RGBA:		test_rgba(dpy, ctx);		break;	case GL_DEPTH_COMPONENT24:		test_depth24(dpy, ctx);		break;	default:		break;	}	/* unreachable */	abort();}

/* ------------------------------------------------------------------------@NAME       : bt_postprocess_field()@INPUT      : @OUTPUT     : @RETURNS    : @DESCRIPTION: Postprocesses all the strings in a single "field = value"              assignment subtree.  Just checks that 'field' does indeed              point to an BTAST_FIELD node (presumably the parent of a list              of simple values), downcases the field name, and calls              bt_postprocess_value() on the value.@GLOBALS    : @CALLS      : @CALLERS    : @CREATED    : 1997/08/25, GPW@MODIFIED   : -------------------------------------------------------------------------- */char *bt_postprocess_field (AST * field, btshort options, boolean replace){   if (field == NULL) return NULL;   if (field->nodetype != BTAST_FIELD)      usage_error ("bt_postprocess_field: invalid AST node (not a field)");   strlwr (field->text);                /* downcase field name */   return bt_postprocess_value (field->down, options, replace);} /* bt_postprocess_field() */

int main(int argc, char *argv[]){  char* endptr;  sysop = _sysop;  syserrm = _syserrm;  syserrc = _syserrc;  check_plugin = _check_plugin;#if ENABLE_SEM  do_inter_lock_init  = _do_inter_lock_init;  do_inter_lock_reset = _do_inter_lock_reset;  do_inter_lock = _do_inter_lock;  do_inter_unlock = _do_inter_unlock;#endif/*------------------------ get host name */  if (gethostname((char*)hostname,255) == -1)     dm_error(errno, "gethostname");/*------------------------ parse arguments */  if (argc != 2) usage_error(0);  switch (serverport = strtol(argv[1], &endptr, 0)) {    case LONG_MAX: case LONG_MIN:       if (errno) usage_error(errno);  }  if (! *(argv[1]) || *endptr) usage_error(errno);  serverport += getportoffset();  initfds();/*------------- make server socket and listen on it -----------------Note: all communication errors that can only be due to faulty code(rather than an external condition) are reported through 'error' andthus lead to termination of this process.*/  run_dnode_mill();}

/* ------------------------------------------------------------------------@NAME       : bt_parse_entry_s()@INPUT      : entry_text - string containing the entire entry to parse,                           or NULL meaning we're done, please cleanup              options    - standard btparse options bitmap              line       - current line number (if that makes any sense)                           -- passed to the parser to set zzline, so that                           lexical and syntax errors are properly localized@OUTPUT     : *top       - newly-allocated AST for the entry                           (or NULL if entry_text was NULL, ie. at EOF)@RETURNS    : 1 with *top set to AST for entry on successful read/parse              1 with *top==NULL if entry_text was NULL, ie. at EOF              0 if any serious errors seen in input (*top is still                 set to the AST, but only for as much of the input as we                were able to parse)              (A "serious" error is a lexical or syntax error; "trivial"              errors such as warnings and notifications count as "success"              for the purposes of this function's return value.)@DESCRIPTION: Parses a BibTeX entry contained in a string.@GLOBALS    : @CALLS      : ANTLR@CREATED    : 1997/01/18, GPW (from code in bt_parse_entry())@MODIFIED   : -------------------------------------------------------------------------- */AST * bt_parse_entry_s (char *    entry_text,                        char *    filename,                        int       line,                        ushort    options,                        boolean * status){   AST *        entry_ast = NULL;   static int * err_counts = NULL;   if (options & BTO_STRINGMASK)        /* any string options set? */   {      usage_error ("bt_parse_entry_s: illegal options "                   "(string options not allowed");   }   InputFilename = filename;   err_counts = bt_get_error_counts (err_counts);   if (entry_text == NULL)              /* signal to clean up */   {      finish_parse (&err_counts);      if (status) *status = TRUE;      return NULL;   }   zzast_sp = ZZAST_STACKSIZE;          /* workaround apparent pccts bug */   start_parse (NULL, entry_text, line);   entry (&entry_ast);                  /* enter the parser */   ++zzasp;                             /* why is this done? */   if (entry_ast == NULL)               /* can happen with very bad input */   {      if (status) *status = FALSE;      return entry_ast;   }#if DEBUG   dump_ast ("bt_parse_entry_s: single entry, after parsing:/n",              entry_ast);#endif   bt_postprocess_entry (entry_ast,                         StringOptions[entry_ast->metatype] | options);#if DEBUG   dump_ast ("bt_parse_entry_s: single entry, after post-processing:/n",             entry_ast);#endif   if (status) *status = parse_status (err_counts);   return entry_ast;} /* bt_parse_entry_s () */

/* ------------------------------------------------------------------------@NAME       : bt_entry_set_key ()@INPUT      : entry              new_key@OUTPUT     : entry->down->text@RETURNS    : @DESCRIPTION: Changes the key of a regular entry to 'new_key'.  If 'entry'              is not a regular entry, or if it doesn't already have a child              node holding an entry key, bombs via 'usage_error()'.              Otherwise a duplicate of 'new_key' is copied into the entry              AST (so the caller can free that string without worry).@CALLS      : bt_set_text ()@CREATED    : 1999/11/25, GPW (from Stephane Genaud)@MODIFIED   : -------------------------------------------------------------------------- */void bt_entry_set_key (AST * entry, char * new_key){   if (entry->metatype == BTE_REGULAR &&       entry->down && entry->down->nodetype == BTAST_KEY)   {      bt_set_text (entry->down, new_key);   }   else   {      usage_error ("can't set entry key -- not a regular entry, "                   "or doesn't have a key already");   }}

intmain(int argc, char **argv){	prog_name = argv[0];	piglit_strip_arg(&argc, argv, "-auto");	piglit_strip_arg(&argc, argv, "-fbo");	if (argc != 2)		usage_error();	if (strcmp(argv[1], "1") == 0) {		test_1();	} else if (strcmp(argv[1], "2") == 0) {		test_2();	} else if (strcmp(argv[1], "3") == 0) {		test_3();	} else {		usage_error();	}	abort();}

int main(int argc, char *argv[]) {	cfs_status_init();	if (argc != 3) {		usage_error();	}	const char *dir_name = argv[1];	const char *dbfile = argv[2];	DIR *dh = opendir(dir_name);	if (!dh) {		perror("unable to open dir");		exit(-1);	}	memdb = memdb_open(dbfile);		struct dirent *de;	time_t ctime = time(NULL);	while((de = readdir(dh))) {		if (de->d_type != DT_REG) {			continue;		}		char *cdata = NULL;		gsize clen = 0;		char *fn = g_strdup_printf("%s/%s", dir_name, de->d_name);		if (g_file_get_contents(fn, &cdata, &clen, NULL)) {			//printf("FOUND %ld %s/n", clen, fn);			if (memdb_create(memdb, de->d_name, 0, ctime) != 0) {				fprintf(stderr, "memdb_create '%s' failed/n", de->d_name);				exit(-1);			}			if (memdb_write(memdb, de->d_name, 0, ctime, cdata, clen, 0, 1) != clen) {				fprintf(stderr, "memdb_write '%s' failed/n", de->d_name);				exit(-1);			}		}		g_free(fn);	}	memdb_close(memdb);	closedir(dh);}

intmain(int argc, char **argv){	progname = argv[0];	piglit_strip_arg(&argc, argv, "-auto");	if (argc != 2)		usage_error();	if (strcmp(argv[1], "gl") == 0) {		try_debug_flag(EGL_OPENGL_API, EGL_OPENGL_BIT);	} else if (strcmp(argv[1], "gles1") == 0) {		try_debug_flag(EGL_OPENGL_ES_API, EGL_OPENGL_ES_BIT);	} else if (strcmp(argv[1], "gles2") == 0) {		try_debug_flag(EGL_OPENGL_ES_API, EGL_OPENGL_ES2_BIT);	} else if (strcmp(argv[1], "gles3") == 0) {		try_debug_flag(EGL_OPENGL_ES_API, EGL_OPENGL_ES3_BIT_KHR);	} else {		usage_error();	}	abort();	return EXIT_FAILURE;}

gbooleanflatpak_builtin_uninstall (int argc, char **argv, GCancellable *cancellable, GError **error){  g_autoptr(GOptionContext) context = NULL;  g_autoptr(FlatpakDir) dir = NULL;  const char *name = NULL;  const char *branch = NULL;  g_autofree char *ref = NULL;  gboolean is_app;  FlatpakHelperUninstallFlags flags = 0;  context = g_option_context_new ("APP [BRANCH] - Uninstall an application");  if (!flatpak_option_context_parse (context, options, &argc, &argv, 0, &dir, cancellable, error))    return FALSE;  if (argc < 2)    return usage_error (context, "APP must be specified", error);  name = argv[1];  if (argc > 2)    branch = argv[2];  if (!opt_app && !opt_runtime)    opt_app = opt_runtime = TRUE;  ref = flatpak_dir_find_installed_ref (dir,                                        name,                                        branch,                                        opt_arch,                                        opt_app, opt_runtime, &is_app,                                        error);  if (ref == NULL)    return FALSE;  /* TODO: when removing runtimes, look for apps that use it, require --force */  if (opt_keep_ref)    flags |= FLATPAK_HELPER_UNINSTALL_FLAGS_KEEP_REF;  if (opt_force_remove)    flags |= FLATPAK_HELPER_UNINSTALL_FLAGS_FORCE_REMOVE;  if (!flatpak_dir_uninstall (dir, ref, flags,                              cancellable, error))    return FALSE;  return TRUE;}

bool tan_parseoptionst::check_and_set_options(){  if (config.set(cmdline))  {    usage_error();    return true;  }  if(cmdline.isset("version"))  {    std::cout << TAN_VERSION << std::endl;    return true;  }      int verbosity=6;  if(cmdline.isset("v")) verbosity=atoi(cmdline.getval("v"));  set_verbosity(verbosity);    if(cmdline.args.size()==0)  {    error("Please provide an input file.");    return 1;  }  else if (cmdline.args.size()>1)  {    error("Multiple input files not supported.");    return 1;  }    std::string engine="cta";  if(cmdline.isset("engine"))    engine=cmdline.getval("engine");    if(cmdline.isset("no-loop-slicing") &&     engine!="direct" && engine!="bre")    warning("Warning: --no-loop-slicing is only available "            "with the following engines: bre, direct.");    if(cmdline.isset("unranked-method"))  {    std::string u_mode=cmdline.getval("unranked-method");    if(u_mode!="none" && u_mode!="precondition" && u_mode!="bmc-precondition" &&        u_mode!="cegar" && u_mode!="bmc")      warning("Warning: unknown unranked-method.");      }      return false;}

staticatf_error_trun_tc(const atf_tp_t *tp, struct params *p, int *exitcode){    atf_error_t err;    err = atf_no_error();    if (!atf_tp_has_tc(tp, p->m_tcname)) {        err = usage_error("Unknown test case `%s'", p->m_tcname);        goto out;    }    switch (p->m_tcpart) {    case BODY:        err = atf_tp_run(tp, p->m_tcname, atf_fs_path_cstring(&p->m_resfile));        if (atf_is_error(err)) {            /* TODO: Handle error */            *exitcode = EXIT_FAILURE;            atf_error_free(err);        } else {            *exitcode = EXIT_SUCCESS;        }        break;    case CLEANUP:        err = atf_tp_cleanup(tp, p->m_tcname);        if (atf_is_error(err)) {            /* TODO: Handle error */            *exitcode = EXIT_FAILURE;            atf_error_free(err);        } else {            *exitcode = EXIT_SUCCESS;        }        break;    default:        UNREACHABLE;    }    INV(!atf_is_error(err));out:    return err;}

/// invoke main modulesint mmcc_parse_optionst::doit(){  if(cmdline.isset("version"))  {    std::cout << CBMC_VERSION << '/n';    return 0;  }  try  {    if(cmdline.args.size()==1)    {      std::ifstream in(cmdline.args[0].c_str());      if(!in)      {        std::cerr << "failed to open `" << cmdline.args[0] << "'/n";        return 2;      }      return convert(in, cmdline.args[0]);    }    else if(cmdline.args.size()==0)    {      return convert(std::cin, "stdin");    }    else    {      usage_error();      return 1;    }  }  catch(const char *error)  {    std::cerr << error << '/n';    return 10;  }  catch(const std::string error)  {    std::cerr << error << '/n';    return 10;  }  return 0;}

gbooleanxdg_app_builtin_dump_runtime (int argc, char **argv, GCancellable *cancellable, GError **error){  g_autoptr(GOptionContext) context = NULL;  g_autoptr(XdgAppDir) dir = NULL;  const char *runtime;  const char *branch = "master";  g_autofree char *ref = NULL;  OstreeRepo *repo;  g_autofree char *commit = NULL;  g_autoptr(GFile) root = NULL;  context = g_option_context_new ("RUNTIME BRANCH - Make branch of application current");  if (!xdg_app_option_context_parse (context, options, &argc, &argv, 0, &dir, cancellable, error))    return FALSE;  if (argc < 3)    return usage_error (context, "RUNTIME and BRANCH must be specified", error);  runtime  = argv[1];  branch = argv[2];  if (!xdg_app_is_valid_name (runtime))    return xdg_app_fail (error, "'%s' is not a valid name", runtime);  if (!xdg_app_is_valid_branch (branch))    return xdg_app_fail (error, "'%s' is not a valid branch name", branch);  ref = xdg_app_build_runtime_ref (runtime, branch, opt_arch);  repo = xdg_app_dir_get_repo (dir);  if (!ostree_repo_read_commit (repo, ref,                                &root, &commit, cancellable, error))    return FALSE;#ifdef HAVE_LIBARCHIVE  return dump_runtime (root, cancellable, error);#else  return xdg_app_fail (error, "Build without libarchive");#endif}