C++ print_arguments函数代码示例

static void generate_interface_xml(GString *gstr, struct interface_data *iface)
{
	const GDBusMethodTable *method;
	const GDBusSignalTable *signal;

	for (method = iface->methods; method && method->name; method++) {
		if (!strlen(method->signature) && !strlen(method->reply))
			g_string_append_printf(gstr, "\t\t<method name=\"%s\"/>\n",
								method->name);
		else {
			g_string_append_printf(gstr, "\t\t<method name=\"%s\">\n",
								method->name);
			print_arguments(gstr, method->signature, "in");
			print_arguments(gstr, method->reply, "out");
			g_string_append_printf(gstr, "\t\t</method>\n");
		}
	}

	for (signal = iface->signals; signal && signal->name; signal++) {
		if (!strlen(signal->signature))
			g_string_append_printf(gstr, "\t\t<signal name=\"%s\"/>\n",
								signal->name);
		else {
			g_string_append_printf(gstr, "\t\t<signal name=\"%s\">\n",
								signal->name);
			print_arguments(gstr, signal->signature, NULL);
			g_string_append_printf(gstr, "\t\t</signal>\n");
		}
	}
}

static void generate_interface_xml(GString *gstr, struct interface_data *iface)
{
	const GDBusMethodTable *method;
	const GDBusSignalTable *signal;

	for (method = iface->methods; method && method->name; method++) {
		gboolean deprecated = method->flags &
						G_DBUS_METHOD_FLAG_DEPRECATED;
		gboolean noreply = method->flags &
						G_DBUS_METHOD_FLAG_NOREPLY;

		if (!deprecated && !noreply &&
				!(method->in_args && method->in_args->name) &&
				!(method->out_args && method->out_args->name))
			g_string_append_printf(gstr, "\t\t<method name=\"%s\"/>\n",
								method->name);
		else {
			g_string_append_printf(gstr, "\t\t<method name=\"%s\">\n",
								method->name);
			print_arguments(gstr, method->in_args, "in");
			print_arguments(gstr, method->out_args, "out");

			if (deprecated)
				g_string_append_printf(gstr, "\t\t\t<annotation name=\"org.freedesktop.DBus.Deprecated\" value=\"true\"/>\n");

			if (noreply)
				g_string_append_printf(gstr, "\t\t\t<annotation name=\"org.freedesktop.DBus.Method.NoReply\" value=\"true\"/>\n");

			g_string_append_printf(gstr, "\t\t</method>\n");
		}
	}

	for (signal = iface->signals; signal && signal->name; signal++) {
		gboolean deprecated = signal->flags &
						G_DBUS_SIGNAL_FLAG_DEPRECATED;

		if (!deprecated && !(signal->args && signal->args->name))
			g_string_append_printf(gstr, "\t\t<signal name=\"%s\"/>\n",
								signal->name);
		else {
			g_string_append_printf(gstr, "\t\t<signal name=\"%s\">\n",
								signal->name);
			print_arguments(gstr, signal->args, NULL);

			if (deprecated)
				g_string_append_printf(gstr, "\t\t\t<annotation name=\"org.freedesktop.DBus.Deprecated\" value=\"true\"/>\n");

			g_string_append_printf(gstr, "\t\t</signal>\n");
		}
	}
}

int main(int argc, char *argv[]){
    
    print_arguments(argc, argv);

    return 0;

}

int main(int argc , char *argv[])
{
	print_arguments(argc, argv);
	find_negative(argc, argv);
	//printf("Argc is %d.\n",argc);
	return 0;
}

int main(int argc, char *argv[]) {

	print_arguments(argc, argv);

    int a = 1;
    int b = 2;
    char _string[] = "string";
    int areas[] = {10, 12, 13, 14, 20};
    int numbers[4] = {0, 1};

    printf("a: %d, b: %d \n", a, b);
    printf("%s \n", _string);
 	printf("The number of ints in areas: %ld\n",
           sizeof(areas) / sizeof(int));
 	printf("numbers: %d %d %d %d\n",
            numbers[0], numbers[1],
            numbers[2], numbers[3]);

 	int i = 0;
    for(i = 1; i < argc; i++) {
        printf("arg %d: %s\n", i, argv[i]);
    }

    return 0;
}

/* Prints the instruction by calling print_arguments after proper matching: */
int
print_insn_crx(bfd_vma memaddr, struct disassemble_info *info)
{
  int is_decoded;     /* Nonzero means instruction has a match.  */

  /* Initialize global variables: */
  cst4flag = 0;
  size_changed = 0;

  /* Retrieve the encoding from current memory location: */
  get_words_at_PC(memaddr, info);
  /* Find a matching opcode in table: */
  is_decoded = match_opcode();
  /* If found, print the instruction's mnemonic and arguments: */
  if ((is_decoded > 0) && (((words[0] << 16) != 0) || (words[1] != 0)))
    {
      info->fprintf_func(info->stream, "%s", instruction->mnemonic);
      if ((currInsn.nargs = get_number_of_operands()) != 0)
	info->fprintf_func(info->stream, "\t");
      make_instruction();
      print_arguments(&currInsn, memaddr, info);
      return currInsn.size;
    }

  /* No match found: */
  info->fprintf_func(info->stream, "%s ", ILLEGAL);
  return 2;
}

/* mon_backtrace prints the current stack backtrace. */
int mon_backtrace(int argc, char **argv)
{
	int *fp = NULL;
	int pc = 0;

	(void) argc;
	(void) argv;
	
	fp = read_fp();
	pc = fp[0];

	while (fp != NULL) {
		int lr = fp[-1];
		struct DebugInfo info = get_debug_info(pc);

		if ((int) fp == lr)
			break;

		kprintf("  fp: %x, lr: %x\n", fp, lr);
		kprintf("    %s:%s:%d\n", info.file, info.function,
			info.source_line_number);

		if (info.arg_count != 0)
			print_arguments(&info, fp);

		pc = lr;
		fp = (int *) fp[-3];
	}

	return 0;
}

int main(int argc, char *argv[])
{
  print_arguments(argc, argv);
  //char derp[] = "for reals";
  //char *herp[] = {"for reals", "for srs"};
  //printf("%s\n", derp);
  //printf("%s\n", herp[1]);
  return 0;
}

int main(int argc, char ** argv) {
  print_arguments();


  std::cout << "Starting Reactor" << std::endl;

  reactor_loop_init();

  return 0;
}

 void visit(const CompressedNode * e){
   if(e->arguments.size() == 1){
     e->arguments[0]->accept(this);
   }
   else{
     stream << '{';
     print_arguments(e);
     stream << '}';
   }
 }

void cpn_opts_usage(const struct cpn_opt *opts,
        const char *executable, FILE *out)
{
    fputs("USAGE: ", out);
    print_header(opts, executable, NULL, out);
    if (has_actions(opts) || has_options(opts))
        fputc('\n', out);
    print_arguments(opts, out, 1);
    if (has_actions(opts) && has_options(opts))
        fputc('\n', out);
    print_actions(opts, out, 1);
}

static void print_actions(const struct cpn_opt *opts, FILE *out, int indent)
{
    const struct cpn_opt *it;
    int i;

    for (it = opts; it && it->type != CPN_OPTS_TYPE_END; it++) {
        if (it->type != CPN_OPTS_TYPE_ACTION)
            continue;

        for (i = indent; i; i--)
            fputc('\t', out);
        print_header(it->value.action_opts, it->long_name, it->description, out);
        print_arguments(it->value.action_opts, out, indent + 1);
        if (has_actions(it) && has_options(it))
            fputc('\n', out);
        print_actions(it->value.action_opts, out, indent + 1);
    }
}

static int check_authorization(DBusConnection *conn)
{
    DBusMessage *msg, *reply;
    DBusMessageIter iter;
    DBusError err;

    msg = dbus_message_new_method_call(AUTHORITY_DBUS, AUTHORITY_PATH,
                                       AUTHORITY_INTF, "CheckAuthorization");
    if (!msg) {
        fprintf(stderr, "Can't allocate new method call\n");
        return -ENOMEM;
    }

    dbus_message_iter_init_append(msg, &iter);
    add_arguments(conn, &iter);

    dbus_error_init(&err);

    reply = dbus_connection_send_with_reply_and_block(conn, msg, -1, &err);

    dbus_message_unref(msg);

    if (!reply) {
        if (dbus_error_is_set(&err)) {
            fprintf(stderr, "%s\n", err.message);
            dbus_error_free(&err);
        } else
            fprintf(stderr, "Can't check authorization\n");
        return -EIO;
    }

    if (dbus_message_has_signature(reply, "(bba{ss})") == TRUE) {
        dbus_message_iter_init(reply, &iter);
        print_arguments(&iter);
    }

    dbus_message_unref(reply);

    return 0;
}

int main(int argc, char *argv[]) {
    // note syntax is argv not argv[]
    print_arguments(argc, argv);

    return 0;
}

int main(int argc, char *argv[]) {
    int err = 0;
    double *m = NULL;
    double *c = NULL;
    double *x = NULL;

    gsl_rng_env_setup();
    const gsl_rng_type  *T   = gsl_rng_default;
    gsl_rng            **rng = NULL;

    DEBUGPRINT("### Parsing arguments");
    struct arguments args;
    initialise_arguments(&args);
    argp_parse (&argp, argc, argv, 0, 0, &args);
#ifdef DEBUG
    print_arguments(&args);
#endif

    DEBUGPRINT("### Reading input configuration");
    struct input_config cfg;
    read_input_config(args.input_file, &cfg);
#ifdef DEBUG
    print_input_config(&cfg);
#endif
    
    DEBUGPRINT("### Generating realization");
    int  n_threads = omp_get_max_threads();
    
    rng = malloc(n_threads * sizeof(gsl_rng *));
    if (!rng) {
        printf("Error: Could not allocate memory for 'rng'.\n");
        err = -1;
        goto cleanup;
    }
    for (int i = 0; i < n_threads; i++) {
        rng[i] = gsl_rng_alloc(T);
        gsl_rng_set(rng[i], cfg.rng_seed + i);
    }

    ptrdiff_t  n   = 1;
    double     vol = 1.0;
    for (int i = 0; i < cfg.levy_basis_rank; i++) {
        n *= (ptrdiff_t)cfg.levy_basis_dimension[i];
        vol *= cfg.levy_basis_resolution[i];
    }
    
    x = malloc(n * cfg.levy_seed_dimension * sizeof(double));
    if (!x) {
        printf("Error: Could not allocate memory for 'x'.\n");
        err = -1;
        goto cleanup;
    }
    
    if (strcmp(cfg.levy_seed_family, "normal") == 0) {
        struct normal_seed_parameters *q = cfg.levy_seed_parameters;
        int dim = cfg.levy_seed_dimension;
        m = calloc(dim, sizeof(double));
        c = calloc(dim * dim, sizeof(double));
        for (int i = 0; i < dim; i++)
            m[i] = q->mean[i] * vol;
        for (int i = 0; i < dim * dim; i++)
            c[i] = q->covariance[i] * vol;
        err = generate_multivariate_normal(n_threads, rng, dim, m, c, n, x);
        if (err) {
            printf("Error in generate_multivariate_normal.\n");
            goto cleanup;
        }
        
    }
    else {
        printf("Error: The Levy seed family \"%s\" is not yet supported.\n", cfg.levy_seed_family);
        err = -1;
        goto cleanup;
    }

    DEBUGPRINT("### Writing output");
    write_output(args.output_file, &cfg, x);
    
  cleanup:
    free(c);
    free(m);
    free(x);
    for (int i = 0; i < n_threads; i++)
        gsl_rng_free(rng[i]);
    free(rng);
    return err;
}