int cho_open_tcl(ClientData clientData, Tcl_Interp *interp, int argc, const char **argv) { struct bu_cmdhist_obj *chop; struct bu_vls vls = BU_VLS_INIT_ZERO; if (argc == 1) { /* get list of command history objects */ for (BU_LIST_FOR(chop, bu_cmdhist_obj, &HeadCmdHistObj.l)) Tcl_AppendResult(interp, bu_vls_addr(&chop->cho_name), " ", (char *)NULL); return TCL_OK; } if (argc == 2) { if ((chop = cho_open(clientData, interp, argv[1])) == BU_CMDHIST_OBJ_NULL) return TCL_ERROR; (void)Tcl_CreateCommand(interp, bu_vls_addr(&chop->cho_name), (Tcl_CmdProc *)cho_cmd, (ClientData)chop, cho_deleteProc); /* Return new function name as result */ Tcl_ResetResult(interp); Tcl_AppendResult(interp, bu_vls_addr(&chop->cho_name), (char *)NULL); return TCL_OK; } bu_vls_printf(&vls, "helplib ch_open"); Tcl_Eval(interp, bu_vls_addr(&vls)); bu_vls_free(&vls); return TCL_ERROR; }
void new_image(const struct bu_structparse *UNUSED(sdp), const char *UNUSED(name), void *base, const char *UNUSED(value), void *UNUSED(data)) { struct bbd_specific *bbd_sp = (struct bbd_specific *)base; struct bbd_img *bbdi; /* XXX - looks like we don't release this memory */ BU_ALLOC(bbdi, struct bbd_img); bbdi->img_mf = bu_open_mapped_file_with_path( bbd_sp->rtip->rti_dbip->dbi_filepath, bu_vls_addr(&bbd_sp->img_filename), NULL); if (!bbdi->img_mf) { bu_log("error opening image %s\n", bu_vls_addr(&bbd_sp->img_filename)); bu_bomb(""); } BU_CK_MAPPED_FILE(bbdi->img_mf); bbdi->img_width = bbd_sp->img_width; bbdi->img_width = bbd_sp->img_height; BU_LIST_APPEND(&bbd_sp->imgs, &(bbdi->l)); bbd_sp->img_count++; }
int X_dm_init(struct dm_list *o_dm_list, int argc, char *argv[]) { struct bu_vls vls; dm_var_init(o_dm_list); /* register application provided routines */ cmd_hook = X_dm; Tk_DeleteGenericHandler(doEvent, (ClientData)NULL); if ((dmp = dm_open(interp, DM_TYPE_X, argc-1, argv)) == DM_NULL) return TCL_ERROR; /* keep display manager in sync */ dmp->dm_perspective = mged_variables->mv_perspective_mode; eventHandler = X_doevent; Tk_CreateGenericHandler(doEvent, (ClientData)NULL); (void)DM_CONFIGURE_WIN(dmp); bu_vls_init(&vls); bu_vls_printf(&vls, "mged_bind_dm %s", bu_vls_addr(&pathName)); Tcl_Eval(interp, bu_vls_addr(&vls)); bu_vls_free(&vls); return TCL_OK; }
/* FIXME: not verified in the least bit */ static int create_cyl(point_line_t **plta, int count) { int i; point_line_t *plt = NULL; const char *result; struct bu_vls vls = BU_VLS_INIT_ZERO; struct bu_vls vls2 = BU_VLS_INIT_ZERO; for (i = 0; i < count; i++) { plt = &(*plta)[i]; if (plt && plt->type) bu_vls_printf(&vls, "{ %f %f %f } ", plt->val[X], plt->val[Y], plt->val[Z]); } bu_vls_printf(&vls2, "cylinder { %s }", bu_vls_addr(&vls)); #if PRINT_SCRIPT fprintf(stderr, "%s\n", bu_vls_addr(&vls2)); #endif #if RUN_SCRIPT Tcl_Eval(twerp, bu_vls_addr(&vls2)); result = Tcl_GetStringResult(twerp); if (result && result[0] != '\0') bu_log("create_cyl failure: %s\n", result); else bu_log("create_cyl created\n"); #endif return 1; }
static int charclassmatch(const char *pattern, char test, int *s) { char c; int counter = 0; int resultholder = 0; struct bu_vls classname = BU_VLS_INIT_ZERO; CHARCLASS *ctclass; c = *pattern++; while (c && (c != ':') && (resultholder != -1)) { if (c == FNMATCH_EOS) resultholder = -1; counter++; c = *pattern++; /* next */ } c = *pattern++; bu_vls_strncpy(&classname, pattern-counter-2, counter); ctclass = findclass(bu_vls_addr(&classname)); if (ctclass == NULL) { bu_log("Unknown character class type: %s\n", bu_vls_addr(&classname)); resultholder = -1; } else { /*bu_log("classname: %s, test char = %c, (class->checkfun)=%d\n", bu_vls_addr(&classname), test, (ctclass->checkfun)(test));*/ if ((ctclass->checkfun)(test) != 0) { resultholder = counter; } else { resultholder = 0; } } *s = resultholder; bu_vls_free(&classname); return counter; }
/* * Validate points data file unit string and output conversion factor * to millimeters. If string is not a standard units identifier, the * function assumes a custom conversion factor was specified. A valid * null terminated string is expected as input. The function returns * GED_ERROR if the unit string is invalid or if null pointers were * passed to the function. */ int str2mm(const char *units_string, double *conv_factor, struct bu_vls *ged_result_str) { struct bu_vls str = BU_VLS_INIT_ZERO; double tmp_value = 0.0; char *endp = (char *)NULL; int ret = GED_OK; if ((units_string == (char *)NULL) || (conv_factor == (double *)NULL)) { bu_vls_printf(ged_result_str, "NULL pointer(s) passed to function 'str2mm'.\n"); ret = GED_ERROR; } else { bu_vls_strcat(&str, units_string); bu_vls_trimspace(&str); tmp_value = strtod(bu_vls_addr(&str), &endp); if ((endp != bu_vls_addr(&str)) && (*endp == '\0')) { /* convert to double success */ *conv_factor = tmp_value; } else if ((tmp_value = bu_mm_value(bu_vls_addr(&str))) > 0.0) { *conv_factor = tmp_value; } else { bu_vls_printf(ged_result_str, "Invalid units string '%s'\n", units_string); ret = GED_ERROR; } } bu_vls_free(&str); return ret; }
std::string BRLCADWrapper::GetBRLCADName(std::string &name) { std::ostringstream str; std::string strcnt; struct bu_vls obj_name = BU_VLS_INIT_ZERO; int len = 0; char *cp,*tp; static int start = 1; for (cp = (char *)name.c_str(), len = 0; *cp != '\0'; ++cp, ++len) { if (*cp == '@') { if (*(cp + 1) == '@') ++cp; else break; } bu_vls_putc(&obj_name, *cp); } bu_vls_putc(&obj_name, '\0'); tp = (char *)((*cp == '\0') ? "" : cp + 1); do { bu_vls_trunc(&obj_name, len); bu_vls_printf(&obj_name, "%d", start++); bu_vls_strcat(&obj_name, tp); } while (db_lookup(outfp->dbip, bu_vls_addr(&obj_name), LOOKUP_QUIET) != RT_DIR_NULL); return bu_vls_addr(&obj_name); }
/* * * Get editing string and call ged_red */ int f_red(ClientData UNUSED(clientData), Tcl_Interp *interpreter, int argc, const char *argv[]) { const char **av; struct bu_vls editstring = BU_VLS_INIT_ZERO; CHECK_DBI_NULL; if (argc != 2) { Tcl_Eval(interpreter, "help red"); return TCL_ERROR; } get_editor_string(&editstring); av = (const char **)bu_calloc(4, sizeof(char *), "f_red: av"); av[0] = argv[0]; av[1] = "-E"; av[2] = bu_vls_addr(&editstring); av[3] = argv[1]; if ( ged_red(gedp, 4, (const char **)av) == GED_ERROR ) { Tcl_AppendResult(interpreter, "Error: ", bu_vls_addr(gedp->ged_result_str), (char *)NULL); } else { Tcl_AppendResult(interpreter, bu_vls_addr(gedp->ged_result_str), (char *)NULL); } bu_vls_free(&editstring); bu_free((void *)av, "f_red: av"); return TCL_OK; }
/* FIXME: not verified in the least bit */ static int create_cyl(point_line_t **plta, int count) { int i; point_line_t *plt = NULL; struct bu_vls vls; struct bu_vls vls2; bu_vls_init(&vls); bu_vls_init(&vls2); for (i = 0; i < count; i++) { plt = &(*plta)[i]; if (plt && plt->type) bu_vls_printf(&vls, "{ %f %f %f } ", plt->val[X], plt->val[Y], plt->val[Z]); } bu_vls_printf(&vls2, "cylinder { %S }", &vls); #if PRINT_SCRIPT fprintf(stderr, "%s\n", bu_vls_addr(&vls2)); #endif #if RUN_SCRIPT Tcl_Eval(twerp, bu_vls_addr(&vls2)); if (twerp->result[0] != '\0') bu_log("create_cyl failure: %s\n", twerp->result); else bu_log("create_cyl created\n"); #endif return 1; }
char * Build_unique_name(char *name) { struct name_conv_list *ptr; int name_len; int tries=0; name_len = strlen( name ); bu_vls_strcpy( &ret_name, name ); ptr = name_root; while ( ptr ) { if ( !strcmp( bu_vls_addr( &ret_name ), ptr->brlcad_name ) || (ptr->solid_name && !strcmp( bu_vls_addr( &ret_name ), ptr->solid_name ) ) ) { /* this name already exists, build a new one */ ++tries; bu_vls_trunc( &ret_name, name_len ); bu_vls_printf( &ret_name, "_%d", tries ); ptr = name_root; } ptr = ptr->next; } return( bu_vls_addr( &ret_name ) ); }
int Wgl_dm_init(struct dm_list *o_dm_list, int argc, char *argv[]) { struct bu_vls vls; dm_var_init(o_dm_list); /* register application provided routines */ cmd_hook = Wgl_dm; Tk_DeleteGenericHandler(doEvent, (ClientData)NULL); if ((dmp = dm_open(interp, DM_TYPE_WGL, argc-1, argv)) == DM_NULL) return TCL_ERROR; /*XXXX this eventually needs to move into Wgl's private structure */ dmp->dm_vp = &view_state->vs_vop->vo_scale; dmp->dm_perspective = mged_variables->mv_perspective_mode; eventHandler = Wgl_doevent; Tk_CreateGenericHandler(doEvent, (ClientData)NULL); (void)DM_CONFIGURE_WIN(dmp); bu_vls_init(&vls); bu_vls_printf(&vls, "mged_bind_dm %s", bu_vls_addr(&pathName)); Tcl_Eval(interp, bu_vls_addr(&vls)); bu_vls_free(&vls); return TCL_OK; }
static void _bu_close_files() { struct _bu_tf_list *popped; if (!_bu_tf) { return; } /* close all files, free their nodes, and unlink */ while (BU_LIST_WHILE(popped, _bu_tf_list, &(_bu_tf->l))) { BU_LIST_DEQUEUE(&(popped->l)); if (popped) { if (popped->fd != -1) { close(popped->fd); popped->fd = -1; } if (BU_VLS_IS_INITIALIZED(&popped->fn) && bu_vls_addr(&popped->fn)) { unlink(bu_vls_addr(&popped->fn)); bu_vls_free(&popped->fn); } bu_free(popped, "free bu_temp_file node"); } } /* free the head */ if (_bu_tf->fd != -1) { close(_bu_tf->fd); _bu_tf->fd = -1; } if (BU_VLS_IS_INITIALIZED(&_bu_tf->fn) && bu_vls_addr(&_bu_tf->fn)) { unlink(bu_vls_addr(&_bu_tf->fn)); bu_vls_free(&_bu_tf->fn); } bu_free(_bu_tf, "free bu_temp_file head"); }
/* * * Usage: * procname getcursor */ HIDDEN int fbo_getcursor_tcl(ClientData clientData, Tcl_Interp *interp, int argc, char **argv) { struct fb_obj *fbop = (struct fb_obj *)clientData; int status; int mode; int x, y; struct bu_vls vls; if (argc != 2) { bu_vls_init(&vls); bu_vls_printf(&vls, "helplib fb_getcursor"); Tcl_Eval(interp, bu_vls_addr(&vls)); bu_vls_free(&vls); return TCL_ERROR; } status = fb_getcursor(fbop->fbo_fbs.fbs_fbp, &mode, &x, &y); if (status == 0) { bu_vls_init(&vls); bu_vls_printf(&vls, "%d %d %d", mode, x, y); Tcl_AppendResult(interp, bu_vls_addr(&vls), (char *)NULL); bu_vls_free(&vls); return TCL_OK; } return TCL_ERROR; }
/* * Supports for the 'keep' method. * Write each node encountered exactly once. */ HIDDEN void node_write(struct db_i *dbip, struct directory *dp, void *ptr) { struct keep_node_data *kndp = (struct keep_node_data *)ptr; struct rt_db_internal intern; RT_CK_WDB(kndp->wdbp); if (dp->d_nref++ > 0) return; /* already written */ if (rt_db_get_internal(&intern, dp, dbip, NULL, &rt_uniresource) < 0) { bu_vls_printf(kndp->gedp->ged_result_str, "Database read error, aborting\n"); return; } if (dp->d_major_type == DB5_MAJORTYPE_BRLCAD && dp->d_minor_type == DB5_MINORTYPE_BRLCAD_EXTRUDE) { /* if this is an extrusion, keep the referenced sketch */ struct rt_extrude_internal *extr; struct directory *dp2; extr = (struct rt_extrude_internal *)intern.idb_ptr; RT_EXTRUDE_CK_MAGIC(extr); if ((dp2 = db_lookup(dbip, extr->sketch_name, LOOKUP_QUIET)) != RT_DIR_NULL) { node_write(dbip, dp2, ptr); } } else if (dp->d_major_type == DB5_MAJORTYPE_BRLCAD && dp->d_minor_type == DB5_MINORTYPE_BRLCAD_REVOLVE) { /* if this is a revolve, keep the referenced sketch */ struct rt_revolve_internal *rev; struct directory *dp2; rev = (struct rt_revolve_internal *)intern.idb_ptr; RT_REVOLVE_CK_MAGIC(rev); if ((dp2 = db_lookup(dbip, bu_vls_addr(&rev->sketch_name), LOOKUP_QUIET)) != RT_DIR_NULL) { node_write(dbip, dp2, ptr); } } else if (dp->d_major_type == DB5_MAJORTYPE_BRLCAD && dp->d_minor_type == DB5_MINORTYPE_BRLCAD_DSP) { /* if this is a DSP, keep the referenced binary object too */ struct rt_dsp_internal *dsp; struct directory *dp2; dsp = (struct rt_dsp_internal *)intern.idb_ptr; RT_DSP_CK_MAGIC(dsp); if (dsp->dsp_datasrc == RT_DSP_SRC_OBJ) { /* need to keep this object */ if ((dp2 = db_lookup(dbip, bu_vls_addr(&dsp->dsp_name), LOOKUP_QUIET)) != RT_DIR_NULL) { node_write(dbip, dp2, ptr); } } } if (wdb_put_internal(kndp->wdbp, dp->d_namep, &intern, 1.0) < 0) { bu_vls_printf(kndp->gedp->ged_result_str, "Database write error, aborting\n"); return; } }
static void dup_dir_check5(struct db_i *input_dbip, const struct db5_raw_internal *rip, off_t addr, void *ptr) { char *name; struct directory *dupdp; struct bu_vls local = BU_VLS_INIT_ZERO; struct dir_check_stuff *dcsp = (struct dir_check_stuff *)ptr; if (dcsp->main_dbip == DBI_NULL) return; RT_CK_DBI(input_dbip); RT_CK_RIP(rip); if (rip->h_dli == DB5HDR_HFLAGS_DLI_HEADER_OBJECT) return; if (rip->h_dli == DB5HDR_HFLAGS_DLI_FREE_STORAGE) return; name = (char *)rip->name.ext_buf; if (name == (char *)NULL) return; if (addr == 0) return; /* do not compare _GLOBAL */ if (rip->major_type == DB5_MAJORTYPE_ATTRIBUTE_ONLY && rip->minor_type == 0) return; /* Add the prefix, if any */ if (db_version(dcsp->main_dbip) < 5) { if (dcsp->wdbp->wdb_ncharadd > 0) { bu_vls_strncpy(&local, bu_vls_addr(&dcsp->wdbp->wdb_prestr), dcsp->wdbp->wdb_ncharadd); bu_vls_strcat(&local, name); } else { bu_vls_strncpy(&local, name, _GED_V4_MAXNAME); } bu_vls_trunc(&local, _GED_V4_MAXNAME); } else { if (dcsp->wdbp->wdb_ncharadd > 0) { (void)bu_vls_vlscat(&local, &dcsp->wdbp->wdb_prestr); (void)bu_vls_strcat(&local, name); } else { (void)bu_vls_strcat(&local, name); } } /* Look up this new name in the existing (main) database */ if ((dupdp = db_lookup(dcsp->main_dbip, bu_vls_addr(&local), LOOKUP_QUIET)) != RT_DIR_NULL) { /* Duplicate found, add it to the list */ dcsp->wdbp->wdb_num_dups++; *dcsp->dup_dirp++ = dupdp; } bu_vls_free(&local); return; }
static int isst_load_g(ClientData UNUSED(clientData), Tcl_Interp *interp, int objc, Tcl_Obj *const *objv) { struct isst_s *isst; char **argv; int argc; double az, el; struct bu_vls tclstr = BU_VLS_INIT_ZERO; vect_t vec; Togl *togl; if (objc < 4) { Tcl_WrongNumArgs(interp, 1, objv, "load_g pathname object"); return TCL_ERROR; } if (Togl_GetToglFromObj(interp, objv[1], &togl) != TCL_OK) { return TCL_ERROR; } isst = (struct isst_s *) Togl_GetClientData(togl); argv = (char **)malloc(sizeof(char *) * (strlen(Tcl_GetString(objv[3])) + 1)); /* allocate way too much. */ argc = bu_argv_from_string(argv, strlen(Tcl_GetString(objv[3])), Tcl_GetString(objv[3])); load_g(isst->tie, Tcl_GetString(objv[2]), argc, (const char **)argv, &(isst->meshes)); free(argv); VSETALL(isst->camera.pos, isst->tie->radius); VMOVE(isst->camera.focus, isst->tie->mid); VMOVE(isst->camera_pos_init, isst->camera.pos); VMOVE(isst->camera_focus_init, isst->camera.focus); /* Set the initial az and el values in Tcl/Tk */ VSUB2(vec, isst->camera.pos, isst->camera.focus); VUNITIZE(vec); AZEL_FROM_V3DIR(az, el, vec); az = az * -DEG2RAD; el = el * -DEG2RAD; bu_vls_sprintf(&tclstr, "%f", az); Tcl_SetVar(interp, "az", bu_vls_addr(&tclstr), 0); bu_vls_sprintf(&tclstr, "%f", el); Tcl_SetVar(interp, "el", bu_vls_addr(&tclstr), 0); bu_vls_free(&tclstr); render_phong_init(&isst->camera.render, NULL); isst->ogl = 1; isst->w = Togl_Width(togl); isst->h = Togl_Height(togl); resize_isst(isst); isst->t1 = bu_gettime(); isst->t2 = bu_gettime(); return TCL_OK; }
int read_point (FILE *fp, fastf_t *c_p, int c_len, int normalize, struct bu_vls *tail) { char *cp = NULL; fastf_t sum; int i; int return_code = 1; static int line_nm = 0; struct bu_vls *bp; for (bp = bu_vls_vlsinit();; bu_vls_trunc(bp, 0)) { if (bu_vls_gets(bp, fp) == -1) { return_code = EOF; goto wrap_up; } ++line_nm; cp = bu_vls_addr(bp); while ((*cp == ' ') || (*cp == '\t')) ++cp; if ((*cp == '#') || (*cp == '\0')) continue; for (i = 0; i < c_len; ++i) { char *endp; c_p[i] = strtod(cp, &endp); if (endp == cp) bu_exit (1, "Illegal input at line %d: '%s'\n", line_nm, bu_vls_addr(bp)); cp = endp; } if (normalize) { sum = 0.0; for (i = 0; i < c_len; ++i) sum += c_p[i]; for (i = 0; i < c_len; ++i) c_p[i] /= sum; } goto wrap_up; } wrap_up: if ((return_code == 1) && (tail != 0)) { bu_vls_trunc(tail, 0); bu_vls_strcat(tail, cp); } bu_vls_vlsfree(bp); return (return_code); }
int compare_attrs(struct directory *dp1, struct directory *dp2) { struct bu_vls vls = BU_VLS_INIT_ZERO; Tcl_Obj *obj1, *obj2; int different = 0; if (db_version(dbip1) > 4) { bu_vls_printf(&vls, "_db1 attr get %s", dp1->d_namep); if (Tcl_Eval(INTERP, bu_vls_addr(&vls)) != TCL_OK) { fprintf(stderr, "Cannot get attributes for %s\n", dp1->d_namep); fprintf(stderr, "%s\n", Tcl_GetStringResult(INTERP)); bu_exit(1, NULL); } obj1 = Tcl_DuplicateObj(Tcl_GetObjResult(INTERP)); Tcl_ResetResult(INTERP); if (dp1->d_flags & RT_DIR_REGION && verify_region_attribs) { verify_region_attrs(dp1, dbip1, obj1); } } else { obj1 = Tcl_NewObj(); } if (db_version(dbip2) > 4) { bu_vls_trunc(&vls, 0); bu_vls_printf(&vls, "_db2 attr get %s", dp1->d_namep); if (Tcl_Eval(INTERP, bu_vls_addr(&vls)) != TCL_OK) { fprintf(stderr, "Cannot get attributes for %s\n", dp1->d_namep); fprintf(stderr, "%s\n", Tcl_GetStringResult(INTERP)); bu_exit(1, NULL); } obj2 = Tcl_DuplicateObj(Tcl_GetObjResult(INTERP)); Tcl_ResetResult(INTERP); if (dp1->d_flags & RT_DIR_REGION && verify_region_attribs) { verify_region_attrs(dp2, dbip2, obj2); } } else { obj2 = Tcl_NewObj(); } if ((dp1->d_flags & RT_DIR_REGION) && (dp2->d_flags & RT_DIR_REGION)) { /* don't complain about "region" attributes */ remove_region_attrs(obj1); remove_region_attrs(obj2); } bu_vls_trunc(&vls, 0); different = do_compare(ATTRS, &vls, obj1, obj2, dp1->d_namep); printf("%s", bu_vls_addr(&vls)); bu_vls_free(&vls); return different; }
/** * compares an input units string to a reference units name and * returns truthfully if they match. the comparison ignores any * embedded whitespace and is case insensitive. */ static int units_name_matches(const char *input, const char *name) { const char *cp; int match; struct bu_vls normalized_input = BU_VLS_INIT_ZERO; struct bu_vls normalized_name = BU_VLS_INIT_ZERO; /* convert NULL */ if (!input) input = ""; if (!name) name = ""; /* skip spaces */ while (isspace((unsigned char)*input)) input++; while (isspace((unsigned char)*name)) name++; /* quick exit */ if (tolower((unsigned char)input[0]) != tolower((unsigned char)name[0])) return 0; cp = input; /* skip spaces, convert to lowercase */ while (*cp != '\0') { if (!isspace((unsigned char)*cp)) bu_vls_putc(&normalized_input, tolower((unsigned char)*cp)); cp++; } cp = name; /* skip spaces, convert to lowercase */ while (*cp != '\0') { if (!isspace((unsigned char)*cp)) bu_vls_putc(&normalized_name, tolower((unsigned char)*cp)); cp++; } /* trim any trailing 's' for plurality */ if (bu_vls_addr(&normalized_input)[bu_vls_strlen(&normalized_input)-1] == 's') { bu_vls_trunc(&normalized_input, -1); } if (bu_vls_addr(&normalized_name)[bu_vls_strlen(&normalized_name)-1] == 's') { bu_vls_trunc(&normalized_name, -1); } /* compare */ match = BU_STR_EQUAL(bu_vls_addr(&normalized_input), bu_vls_addr(&normalized_name)); bu_vls_free(&normalized_input); bu_vls_free(&normalized_name); return match; }
/** * This is the generic routine to be listed in OBJ[].ft_get * for those solid types which are fully described by their * ft_parsetab entry. * * 'attr' is specified to retrieve only one attribute, rather than * all. Example: "db get ell.s B" to get only the B vector. */ int rt_generic_get(struct bu_vls *logstr, const struct rt_db_internal *intern, const char *attr) { register const struct bu_structparse *sp = NULL; register const struct rt_functab *ftp; RT_CK_DB_INTERNAL(intern); ftp = intern->idb_meth; RT_CK_FUNCTAB(ftp); sp = ftp->ft_parsetab; if (!sp) { bu_vls_printf(logstr, "%s {a Tcl output routine for this type of object has not yet been implemented}", ftp->ft_label); return BRLCAD_ERROR; } if (attr == (char *)0) { struct bu_vls str = BU_VLS_INIT_ZERO; /* Print out solid type and all attributes */ bu_vls_printf(logstr, "%s", ftp->ft_label); while (sp->sp_name != NULL) { bu_vls_printf(logstr, " %s", sp->sp_name); bu_vls_trunc(&str, 0); bu_vls_struct_item(&str, sp, (char *)intern->idb_ptr, ' '); if (sp->sp_count < 2) bu_vls_printf(logstr, " %s", bu_vls_addr(&str)); else { bu_vls_printf(logstr, " {"); bu_vls_printf(logstr, "%s", bu_vls_addr(&str)); bu_vls_printf(logstr, "} "); } ++sp; } bu_vls_free(&str); } else { if (bu_vls_struct_item_named(logstr, sp, attr, (char *)intern->idb_ptr, ' ') < 0) { bu_vls_printf(logstr, "Objects of type %s do not have a %s attribute.", ftp->ft_label, attr); return BRLCAD_ERROR; } } return BRLCAD_OK; }
/** * b u _ v l s _ t r i m s p a c e * * Remove leading and trailing white space from a vls string. */ void bu_vls_trimspace( struct bu_vls *vp ) { BU_CK_VLS(vp); /* Remove trailing white space */ while ( isspace( bu_vls_addr(vp)[bu_vls_strlen(vp)-1] ) ) bu_vls_trunc( vp, -1 ); /* Remove leading white space */ while ( isspace( *bu_vls_addr(vp) ) ) bu_vls_nibble( vp, 1 ); }
/* * Listen for framebuffer clients. * * Usage: * procname listen port * * Returns the port number actually used. * */ HIDDEN int fbo_listen_tcl(ClientData clientData, Tcl_Interp *interp, int argc, char **argv) { struct fb_obj *fbop = (struct fb_obj *)clientData; struct bu_vls vls; bu_vls_init(&vls); if (fbop->fbo_fbs.fbs_fbp == FBIO_NULL) { bu_vls_printf(&vls, "%s listen: framebuffer not open!\n", argv[0]); Tcl_AppendResult(interp, bu_vls_addr(&vls), (char *)NULL); bu_vls_free(&vls); return TCL_ERROR; } /* return the port number */ if (argc == 2) { bu_vls_printf(&vls, "%d", fbop->fbo_fbs.fbs_listener.fbsl_port); Tcl_AppendResult(interp, bu_vls_addr(&vls), (char *)NULL); bu_vls_free(&vls); return TCL_OK; } if (argc == 3) { int port; if (sscanf(argv[2], "%d", &port) != 1) { Tcl_AppendResult(interp, "listen: bad value - ", argv[2], "\n", (char *)NULL); return TCL_ERROR; } if (port >= 0) fbs_open(interp, &fbop->fbo_fbs, port); else { fbs_close(interp, &fbop->fbo_fbs); } bu_vls_printf(&vls, "%d", fbop->fbo_fbs.fbs_listener.fbsl_port); Tcl_AppendResult(interp, bu_vls_addr(&vls), (char *)NULL); bu_vls_free(&vls); return TCL_OK; } bu_vls_printf(&vls, "helplib fb_listen"); Tcl_Eval(interp, bu_vls_addr(&vls)); bu_vls_free(&vls); return TCL_ERROR; }
int compare_tcl_combs(Tcl_Obj *obj1, struct directory *dp1, Tcl_Obj *obj2) { int junk; struct bu_vls adjust = BU_VLS_INIT_ZERO; int different = 0; /* first check if there is any difference */ if (BU_STR_EQUAL(Tcl_GetStringFromObj(obj1, &junk), Tcl_GetStringFromObj(obj2, &junk))) return 0; if (mode != HUMAN) { bu_vls_printf(&adjust, "db adjust %s", dp1->d_namep); } different = do_compare(PARAMS, &adjust, obj1, obj2, dp1->d_namep); if (mode != HUMAN) { printf("%s\n", bu_vls_addr(&adjust)); } bu_vls_free(&adjust); return different; }
HIDDEN int extract_format_prefix(struct bu_vls *format, const char *input) { struct bu_vls wformat = BU_VLS_INIT_ZERO; char *colon_pos = NULL; char *inputcpy = NULL; if (UNLIKELY(!input)) return 0; inputcpy = bu_strdup(input); colon_pos = strchr(inputcpy, ':'); if (colon_pos) { int ret = 0; bu_vls_sprintf(&wformat, "%s", input); bu_vls_trunc(&wformat, -1 * strlen(colon_pos)); if (bu_vls_strlen(&wformat) > 0) { ret = 1; if (format) bu_vls_sprintf(format, "%s", bu_vls_addr(&wformat)); } bu_vls_free(&wformat); if (inputcpy) bu_free(inputcpy, "input copy"); return ret; } else { if (inputcpy) bu_free(inputcpy, "input copy"); return 0; } /* Shouldn't get here */ return 0; }
HIDDEN int extract_path(struct bu_vls *path, const char *input) { int ret = 0; struct bu_vls wpath = BU_VLS_INIT_ZERO; char *colon_pos = NULL; char *inputcpy = NULL; if (UNLIKELY(!input)) return 0; inputcpy = bu_strdup(input); colon_pos = strchr(inputcpy, ':'); if (colon_pos) { bu_vls_sprintf(&wpath, "%s", input); bu_vls_nibble(&wpath, strlen(input) - strlen(colon_pos) + 1); if (path && bu_vls_strlen(&wpath) > 0) { ret = 1; bu_vls_sprintf(path, "%s", bu_vls_addr(&wpath)); } bu_vls_free(&wpath); } else { if (path) bu_vls_sprintf(path, "%s", input); ret = 1; } if (inputcpy) bu_free(inputcpy, "input copy"); if (path && !(bu_vls_strlen(path) > 0)) return 0; return ret; }
void rt_vlist_export(struct bu_vls *vls, struct bu_list *hp, const char *name) { register struct bn_vlist *vp; size_t nelem; size_t namelen; size_t nbytes; unsigned char *buf; unsigned char *bp; BU_CK_VLS(vls); /* Count number of element in the vlist */ nelem = 0; for (BU_LIST_FOR(vp, bn_vlist, hp)) { nelem += vp->nused; } /* Build output buffer for binary transmission * nelem[4], String[n+1], cmds[nelem*1], pts[3*nelem*8] */ namelen = strlen(name)+1; nbytes = namelen + 4 + nelem * (1+ELEMENTS_PER_VECT*SIZEOF_NETWORK_DOUBLE) + 2; /* FIXME: this is pretty much an abuse of vls. should be using * vlb for variable-length byte buffers. */ bu_vls_setlen(vls, (int)nbytes); buf = (unsigned char *)bu_vls_addr(vls); *(uint32_t *)buf = htonl((uint32_t)nelem); bp = buf+sizeof(uint32_t); bu_strlcpy((char *)bp, name, namelen); bp += namelen; /* Output cmds, as bytes */ for (BU_LIST_FOR(vp, bn_vlist, hp)) { register int i; register int nused = vp->nused; register int *cmd = vp->cmd; for (i = 0; i < nused; i++) { *bp++ = *cmd++; } } /* Output points, as three 8-byte doubles */ for (BU_LIST_FOR(vp, bn_vlist, hp)) { register int i; register int nused = vp->nused; register point_t *pt = vp->pt; /* must be double for import and export */ double point[ELEMENTS_PER_POINT]; for (i = 0; i < nused; i++) { VMOVE(point, pt[i]); /* convert fastf_t to double */ htond(bp, (unsigned char *)point, ELEMENTS_PER_VECT); bp += ELEMENTS_PER_VECT*SIZEOF_NETWORK_DOUBLE; } } }
int Dm_Init(void *interpreter) { Tcl_Interp *interp = (Tcl_Interp *)interpreter; static struct bu_cmdtab cmdtab[] = { {"dm_validXType", dm_validXType_tcl}, {"dm_bestXType", dm_bestXType_tcl}, {(const char *)NULL, BU_CMD_NULL} }; struct bu_vls vls = BU_VLS_INIT_ZERO; /* register commands */ register_cmds(interp, cmdtab); bu_vls_strcpy(&vls, "vectorThreshold"); Tcl_LinkVar(interp, bu_vls_addr(&vls), (char *)&vectorThreshold, TCL_LINK_INT); bu_vls_free(&vls); /* initialize display manager object code */ Dmo_Init(interp); Tcl_PkgProvide(interp, "Dm", brlcad_version()); return TCL_OK; }
/* * Usage: * procname configure width height */ int fbo_configure_tcl(ClientData clientData, Tcl_Interp *interp, int argc, char **argv) { struct fb_obj *fbop = (struct fb_obj *)clientData; int width, height; if (argc != 4) { struct bu_vls vls; bu_vls_init(&vls); bu_vls_printf(&vls, "helplib fb_configure"); Tcl_Eval(interp, bu_vls_addr(&vls)); bu_vls_free(&vls); return TCL_ERROR; } if (sscanf(argv[2], "%d", &width) != 1) { Tcl_AppendResult(interp, "fb_configure: bad width - ", argv[2], (char *)NULL); return TCL_ERROR; } if (sscanf(argv[3], "%d", &height) != 1) { Tcl_AppendResult(interp, "fb_configure: bad height - ", argv[3], (char *)NULL); return TCL_ERROR; } /* configure the framebuffer window */ if (fbop->fbo_fbs.fbs_fbp != FBIO_NULL) fb_configureWindow(fbop->fbo_fbs.fbs_fbp, width, height); return TCL_OK; }
/* * Refresh the entire framebuffer or that part specified by * a rectangle (i.e. x y width height) * Usage: * procname refresh [rect] */ HIDDEN int fbo_refresh_tcl(ClientData clientData, Tcl_Interp *interp, int argc, char **argv) { struct fb_obj *fbop = (struct fb_obj *)clientData; int x, y, w, h; /* rectangle to be refreshed */ if (argc < 2 || 3 < argc) { struct bu_vls vls; bu_vls_init(&vls); bu_vls_printf(&vls, "helplib fb_refresh"); Tcl_Eval(interp, bu_vls_addr(&vls)); bu_vls_free(&vls); return TCL_ERROR; } if (argc == 2) { /* refresh the whole display */ x = y = 0; w = fbop->fbo_fbs.fbs_fbp->if_width; h = fbop->fbo_fbs.fbs_fbp->if_height; } else if (sscanf(argv[2], "%d %d %d %d", &x, &y, &w, &h) != 4) { /* refresh rectanglar area */ Tcl_AppendResult(interp, "fb_refresh: bad rectangle - ", argv[2], (char *)NULL); return TCL_ERROR; } #if 1 return fb_refresh(fbop->fbo_fbs.fbs_fbp, x, y, w, h); #else return fbop->fbo_fbs.fbs_fbp->if_refresh(fbop->fbo_fbs.fbs_fbp, x, y, w, h) #endif }
HIDDEN int dm_bestXType_tcl(void *clientData, int argc, const char **argv) { Tcl_Interp *interp = (Tcl_Interp *)clientData; Tcl_Obj *obj; const char *best_dm; char buffer[256] = {0}; if (argc != 2) { struct bu_vls vls = BU_VLS_INIT_ZERO; bu_vls_printf(&vls, "helplib dm_bestXType"); Tcl_Eval(interp, bu_vls_addr(&vls)); bu_vls_free(&vls); return TCL_ERROR; } obj = Tcl_GetObjResult(interp); if (Tcl_IsShared(obj)) obj = Tcl_DuplicateObj(obj); snprintf(buffer, 256, "%s", argv[1]); best_dm = dm_bestXType(buffer); if (best_dm) { Tcl_AppendStringsToObj(obj, best_dm, (char *)NULL); Tcl_SetObjResult(interp, obj); return TCL_OK; } return TCL_ERROR; }