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;
}
