int compare_external(struct directory *dp1, struct directory *dp2) { int killit = 0; struct bu_external ext1, ext2; if (db_get_external(&ext1, dp1, dbip1)) { fprintf(stderr, "ERROR: db_get_external failed on solid %s in %s\n", dp1->d_namep, dbip1->dbi_filename); bu_exit(1, NULL); } if (db_get_external(&ext2, dp2, dbip2)) { fprintf(stderr, "ERROR: db_get_external failed on solid %s in %s\n", dp2->d_namep, dbip2->dbi_filename); bu_exit(1, NULL); } if (ext1.ext_nbytes != ext2.ext_nbytes) { printf("Byte counts are different on %s (%ld != %ld)\n", dp1->d_namep, (long int)ext1.ext_nbytes, (long int)ext2.ext_nbytes); killit = 1; } if (memcmp((void *)ext1.ext_buf, (void *)ext2.ext_buf, ext1.ext_nbytes)) { printf("Byte value(s) are different on %s (has no Tcl list representation)\n", dp1->d_namep); killit = 1; } if (killit) { if (mode == HUMAN) { printf("kill %s and import it from %s\n", dp1->d_namep, dbip1->dbi_filename); } else { printf("kill %s\n# IMPORT %s from %s\n", dp1->d_namep, dp2->d_namep, dbip2->dbi_filename); } return 1; } return 0; }
int rt_db_get_internal( struct rt_db_internal *ip, const struct directory *dp, const struct db_i *dbip, const mat_t mat, struct resource *resp) { struct bu_external ext; int id; int ret; RT_DB_INTERNAL_INIT(ip); if (dbip->dbi_version > 4) return rt_db_get_internal5(ip, dp, dbip, mat, resp); BU_EXTERNAL_INIT(&ext); if (db_get_external(&ext, dp, dbip) < 0) return -2; /* FAIL */ if (dp->d_flags & RT_DIR_COMB) { id = ID_COMBINATION; } else { /* As a convenience to older ft_import4 routines */ if (mat == NULL) mat = bn_mat_identity; id = rt_id_solid(&ext); } /* ip is already initialized and should not be re-initialized */ ret = -1; if (OBJ[id].ft_import4) { ret = OBJ[id].ft_import4(ip, &ext, mat, dbip, resp); } if (ret < 0) { bu_log("rt_db_get_internal(%s): import failure\n", dp->d_namep); rt_db_free_internal(ip); bu_free_external(&ext); return -1; /* FAIL */ } bu_free_external(&ext); RT_CK_DB_INTERNAL(ip); ip->idb_meth = &OBJ[id]; /* prior to version 5, there are no attributes ... */ bu_avs_init_empty(&ip->idb_avs); /* ... but this isn't the whole story: */ if (id == ID_COMBINATION) { const struct rt_comb_internal *comb = (const struct rt_comb_internal *)ip->idb_ptr; RT_CK_COMB(comb); db5_sync_comb_to_attr(&ip->idb_avs, comb); } return id; /* OK */ }
int ged_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; }
int db_dump(struct rt_wdb *wdbp, struct db_i *dbip) /* output */ /* input */ { register int i; register struct directory *dp; struct bu_external ext; RT_CK_DBI(dbip); RT_CK_WDB(wdbp); /* just in case since we don't actually handle it below */ if (db_version(dbip) != db_version(wdbp->dbip)) { bu_log("Internal Error: dumping a v%d database into a v%d database is untested\n", db_version(dbip), db_version(wdbp->dbip)); return -1; } /* Output all directory entries */ for (i = 0; i < RT_DBNHASH; i++) { for (dp = dbip->dbi_Head[i]; dp != RT_DIR_NULL; dp = dp->d_forw) { RT_CK_DIR(dp); /* XXX Need to go to internal form, if database versions don't match */ if (db_get_external(&ext, dp, dbip) < 0) { bu_log("db_dump() read failed on %s, skipping\n", dp->d_namep); continue; } if (wdb_export_external(wdbp, &ext, dp->d_namep, dp->d_flags & ~(RT_DIR_INMEM), dp->d_minor_type) < 0) { bu_log("db_dump() write failed on %s, aborting\n", dp->d_namep); bu_free_external(&ext); return -1; } bu_free_external(&ext); } } return 0; }
int ged_unhide(struct ged *gedp, int argc, const char *argv[]) { struct directory *dp; struct db_i *dbip; struct bu_external ext; struct bu_external tmp; struct db5_raw_internal raw; int i; static const char *usage = "object(s)"; 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; } dbip = gedp->ged_wdbp->dbip; if (db_version(dbip) < 5) { bu_vls_printf(gedp->ged_result_str, "Database was created with a previous release of BRL-CAD.\nSelect \"Tools->Upgrade Database...\" to enable support for this feature."); return GED_ERROR; } for (i = 1; i < argc; i++) { if ((dp = db_lookup(dbip, argv[i], LOOKUP_NOISY)) == RT_DIR_NULL) { continue; } RT_CK_DIR(dp); BU_EXTERNAL_INIT(&ext); if (db_get_external(&ext, dp, dbip) < 0) { bu_vls_printf(gedp->ged_result_str, "db_get_external failed for %s\n", dp->d_namep); continue; } if (db5_get_raw_internal_ptr(&raw, ext.ext_buf) == NULL) { bu_vls_printf(gedp->ged_result_str, "db5_get_raw_internal_ptr() failed for %s\n", dp->d_namep); bu_free_external(&ext); continue; } raw.h_name_hidden = (unsigned char)(0x0); BU_EXTERNAL_INIT(&tmp); db5_export_object3(&tmp, DB5HDR_HFLAGS_DLI_APPLICATION_DATA_OBJECT, dp->d_namep, raw.h_name_hidden, &raw.attributes, &raw.body, raw.major_type, raw.minor_type, raw.a_zzz, raw.b_zzz); bu_free_external(&ext); if (db_put_external(&tmp, dp, dbip)) { bu_vls_printf(gedp->ged_result_str, "db_put_external() failed for %s\n", dp->d_namep); bu_free_external(&tmp); continue; } bu_free_external(&tmp); dp->d_flags &= (~RT_DIR_HIDDEN); } return GED_OK; }
int ged_dbcopy(struct ged *from_gedp, struct ged *to_gedp, const char *from, const char *to, int fflag) { struct directory *from_dp; struct bu_external external; GED_CHECK_DATABASE_OPEN(from_gedp, GED_ERROR); GED_CHECK_DATABASE_OPEN(to_gedp, GED_ERROR); GED_CHECK_READ_ONLY(to_gedp, GED_ERROR); /* initialize result */ bu_vls_trunc(from_gedp->ged_result_str, 0); bu_vls_trunc(to_gedp->ged_result_str, 0); GED_DB_LOOKUP(from_gedp, from_dp, from, LOOKUP_NOISY, GED_ERROR & GED_QUIET); if (!fflag && db_lookup(to_gedp->ged_wdbp->dbip, to, LOOKUP_QUIET) != RT_DIR_NULL) { bu_vls_printf(from_gedp->ged_result_str, "%s already exists.", to); return GED_ERROR; } if (db_get_external(&external, from_dp, from_gedp->ged_wdbp->dbip)) { bu_vls_printf(from_gedp->ged_result_str, "Database read error, aborting\n"); return GED_ERROR; } if (wdb_export_external(to_gedp->ged_wdbp, &external, to, from_dp->d_flags, from_dp->d_minor_type) < 0) { bu_free_external(&external); bu_vls_printf(from_gedp->ged_result_str, "Failed to write new object (%s) to database - aborting!!\n", to); return GED_ERROR; } bu_free_external(&external); /* Need to do something extra for _GLOBAL */ if (db_version(to_gedp->ged_wdbp->dbip) > 4 && BU_STR_EQUAL(to, DB5_GLOBAL_OBJECT_NAME)) { struct directory *to_dp; struct bu_attribute_value_set avs; const char *val; GED_DB_LOOKUP(to_gedp, to_dp, to, LOOKUP_NOISY, GED_ERROR & GED_QUIET); bu_avs_init_empty(&avs); if (db5_get_attributes(to_gedp->ged_wdbp->dbip, &avs, to_dp)) { bu_vls_printf(from_gedp->ged_result_str, "Cannot get attributes for object %s\n", to_dp->d_namep); return GED_ERROR; } if ((val = bu_avs_get(&avs, "title")) != NULL) to_gedp->ged_wdbp->dbip->dbi_title = strdup(val); if ((val = bu_avs_get(&avs, "units")) != NULL) { double loc2mm; if ((loc2mm = bu_mm_value(val)) > 0) { to_gedp->ged_wdbp->dbip->dbi_local2base = loc2mm; to_gedp->ged_wdbp->dbip->dbi_base2local = 1.0 / loc2mm; } } if ((val = bu_avs_get(&avs, "regionid_colortable")) != NULL) { rt_color_free(); db5_import_color_table((char *)val); } bu_avs_free(&avs); } return GED_OK; }
int rt_retrieve_binunif(struct rt_db_internal *intern, struct db_i *dbip, char *name) { register struct directory *dp; struct rt_binunif_internal *bip; struct bu_external ext; struct db5_raw_internal raw; char *tmp; /* *Find the guy we're told to write */ if ( (dp = db_lookup( dbip, name, LOOKUP_NOISY)) == DIR_NULL ) return -1; RT_INIT_DB_INTERNAL(intern); if ( rt_db_get_internal5( intern, dp, dbip, NULL, &rt_uniresource) != ID_BINUNIF || db_get_external( &ext, dp, dbip ) < 0 ) return -1; if (db5_get_raw_internal_ptr(&raw, ext.ext_buf) == NULL) { bu_log("%s:%d\n", __FILE__, __LINE__); bu_free_external( &ext ); return -1; } if (db5_type_descrip_from_codes(&tmp, raw.major_type, raw.minor_type)) tmp = 0; if (RT_G_DEBUG & DEBUG_VOL) bu_log("get_body() sees type (%d, %d)='%s'\n", raw.major_type, raw.minor_type, tmp); if (raw.major_type != DB5_MAJORTYPE_BINARY_UNIF) return -1; bip = intern->idb_ptr; RT_CK_BINUNIF(bip); if (RT_G_DEBUG & DEBUG_HF) rt_binunif_dump(bip); if (RT_G_DEBUG & DEBUG_VOL) bu_log("cmd_export_body() thinks bip->count=%d\n", bip->count); switch (bip -> type) { case DB5_MINORTYPE_BINU_FLOAT: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... float"); break; case DB5_MINORTYPE_BINU_DOUBLE: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... double"); break; case DB5_MINORTYPE_BINU_8BITINT: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... 8bitint"); break; case DB5_MINORTYPE_BINU_8BITINT_U: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... 8bituint"); break; case DB5_MINORTYPE_BINU_16BITINT: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... 16bituint"); break; case DB5_MINORTYPE_BINU_16BITINT_U: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... 16bitint"); break; case DB5_MINORTYPE_BINU_32BITINT: case DB5_MINORTYPE_BINU_32BITINT_U: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... 32bitint"); break; case DB5_MINORTYPE_BINU_64BITINT: case DB5_MINORTYPE_BINU_64BITINT_U: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... 64bitint"); break; default: /* XXX This shouln't happen!! */ bu_log("bip->type switch... default"); break; } bu_free_external( &ext ); return 0; }
/* * C M D _ E X P O R T _ B O D Y ( ) * * Write an object's body to disk file * */ int cmd_export_body(ClientData clientData, Tcl_Interp *interp, int argc, char **argv) { register struct directory *dp; int fd; void *bufp; size_t nbytes = 0; long int written; struct bu_external ext; struct db5_raw_internal raw; struct rt_db_internal intern; struct rt_binunif_internal *bip; struct bu_vls vls; #if 0 int status; #endif char *tmp; CHECK_DBI_NULL; if (argc != 3) { bu_vls_init(&vls); bu_vls_printf(&vls, "help %s", argv[0]); Tcl_Eval(interp, bu_vls_addr(&vls)); bu_vls_free(&vls); return TCL_ERROR; } /* * Find the guy we're told to write */ if ( (dp = db_lookup( dbip, argv[2], LOOKUP_NOISY)) == DIR_NULL ) { bu_vls_init( &vls ); bu_vls_printf( &vls, "Cannot find object %s for writing\n", argv[2] ); Tcl_SetResult(interp, bu_vls_addr( &vls ), TCL_VOLATILE ); bu_vls_free( &vls ); mged_print_result( TCL_ERROR ); return TCL_ERROR; } RT_INIT_DB_INTERNAL(&intern); if ( rt_db_get_internal5( &intern, dp, dbip, NULL, &rt_uniresource) != ID_BINUNIF || db_get_external( &ext, dp, dbip ) < 0 ) { (void)signal( SIGINT, SIG_IGN ); TCL_READ_ERR_return; } if (db5_get_raw_internal_ptr(&raw, ext.ext_buf) == NULL) { bu_free_external( &ext ); (void)signal( SIGINT, SIG_IGN ); TCL_READ_ERR_return; } /* * Do the writing */ #ifndef _WIN32 if ( (fd = creat( argv[1], S_IRWXU | S_IRGRP | S_IROTH )) == -1 ) { #else if ( (fd = creat( argv[1], _S_IREAD | _S_IWRITE )) == -1 ) { #endif bu_free_external( &ext ); bu_vls_init( &vls ); bu_vls_printf( &vls, "Cannot open file %s for writing\n", argv[1] ); Tcl_SetResult(interp, bu_vls_addr( &vls ), TCL_VOLATILE ); bu_vls_free( &vls ); mged_print_result( TCL_ERROR ); return TCL_ERROR; } if (db5_type_descrip_from_codes(&tmp, raw.major_type, raw.minor_type)) tmp = 0; if (RT_G_DEBUG & DEBUG_VOL) bu_log("cmd_export_body() sees type (%d, %d)='%s'\n", raw.major_type, raw.minor_type, tmp); switch (raw.major_type) { case DB5_MAJORTYPE_BINARY_UNIF: #if 0 if ( rt_binunif_import5( &intern, &ext, 0, dbip, &rt_uniresource, raw.minor_type ) ) { (void)signal( SIGINT, SIG_IGN ); TCL_READ_ERR_return; } #endif bip = (struct rt_binunif_internal *) intern.idb_ptr; RT_CK_BINUNIF(bip); rt_binunif_dump(bip); bufp = (void *) bip->u.uint8; bu_log("cmd_export_body() thinks bip->count=%d\n", bip->count); switch (bip -> type) { case DB5_MINORTYPE_BINU_FLOAT: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... float"); nbytes = (size_t) (bip->count * sizeof(float)); break; case DB5_MINORTYPE_BINU_DOUBLE: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... double"); nbytes = (size_t) (bip->count * sizeof(double)); break; case DB5_MINORTYPE_BINU_8BITINT: case DB5_MINORTYPE_BINU_8BITINT_U: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... 8bitint"); nbytes = (size_t) (bip->count); break; case DB5_MINORTYPE_BINU_16BITINT: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... 16bitint"); nbytes = (size_t) (bip->count * 2); bu_log("data[0] = %u\n", bip->u.uint16[0]); break; case DB5_MINORTYPE_BINU_16BITINT_U: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... 16bituint"); nbytes = (size_t) (bip->count * 2); bu_log("data[0] = %u\n", bip->u.uint16[0]); break; case DB5_MINORTYPE_BINU_32BITINT: case DB5_MINORTYPE_BINU_32BITINT_U: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... 32bitint"); nbytes = (size_t) (bip->count * 4); break; case DB5_MINORTYPE_BINU_64BITINT: case DB5_MINORTYPE_BINU_64BITINT_U: if (RT_G_DEBUG & DEBUG_VOL) bu_log("bip->type switch... 64bitint"); nbytes = (size_t) (bip->count * 8); break; default: /* XXX This shouln't happen!! */ bu_log("bip->type switch... default"); break; } break; default: if (RT_G_DEBUG & DEBUG_VOL) bu_log("I'm in the default\n"); bufp = (void *) ext.ext_buf; nbytes = (size_t) ext.ext_nbytes; break; } if (RT_G_DEBUG & DEBUG_VOL) bu_log("going to write %ld bytes\n", nbytes); if ( (written = write(fd, bufp, nbytes) ) != nbytes ) { perror(argv[1]); bu_log("%s:%d\n", __FILE__, __LINE__); bu_free_external( &ext ); bu_vls_init( &vls ); bu_vls_printf( &vls, "Incomplete write of object %s to file %s, got %ld, s/b=%ld\n", argv[2], argv[1], written, nbytes ); Tcl_SetResult(interp, bu_vls_addr( &vls ), TCL_VOLATILE ); bu_vls_free( &vls ); mged_print_result( TCL_ERROR ); return TCL_ERROR; } bu_free_external( &ext ); return TCL_OK; }