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

/* * Erase all currently displayed geometry and draw the specified object(s) * * Usage: * blast object(s) * */intged_blast(struct ged *gedp, int argc, const char *argv[]){    static const char *usage = "object(s)";    GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);    GED_CHECK_DRAWABLE(gedp, GED_ERROR);    GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);    /* initialize result */    bu_vls_trunc(gedp->ged_result_str, 0);    /* must be wanting help */    if (argc == 1) {	bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);	return GED_HELP;    }    /* First, clear the screen */    {	const char *av[2];	av[0] = "zap";	av[1] = (char *)0;	ged_zap(gedp, 1, av);    }    /* Draw the new object(s) */    return ged_draw(gedp, argc, argv);}

intged_cat(struct ged *gedp, int argc, const char *argv[]){    struct directory *dp;    int arg;    static const char *usage = "<objects>";    GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);    GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);    /* initialize result */    bu_vls_trunc(gedp->ged_result_str, 0);    /* must be wanting help */    if (argc == 1) {	bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);	return GED_HELP;    }    for (arg = 1; arg < argc; arg++) {	if ((dp = db_lookup(gedp->ged_wdbp->dbip, argv[arg], LOOKUP_NOISY)) == RT_DIR_NULL)	    continue;	_ged_do_list(gedp, dp, 0);	/* non-verbose */    }    return GED_OK;}

intged_model2view_lu(struct ged *gedp, int argc, const char *argv[]){    fastf_t f;    point_t view_pt;    double model_pt[3]; /* intentionally double for scan */    static const char *usage = "x y z";    GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);    GED_CHECK_VIEW(gedp, GED_ERROR);    GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);    /* initialize result */    bu_vls_trunc(gedp->ged_result_str, 0);    if (argc != 4)	goto bad;    if (sscanf(argv[1], "%lf", &model_pt[X]) != 1 ||	sscanf(argv[2], "%lf", &model_pt[Y]) != 1 ||	sscanf(argv[3], "%lf", &model_pt[Z]) != 1)	goto bad;    VSCALE(model_pt, model_pt, gedp->ged_wdbp->dbip->dbi_local2base);    MAT4X3PNT(view_pt, gedp->ged_gvp->gv_model2view, model_pt);    f = gedp->ged_gvp->gv_scale * gedp->ged_wdbp->dbip->dbi_base2local;    VSCALE(view_pt, view_pt, f);    bn_encode_vect(gedp->ged_result_str, view_pt);    return GED_OK;bad:    bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);    return GED_ERROR;}

intged_debuglib(struct ged *gedp, int argc, const char *argv[]){    static const char *usage = "[hex_code]";    GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);    GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);    /* initialize result */    bu_vls_trunc(gedp->ged_result_str, 0);    if (argc > 2) {	bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);	return GED_ERROR;    }    /* get librt's debug bit vector */    if (argc == 1) {	bu_vls_printb(gedp->ged_result_str, "Possible flags", 0xffffffffL, DEBUG_FORMAT);	bu_vls_printf(gedp->ged_result_str, "/n");    } else {	/* set librt's debug bit vector */	if (sscanf(argv[1], "%x", (unsigned int *)&rt_g.debug) != 1) {	    bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);	    return GED_ERROR;	}	if (RT_G_DEBUG) bu_debug |= BU_DEBUG_COREDUMP;    }    bu_vls_printb(gedp->ged_result_str, "librt RT_G_DEBUG", RT_G_DEBUG, DEBUG_FORMAT);    bu_vls_printf(gedp->ged_result_str, "/n");    return GED_OK;}

/** * Given a point in model space coordinates (in mm) convert it to view * (screen) coordinates which must be scaled to correspond to actual * screen coordinates. If no input coordinates are supplied, the * model2view matrix is displayed. */intged_model2view(struct ged *gedp, int argc, const char *argv[]){    point_t view_pt;    double model_pt[3]; /* intentionally double for scan */    static const char *usage = "[x y z]";    GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);    GED_CHECK_VIEW(gedp, GED_ERROR);    GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);    /* initialize result */    bu_vls_trunc(gedp->ged_result_str, 0);    /* get the model2view matrix */    if (argc == 1) {	bn_encode_mat(gedp->ged_result_str, gedp->ged_gvp->gv_model2view);	return GED_OK;    }    if (argc != 4	|| sscanf(argv[1], "%lf", &model_pt[X]) != 1	|| sscanf(argv[2], "%lf", &model_pt[Y]) != 1	|| sscanf(argv[3], "%lf", &model_pt[Z]) != 1)    {	bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);	return GED_ERROR;    }    MAT4X3PNT(view_pt, gedp->ged_gvp->gv_model2view, model_pt);    bn_encode_vect(gedp->ged_result_str, view_pt);    return GED_OK;}

/* * Returns the views eyemodel * * Usage: * get_eyemodel * */intged_get_eyemodel(struct ged *gedp, int argc, const char *argv[]){    quat_t quat;    vect_t eye_model;    GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);    GED_CHECK_DRAWABLE(gedp, GED_ERROR);    GED_CHECK_VIEW(gedp, GED_ERROR);    GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);    /* initialize result */    bu_vls_trunc(gedp->ged_result_str, 0);    if (argc != 1) {	bu_vls_printf(gedp->ged_result_str, "Usage: %s", argv[0]);	return GED_ERROR;    }    _ged_rt_set_eye_model(gedp, eye_model);    quat_mat2quat(quat, gedp->ged_gvp->gv_rotation);    bu_vls_printf(gedp->ged_result_str, "viewsize %.15e;/n", gedp->ged_gvp->gv_size);    bu_vls_printf(gedp->ged_result_str, "orientation %.15e %.15e %.15e %.15e;/n",		  V4ARGS(quat));    bu_vls_printf(gedp->ged_result_str, "eye_pt %.15e %.15e %.15e;/n",		  eye_model[X], eye_model[Y], eye_model[Z]);    return GED_OK;}

intged_form(struct ged *gedp, int argc, const char *argv[]){    const struct rt_functab *ftp;    static const char *usage = "type";    GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);    GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);    /* initialize result */    bu_vls_trunc(gedp->ged_result_str, 0);    /* must be wanting help */    if (argc == 1) {	bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);	return GED_HELP;    }    if (argc != 2) {	bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);	return GED_ERROR;    }    if ((ftp = rt_get_functab_by_label(argv[1])) == NULL) {	bu_vls_printf(gedp->ged_result_str, "There is no geometric object type /"%s/".", argv[1]);	return GED_ERROR;    }    if (!ftp->ft_form) {	return GED_ERROR;    }    return ftp->ft_form(gedp->ged_result_str, ftp);}

intged_echo(struct ged *gedp, int argc, const char *argv[]){    int i;    static const char *usage = "args";    GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);    GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);    /* initialize result */    bu_vls_trunc(gedp->ged_result_str, 0);    /* must be wanting help */    if (argc == 1) {	bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);	return GED_HELP;    }    for (i = 1; i < argc; i++) {	bu_vls_printf(gedp->ged_result_str, "%s%s", i == 1 ? "" : " ", argv[i]);    }    bu_vls_printf(gedp->ged_result_str, "/n");    return GED_OK;}

intged_find_botpt_nearest_pt(struct ged *gedp, int argc, const char *argv[]){    static const char *usage = "bot view_xyz";    struct rt_db_internal intern;    struct rt_bot_internal *botip;    mat_t mat;    int nearest_pt;    vect_t view;    /* must be double for scanf */    double scan[ELEMENTS_PER_VECT];    GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);    GED_CHECK_VIEW(gedp, GED_ERROR);    GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);    /* initialize result */    bu_vls_trunc(gedp->ged_result_str, 0);    /* must be wanting help */    if (argc == 1) {	bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);	return GED_HELP;    }    if (argc != 3) {	bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);	return GED_ERROR;    }    if (bu_sscanf(argv[2], "%lf %lf %lf", &scan[X], &scan[Y], &scan[Z]) != 3) {	bu_vls_printf(gedp->ged_result_str, "%s: bad view location - %s", argv[0], argv[2]);	return GED_ERROR;    }    if (wdb_import_from_path2(gedp->ged_result_str, &intern, argv[1], gedp->ged_wdbp, mat) == GED_ERROR) {	bu_vls_printf(gedp->ged_result_str, "%s: failed to find %s", argv[0], argv[1]);	return GED_ERROR;    }    if (intern.idb_major_type != DB5_MAJORTYPE_BRLCAD ||	intern.idb_minor_type != DB5_MINORTYPE_BRLCAD_BOT) {	bu_vls_printf(gedp->ged_result_str, "Object is not a BOT");	rt_db_free_internal(&intern);	return GED_ERROR;    }    botip = (struct rt_bot_internal *)intern.idb_ptr;    VMOVE(view, scan); /* convert double to fastf_t */    nearest_pt = rt_bot_find_v_nearest_pt2(botip, view, gedp->ged_gvp->gv_model2view);    bu_vls_printf(gedp->ged_result_str, "%d", nearest_pt);    rt_db_free_internal(&intern);    return GED_OK;}

intged_v2m_point(struct ged *gedp, int argc, const char *argv[]){    point_t view;    point_t model;    static const char *usage = "x y z";    GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);    GED_CHECK_VIEW(gedp, GED_ERROR);    GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);    /* initialize result */    bu_vls_trunc(gedp->ged_result_str, 0);    /* must be wanting help */    if (argc == 1) {	bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);	return GED_HELP;    }    if (argc != 2 && argc != 4) {	bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);	return GED_ERROR;    }    if (argc == 2) {	if (bn_decode_vect(view, argv[1]) != 3) {	    bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);	    return GED_ERROR;	}    } else {	double scan[3];	if (sscanf(argv[1], "%lf", &scan[X]) != 1) {	    bu_vls_printf(gedp->ged_result_str, "ged_m2v_point: bad X value - %s/n", argv[1]);	    return GED_ERROR;	}	if (sscanf(argv[2], "%lf", &scan[Y]) != 1) {	    bu_vls_printf(gedp->ged_result_str, "ged_m2v_point: bad Y value - %s/n", argv[2]);	    return GED_ERROR;	}	if (sscanf(argv[3], "%lf", &scan[Z]) != 1) {	    bu_vls_printf(gedp->ged_result_str, "ged_m2v_point: bad Z value - %s/n", argv[3]);	    return GED_ERROR;	}	/* convert from double to fastf_t */	VMOVE(view, scan);    }    /* Convert the incoming view point to a model point */    MAT4X3PNT(model, gedp->ged_gvp->gv_view2model, view);    bn_encode_vect(gedp->ged_result_str, model);    return GED_OK;}

intged_setview(struct ged *gedp, int argc, const char *argv[]){    vect_t rvec;    static const char *usage = "x y z";    GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);    GED_CHECK_VIEW(gedp, GED_ERROR);    GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);    /* initialize result */    bu_vls_trunc(gedp->ged_result_str, 0);    /* must be wanting help */    if (argc == 1) {	bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);	return GED_HELP;    }    if (argc != 2 && argc != 4) {	bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);	return GED_ERROR;    }    /* set view center */    if (argc == 2) {	if (bn_decode_vect(rvec, argv[1]) != 3) {	    bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);	    return GED_ERROR;	}    } else {	double scan[3];	if (sscanf(argv[1], "%lf", &scan[X]) != 1) {	    bu_vls_printf(gedp->ged_result_str, "ged_setview: bad X value - %s/n", argv[1]);	    return GED_ERROR;	}	if (sscanf(argv[2], "%lf", &scan[Y]) != 1) {	    bu_vls_printf(gedp->ged_result_str, "ged_setview: bad Y value - %s/n", argv[2]);	    return GED_ERROR;	}	if (sscanf(argv[3], "%lf", &scan[Z]) != 1) {	    bu_vls_printf(gedp->ged_result_str, "ged_setview: bad Z value - %s/n", argv[3]);	    return GED_ERROR;	}	/* convert from double to fastf_t */	VMOVE(rvec, scan);    }    bn_mat_angles(gedp->ged_gvp->gv_rotation, rvec[X], rvec[Y], rvec[Z]);    ged_view_update(gedp->ged_gvp);    return GED_OK;}

/* * Illuminate/highlight database object * * Usage: * illum [-n] obj * */intged_illum(struct ged *gedp, int argc, const char *argv[]){    struct display_list *gdlp;    struct display_list *next_gdlp;    int found = 0;    int illum = 1;    static const char *usage = "[-n] obj";    GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);    GED_CHECK_DRAWABLE(gedp, GED_ERROR);    GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);    /* initialize result */    bu_vls_trunc(gedp->ged_result_str, 0);    /* must be wanting help */    if (argc == 1) {	bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);	return GED_HELP;    }    if (argc == 3) {	if (argv[1][0] == '-' && argv[1][1] == 'n')	    illum = 0;	else	    goto bad;	--argc;	++argv;    }    if (argc != 2)	goto bad;    gdlp = BU_LIST_NEXT(display_list, gedp->ged_gdp->gd_headDisplay);    while (BU_LIST_NOT_HEAD(gdlp, gedp->ged_gdp->gd_headDisplay)) {	next_gdlp = BU_LIST_PNEXT(display_list, gdlp);	found += dl_set_illum(gdlp, argv[1], illum);	gdlp = next_gdlp;    }    if (!found) {	bu_vls_printf(gedp->ged_result_str, "illum: %s not found", argv[1]);	return GED_ERROR;    }    return GED_OK;bad:    bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);    return GED_ERROR;}

intged_scale_args(struct ged *gedp, int argc, const char *argv[], fastf_t *sf1, fastf_t *sf2, fastf_t *sf3){    static const char *usage = "sf (or) sfx sfy sfz";    int ret = GED_OK, args_read;    double scan;    GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);    GED_CHECK_VIEW(gedp, GED_ERROR);    GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);    /* initialize result */    bu_vls_trunc(gedp->ged_result_str, 0);    /* must be wanting help */    if (argc == 1) {	bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);	return GED_HELP;    }    if (argc != 2 && argc != 4) {	bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);	return GED_ERROR;    }    if (argc == 2) {	if (!sf1 || sscanf(argv[1], "%lf", &scan) != 1) {	    bu_vls_printf(gedp->ged_result_str, "/nbad scale factor '%s'", argv[1]);	    return GED_ERROR;	}	*sf1 = scan;    } else {	args_read = sscanf(argv[1], "%lf", &scan);	if (!sf1 || args_read != 1) {	    bu_vls_printf(gedp->ged_result_str, "/nbad x scale factor '%s'", argv[1]);	    ret = GED_ERROR;	}	*sf1 = scan;	args_read = sscanf(argv[2], "%lf", &scan);	if (!sf2 || args_read != 1) {	    bu_vls_printf(gedp->ged_result_str, "/nbad y scale factor '%s'", argv[2]);	    ret = GED_ERROR;	}	*sf2 = scan;	args_read = sscanf(argv[3], "%lf", &scan);	if (!sf3 || args_read != 1) {	    bu_vls_printf(gedp->ged_result_str, "/nbad z scale factor '%s'", argv[3]);	    ret = GED_ERROR;	}	*sf3 = scan;    }    return ret;}

intged_edmater(struct rt_wdb *wdbp, int argc, const char *argv[]){    FILE *fp;    int i;    int status;    const char **av;    static const char *usage = "comb(s)";    char tmpfil[MAXPATHLEN];    GED_CHECK_DATABASE_OPEN(wdbp, GED_ERROR);    GED_CHECK_READ_ONLY(wdbp, GED_ERROR);    /* must be wanting help */    if (argc == 1) {	wdbp->wdb_result_flags |= GED_RESULT_FLAGS_HELP_BIT;	bu_vls_printf(&wdbp->wdb_result_str, "Usage: %s %s", argv[0], usage);	return GED_OK;    }    fp = bu_temp_file(tmpfil, MAXPATHLEN);    if (!fp)	return TCL_ERROR;    av = (const char **)bu_malloc(sizeof(char *)*(argc + 2), "f_edmater: av");    av[0] = "wmater";    av[1] = tmpfil;    for(i = 2; i < argc + 1; ++i)	av[i] = argv[i-1];    av[i] = NULL;    if (ged_wmater(wdbp, argc + 1, av) == TCL_ERROR) {	(void)unlink(tmpfil);	bu_free((genptr_t)av, "f_edmater: av");	return TCL_ERROR;    }    (void)fclose(fp);    if (ged_editit(tmpfil)) {	av[0] = "rmater";	av[2] = NULL;	status = ged_rmater(wdbp, 2, av);    } else {	status = TCL_ERROR;    }    (void)unlink(tmpfil);    bu_free((genptr_t)av, "ged_edmater: av");    return status;}

/* * List the objects currently prepped for drawing * * Usage: * who [r(eal)|p(hony)|b(oth)] * */intged_who(struct ged *gedp, int argc, const char *argv[]){    struct ged_display_list *gdlp;    int skip_real, skip_phony;    static const char *usage = "[r(eal)|p(hony)|b(oth)]";    GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);    GED_CHECK_DRAWABLE(gedp, GED_ERROR);    GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);    /* initialize result */    bu_vls_trunc(gedp->ged_result_str, 0);    if (2 < argc) {	bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);	return GED_ERROR;    }    skip_real = 0;    skip_phony = 1;    if (argc == 2) {	switch (argv[1][0]) {	    case 'b':		skip_real = 0;		skip_phony = 0;		break;	    case 'p':		skip_real = 1;		skip_phony = 0;		break;	    case 'r':		skip_real = 0;		skip_phony = 1;		break;	    default:		bu_vls_printf(gedp->ged_result_str, "ged_who: argument not understood/n");		return GED_ERROR;	}    }    for (BU_LIST_FOR(gdlp, ged_display_list, gedp->ged_gdp->gd_headDisplay)) {	if (gdlp->gdl_dp->d_addr == RT_DIR_PHONY_ADDR) {	    if (skip_phony) continue;	} else {	    if (skip_real) continue;	}	bu_vls_printf(gedp->ged_result_str, "%s ", bu_vls_addr(&gdlp->gdl_path));    }    return GED_OK;}

intged_wcodes(struct ged *gedp, int argc, const char *argv[]){    int i;    int status;    FILE *fp;    struct directory *dp;    static const char *usage = "filename object(s)";    GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);    GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);    /* initialize result */    bu_vls_trunc(gedp->ged_result_str, 0);    /* must be wanting help */    if (argc == 1) {	bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);	return GED_HELP;    }    if (argc == 2) {	bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);	return GED_ERROR;    }    if ((fp = fopen(argv[1], "w")) == NULL) {	bu_vls_printf(gedp->ged_result_str, "%s: Failed to open file - %s",		      argv[0], argv[1]);	return GED_ERROR;    }    path = (struct directory **)bu_calloc(PATH_STEP, sizeof(struct directory *), "alloc initial path");    path_capacity = PATH_STEP;    for (i = 2; i < argc; ++i) {	if ((dp = db_lookup(gedp->ged_wdbp->dbip, argv[i], LOOKUP_NOISY)) != RT_DIR_NULL) {	    status = wcodes_printcodes(gedp, fp, dp, 0);	    if (status == GED_ERROR) {		(void)fclose(fp);		return GED_ERROR;	    }	}    }    (void)fclose(fp);    bu_free(path, "dealloc path");    path = NULL;    path_capacity = 0;    return GED_OK;}

intged_get_bot_edges(struct ged *gedp, int argc, const char *argv[]){    static const char *usage = "bot";    struct rt_db_internal intern;    struct rt_bot_internal *botip;    mat_t mat;    size_t edge_count;    size_t *edge_list;    GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);    GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);    /* initialize result */    bu_vls_trunc(gedp->ged_result_str, 0);    /* must be wanting help */    if (argc == 1) {	bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);	return GED_HELP;    }    if (argc != 2) {	bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);	return GED_ERROR;    }    if (wdb_import_from_path2(gedp->ged_result_str, &intern, argv[1], gedp->ged_wdbp, mat) == GED_ERROR) {	bu_vls_printf(gedp->ged_result_str, "%s: failed to find %s", argv[0], argv[1]);	return GED_ERROR;    }    if (intern.idb_major_type != DB5_MAJORTYPE_BRLCAD ||	intern.idb_minor_type != DB5_MINORTYPE_BRLCAD_BOT) {	bu_vls_printf(gedp->ged_result_str, "Object is not a BOT");	rt_db_free_internal(&intern);	return GED_ERROR;    }    botip = (struct rt_bot_internal *)intern.idb_ptr;    if ((edge_count = rt_bot_get_edge_list(botip, &edge_list)) > 0) {	size_t i;	for (i = 0; i < edge_count; i++)	    bu_vls_printf(gedp->ged_result_str, "{%zu %zu} ", edge_list[i*2], edge_list[i*2+1]);	bu_free(edge_list, "bot edge list");    }    rt_db_free_internal(&intern);    return GED_OK;}

intged_killall(struct ged *gedp, int argc, const char *argv[]){    int nflag;    int ret;    static const char *usage = "[-n] object(s)";    GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);    GED_CHECK_DRAWABLE(gedp, GED_ERROR);    GED_CHECK_READ_ONLY(gedp, GED_ERROR);    GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);    /* initialize result */    bu_vls_trunc(gedp->ged_result_str, 0);    /* must be wanting help */    if (argc == 1) {	bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);	return GED_HELP;    }    /* Process the -n option */    if (argc > 1 && argv[1][0] == '-' && argv[1][1] == 'n' && argv[1][2] == '/0') {	int i;	nflag = 1;	/* Objects that would be killed are in the first sublist */	bu_vls_printf(gedp->ged_result_str, "{");	for (i = 2; i < argc; i++)	    bu_vls_printf(gedp->ged_result_str, "%s ", argv[i]);	bu_vls_printf(gedp->ged_result_str, "} {");    } else	nflag = 0;    gedp->ged_internal_call = 1;    if ((ret = ged_killrefs(gedp, argc, argv)) != GED_OK) {	gedp->ged_internal_call = 0;	bu_vls_printf(gedp->ged_result_str, "KILL skipped because of earlier errors./n");	return ret;    }    gedp->ged_internal_call = 0;    if (nflag) {	/* Close the sublist of objects that reference the would-be killed objects. */	bu_vls_printf(gedp->ged_result_str, "}");	return GED_OK;    }    /* ALL references removed...now KILL the object[s] */    /* reuse argv[] */    argv[0] = "kill";    return ged_kill(gedp, argc, argv);}

intged_bot_flip(struct ged *gedp, int argc, const char *argv[]){    int i;    struct directory *dp;    struct rt_db_internal intern;    struct rt_bot_internal *bot;    static const char *usage = "bot [bot2 bot3 ...]";    GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);    GED_CHECK_READ_ONLY(gedp, GED_ERROR);    GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);    /* initialize result */    bu_vls_trunc(gedp->ged_result_str, 0);    /* must be wanting help */    if (argc == 1) {	bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);	return GED_HELP;    }    for (i = 1; i < argc; ++i) {	/* Skip past any path elements */	char *obj = (char *)bu_calloc(strlen(argv[i]), sizeof(char), "ged_bot_flip obj");	bu_basename(obj, argv[i]);	if (BU_STR_EQUAL(obj, ".")) {	    /* malformed path, lookup using exactly what was provided */	    bu_free(obj, "free bu_basename");	    obj = bu_strdup(argv[i]);	}	if ((dp = db_lookup(gedp->ged_wdbp->dbip, obj, LOOKUP_QUIET)) == RT_DIR_NULL) {	    bu_vls_printf(gedp->ged_result_str, "%s: db_lookup(%s) error/n", argv[0], obj);	} else {	    GED_DB_GET_INTERNAL(gedp, &intern, dp, bn_mat_identity, &rt_uniresource, GED_ERROR);	    if (intern.idb_major_type != DB5_MAJORTYPE_BRLCAD || intern.idb_minor_type != DB5_MINORTYPE_BRLCAD_BOT) {		bu_vls_printf(gedp->ged_result_str, "%s: %s is not a BOT solid!/n", argv[0], obj);	    } else {		bot = (struct rt_bot_internal *)intern.idb_ptr;		rt_bot_flip(bot);		GED_DB_PUT_INTERNAL(gedp, dp, &intern, gedp->ged_wdbp->wdb_resp, GED_ERROR);	    }	}	bu_free(obj, "free obj");    }    return GED_OK;}

intged_comb_color(struct rt_wdb *wdbp, int argc, const char *argv[]){    int				i;    int				val;    register struct directory	*dp;    struct rt_db_internal	intern;    struct rt_comb_internal	*comb;    static const char *usage = "comb_color combination R G B";    GED_CHECK_DATABASE_OPEN(wdbp, GED_ERROR);    GED_CHECK_READ_ONLY(wdbp, GED_ERROR);    /* initialize result */    bu_vls_trunc(&wdbp->wdb_result_str, 0);    wdbp->wdb_result = GED_RESULT_NULL;    wdbp->wdb_result_flags = 0;    /* must be wanting help */    if (argc == 1) {	wdbp->wdb_result_flags |= GED_RESULT_FLAGS_HELP_BIT;	bu_vls_printf(&wdbp->wdb_result_str, "Usage: %s %s", argv[0], usage);	return GED_OK;    }    if (argc != 5) {	bu_vls_printf(&wdbp->wdb_result_str, "Usage: %s %s", argv[0], usage);	return GED_ERROR;    }    GED_DB_LOOKUP(wdbp, dp, argv[1], LOOKUP_NOISY, GED_ERROR);    GED_CHECK_COMB(wdbp, dp, GED_ERROR);    GED_DB_GET_INTERNAL(wdbp, &intern, dp, (fastf_t *)NULL, &rt_uniresource, GED_ERROR);    comb = (struct rt_comb_internal *)intern.idb_ptr;    RT_CK_COMB(comb);    for (i = 0; i < 3; ++i) {	if (sscanf(argv[i+2], "%d", &val) != 1 || val < 0 || 255 < val) {	    bu_vls_printf(&wdbp->wdb_result_str,"RGB value out of range: %s", argv[i + 2]);	    rt_db_free_internal(&intern, &rt_uniresource);	    return GED_ERROR;	}	else	    comb->rgb[i] = val;    }    comb->rgb_valid = 1;    GED_DB_PUT_INTERNAL(wdbp, dp, &intern, &rt_uniresource, GED_ERROR);    return GED_OK;}

/** * Checks for the existence of a specified object. */intged_exists(struct ged *gedp, int argc, const char *argv_orig[]){    /* struct directory *dp;*/    static const char *usage = "object";    struct exists_data ed;    struct bu_vls message = BU_VLS_INIT_ZERO;    int result;    char **argv = bu_dup_argv(argc, argv_orig);    GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);    GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);    /* initialize result */    bu_vls_trunc(gedp->ged_result_str, 0);    /* must be wanting help */    if (argc == 1) {        bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv_orig[0], usage);        return GED_HELP;    }    /*      if (argc != 2) {      bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv_orig[0], usage);      return GED_ERROR;      }    */    ed.t_wp = &argv[1];    ed.gedp = gedp;    ed.t_wp_op = NULL;    ed.message = &message;    result = oexpr(t_lex(*(ed.t_wp), &ed), &ed);    if (result)        bu_vls_printf(gedp->ged_result_str, "1");    else        bu_vls_printf(gedp->ged_result_str, "0");    if (bu_vls_strlen(ed.message) > 0) {        bu_vls_printf(gedp->ged_result_str, "%s", bu_vls_addr(ed.message));        bu_vls_free(&message);        return GED_ERROR;    }    bu_vls_free(&message);    if (*(ed.t_wp) != NULL && *++(ed.t_wp) != NULL) {        return GED_ERROR;    } else {        return GED_OK;    }}

intged_adjust(struct ged *gedp, int argc, const char *argv[]){    int status;    struct directory *dp;    char *name;    struct rt_db_internal intern;    static const char *usage = "object attr value ?attr value?";    GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);    GED_CHECK_READ_ONLY(gedp, GED_ERROR);    GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);    /* initialize result */    bu_vls_trunc(gedp->ged_result_str, 0);    /* must be wanting help */    if (argc == 1) {	bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);	return GED_HELP;    }    if (argc < 4) {	bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);	return GED_ERROR;    }    name = (char *)argv[1];    GED_DB_LOOKUP(gedp, dp, name, LOOKUP_QUIET, GED_ERROR);    GED_DB_GET_INTERNAL(gedp, &intern, dp, (matp_t)NULL, &rt_uniresource, GED_ERROR);    RT_CK_DB_INTERNAL(&intern);    /* Find out what type of object we are dealing with and tweak it. */    RT_CK_FUNCTAB(intern.idb_meth);    if (!intern.idb_meth->ft_adjust) {	bu_vls_printf(gedp->ged_result_str, "wdb_export(%s) adjust failure", name);	return GED_ERROR;    }    status = intern.idb_meth->ft_adjust(gedp->ged_result_str, &intern, argc-2, argv+2);    if (status == GED_OK && wdb_put_internal(gedp->ged_wdbp, name, &intern, 1.0) < 0) {	bu_vls_printf(gedp->ged_result_str, "wdb_export(%s) failure", name);	rt_db_free_internal(&intern);	return GED_ERROR;    }    return GED_OK;}

intged_orient(struct ged *gedp, int argc, const char *argv[]){    quat_t quat;    static const char *usage = "quat";    GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);    GED_CHECK_VIEW(gedp, GED_ERROR);    GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);    /* initialize result */    bu_vls_trunc(gedp->ged_result_str, 0);    /* must be wanting help */    if (argc == 1) {	bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);	return GED_HELP;    }    if (argc != 2 && argc != 5) {	bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);	return GED_ERROR;    }    /* set view orientation */    if (argc == 2) {	if (bn_decode_quat(quat, argv[1]) != 4) {	    bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);	    return GED_ERROR;	}    } else {	int i;	for (i = 1; i < 5; ++i) {	    double scan;	    if (sscanf(argv[i], "%lf", &scan) != 1) {		bu_vls_printf(gedp->ged_result_str, "ged_orient: bad value - %s/n", argv[i-1]);		return GED_ERROR;	    }	    /* convert from double to fastf_t */	    quat[i-1] = scan;	}    }    quat_quat2mat(gedp->ged_gvp->gv_rotation, quat);    ged_view_update(gedp->ged_gvp);    return GED_OK;}

intged_bot_condense(struct ged *gedp, int argc, const char *argv[]){    struct directory *old_dp, *new_dp;    struct rt_db_internal intern;    struct rt_bot_internal *bot;    int count2=0;    static const char *usage = "new_bot old_bot";    GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);    GED_CHECK_READ_ONLY(gedp, GED_ERROR);    GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);    /* initialize result */    bu_vls_trunc(gedp->ged_result_str, 0);    /* must be wanting help */    if (argc == 1) {	bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);	return GED_HELP;    }    if (argc != 3) {	bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);	return GED_ERROR;    }    GED_DB_LOOKUP(gedp, old_dp, argv[2], LOOKUP_NOISY, GED_ERROR & GED_QUIET);    GED_DB_GET_INTERNAL(gedp, &intern,  old_dp, bn_mat_identity, &rt_uniresource, GED_ERROR);    if (intern.idb_major_type != DB5_MAJORTYPE_BRLCAD || intern.idb_minor_type != DB5_MINORTYPE_BRLCAD_BOT) {	bu_vls_printf(gedp->ged_result_str, "%s: %s is not a BOT solid!/n", argv[0], argv[2]);	return GED_ERROR;    }    bot = (struct rt_bot_internal *)intern.idb_ptr;    RT_BOT_CK_MAGIC(bot);    count2 = rt_bot_condense(bot);    bu_vls_printf(gedp->ged_result_str, "%s: %d dead vertices eliminated/n", argv[0], count2);    GED_DB_DIRADD(gedp, new_dp, argv[1], RT_DIR_PHONY_ADDR, 0, RT_DIR_SOLID, (void *)&intern.idb_type, GED_ERROR);    GED_DB_PUT_INTERNAL(gedp, new_dp, &intern, &rt_uniresource, GED_ERROR);    return GED_OK;}

intged_copy(struct ged *gedp, int argc, const char *argv[]){    struct directory *from_dp;    struct bu_external external;    static const char *usage = "from to";    GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);    GED_CHECK_READ_ONLY(gedp, GED_ERROR);    GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);    /* initialize result */    bu_vls_trunc(gedp->ged_result_str, 0);    /* must be wanting help */    if (argc == 1) {	bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);	return GED_HELP;    }    if (argc != 3) {	bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);	return GED_ERROR;    }    GED_DB_LOOKUP(gedp, from_dp, argv[1], LOOKUP_NOISY, GED_ERROR & GED_QUIET);    GED_CHECK_EXISTS(gedp, argv[2], LOOKUP_QUIET, GED_ERROR);    if (db_get_external(&external, from_dp, gedp->ged_wdbp->dbip)) {	bu_vls_printf(gedp->ged_result_str, "Database read error, aborting/n");	return GED_ERROR;    }    if (wdb_export_external(gedp->ged_wdbp, &external, argv[2],			    from_dp->d_flags,  from_dp->d_minor_type) < 0) {	bu_free_external(&external);	bu_vls_printf(gedp->ged_result_str,		      "Failed to write new object (%s) to database - aborting!!/n",		      argv[2]);	return GED_ERROR;    }    bu_free_external(&external);    return GED_OK;}

intged_edcolor(struct ged *gedp, int argc, const char *argv[]){    GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);    GED_CHECK_READ_ONLY(gedp, GED_ERROR);    GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);    /* initialize result */    bu_vls_trunc(gedp->ged_result_str, 0);    if (argc != 3) {	bu_vls_printf(gedp->ged_result_str, "Usage: %s", argv[0]);	return GED_ERROR;    }    return edcolor(gedp, argc, argv);}

intged_savekey(struct ged *gedp, int argc, const char *argv[]){    FILE *fp;    fastf_t timearg;    vect_t eye_model;    vect_t temp;    static const char *usage = "file [time]";    GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);    GED_CHECK_VIEW(gedp, GED_ERROR);    GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);    /* initialize result */    bu_vls_trunc(gedp->ged_result_str, 0);    /* must be wanting help */    if (argc == 1) {	bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);	return GED_HELP;    }    if (argc < 2 || 3 < argc) {	bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);	return GED_ERROR;    }    if ((fp = fopen(argv[1], "a")) == NULL) {	perror(argv[1]);	return TCL_ERROR;    }    if (argc > 2) {	timearg = atof(argv[2]);	fprintf(fp, "%f/n", timearg);    }    /*     * Eye is in conventional place.     */    VSET(temp, 0.0, 0.0, 1.0);    MAT4X3PNT(eye_model, gedp->ged_gvp->gv_view2model, temp);    savekey_rt_oldwrite(gedp, fp, eye_model);    (void)fclose(fp);    return GED_OK;}

intged_debugmem(struct ged *gedp, int argc, const char *argv[]){    GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);    GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);    /* initialize result */    bu_vls_trunc(gedp->ged_result_str, 0);    if (argc != 1) {	bu_vls_printf(gedp->ged_result_str, "Usage: %s", argv[0]);	return GED_ERROR;    }    bu_prmem("Invoked via libged");    return GED_OK;}

intged_size(struct ged *gedp, int argc, const char *argv[]){    /* intentionally double for scan */    double size;    static const char *usage = "[s]";    GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);    GED_CHECK_VIEW(gedp, GED_ERROR);    GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);    /* initialize result */    bu_vls_trunc(gedp->ged_result_str, 0);    /* get view size */    if (argc == 1) {	bu_vls_printf(gedp->ged_result_str, "%g",		      gedp->ged_gvp->gv_size * gedp->ged_wdbp->dbip->dbi_base2local);	return GED_OK;    }    /* set view size */    if (argc == 2) {	if (sscanf(argv[1], "%lf", &size) != 1	    || size <= 0	    || ZERO(size))	{	    bu_vls_printf(gedp->ged_result_str, "bad size - %s", argv[1]);	    return GED_ERROR;	}	gedp->ged_gvp->gv_size = gedp->ged_wdbp->dbip->dbi_local2base * size;	if (gedp->ged_gvp->gv_size < RT_MINVIEWSIZE)	    gedp->ged_gvp->gv_size = RT_MINVIEWSIZE;	gedp->ged_gvp->gv_isize = 1.0 / gedp->ged_gvp->gv_size;	gedp->ged_gvp->gv_scale = 0.5 * gedp->ged_gvp->gv_size;	ged_view_update(gedp->ged_gvp);	return GED_OK;    }    bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);    return GED_ERROR;}

intged_perspective(struct ged *gedp, int argc, const char *argv[]){    /* intentionally double for scan */    double perspective;    static const char *usage = "[angle]";    GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR);    GED_CHECK_VIEW(gedp, GED_ERROR);    GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR);    /* initialize result */    bu_vls_trunc(gedp->ged_result_str, 0);    /* get the perspective angle */    if (argc == 1) {	bu_vls_printf(gedp->ged_result_str, "%g", gedp->ged_gvp->gv_perspective);	return GED_OK;    }    /* set perspective angle */    if (argc == 2) {	if (sscanf(argv[1], "%lf", &perspective) != 1) {	    bu_vls_printf(gedp->ged_result_str, "bad perspective angle - %s", argv[1]);	    return GED_ERROR;	}	gedp->ged_gvp->gv_perspective = perspective;	if (SMALL_FASTF < gedp->ged_gvp->gv_perspective) {	    ged_persp_mat(gedp->ged_gvp->gv_pmat, gedp->ged_gvp->gv_perspective,			  (fastf_t)1.0f, (fastf_t)0.01f, (fastf_t)1.0e10f, (fastf_t)1.0f);	} else {	    MAT_COPY(gedp->ged_gvp->gv_pmat, bn_mat_identity);	}	ged_view_update(gedp->ged_gvp);	return GED_OK;    }    bu_vls_printf(gedp->ged_result_str, "Usage: %s %s", argv[0], usage);    return GED_ERROR;}