int bu_same_file(const char *fn1, const char *fn2) { struct stat sb1, sb2; if (UNLIKELY(!fn1 || !fn2)) { return 0; } if (UNLIKELY(fn1[0] == '\0' || fn2[0] == '\0')) { return 0; } if (!bu_file_exists(fn1, NULL) || !bu_file_exists(fn2, NULL)) { return 0; } if ((stat(fn1, &sb1) == 0) && (stat(fn2, &sb2) == 0) && (sb1.st_dev == sb2.st_dev) && (sb1.st_ino == sb2.st_ino)) { return 1; } return 0; }
int bu_file_delete(const char *path) { int fd = 0; int ret = 0; int retry = 0; struct stat sb; /* reject empty, special, or non-existent paths */ if (!path || BU_STR_EQUAL(path, "") || BU_STR_EQUAL(path, ".") || BU_STR_EQUAL(path, "..") || !bu_file_exists(path, &fd)) { return 0; } do { if (retry++) { /* second pass, try to force deletion by changing file * permissions (similar to rm -f). */ if (fstat(fd, &sb) == -1) { break; } bu_fchmod(fd, (sb.st_mode|S_IRWXU)); } ret = (remove(path) == 0) ? 0 : 1; } while (ret == 0 && retry < 2); close(fd); /* all boils down to whether the file still exists, not whether * remove thinks it succeeded. */ if (bu_file_exists(path, &fd)) { /* failure */ if (retry > 1) { /* restore original file permission */ bu_fchmod(fd, sb.st_mode); } close(fd); return 0; } else { /* deleted */ return 1; } }
int main(int argc, char *argv[]) { static const char usage[] = "Usage:\n%s [-o outfile] \n\n -o file \tFile to write out (default: ringworld.g)\n\n"; char outfile[MAXPATHLEN] = "ringworld.g"; int optc; struct rt_wdb *fp; while ((optc = bu_getopt(argc, argv, "o:h?")) != -1) { if (bu_optopt == '?') optc='h'; switch (optc) { case 'o': snprintf(outfile, MAXPATHLEN, "%s", bu_optarg); break; default: fprintf(stderr,usage, *argv); return optc == '?' ? EXIT_FAILURE : EXIT_SUCCESS; } } if (argc == 1) { fprintf(stderr,usage, *argv); fprintf(stderr," Program continues running:\n"); } if (bu_file_exists(outfile, NULL)) bu_exit(EXIT_FAILURE, "ERROR: %s already exists. Remove file and try again.", outfile); bu_log("Writing ringworld out to [%s]\n", outfile); fp = wdb_fopen(outfile); mk_sol(fp, SUN_DIAMETER); mk_ring(fp, RING_ORBIT, RING_WIDTH, RING_FLOOR_THICKNESS, RING_WALL_THICKNESS, RING_WALL_HEIGHT); mk_shadowring(fp, SHADOWRING_ORBIT, SHADOWRING_NUM, SHADOWRING_WIDTH, SHADOWRING_LENGTH, SHADOWRING_THICKNESS); /* generate a comb all.g */ { struct wmember c; BU_LIST_INIT(&c.l); mk_addmember("ring.r", &c.l, NULL, WMOP_UNION); mk_addmember("sun.r", &c.l, NULL, WMOP_UNION); /* mk_addmember("shadowring.r", &c.l, NULL, WMOP_UNION); */ mk_lcomb(fp, "all.g", &c, 0, NULL, NULL, NULL, 0); } wdb_close(fp); bu_log("BRL-CAD geometry database file [%s] created.\nDone.\n", outfile); return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { static const char usage[] = "Usage:\n%s [-o outfile] [-n count]\n\n -o file \tFile to write out (default: metaball.g)\n -n count\tTotal metaball point count (default %d)\n\n"; static const int COUNTMAX = 555; char outfile[MAXPATHLEN] = "metaball.g"; int optc; long count = COUNTMAX; if (argc == 1) { fprintf(stderr,usage, *argv, COUNTMAX); fprintf(stderr," Program continues running:\n"); } while ((optc = bu_getopt(argc, argv, "o:n:h?")) != -1) { if (bu_optopt == '?') optc='h'; switch (optc) { case 'o': snprintf(outfile, MAXPATHLEN, "%s", bu_optarg); break; case 'n': count = atoi(bu_optarg); break; default: fprintf(stderr,usage, *argv, COUNTMAX); return optc == '?' ? EXIT_FAILURE : EXIT_SUCCESS; } } if (count <= 0) bu_exit(EXIT_FAILURE, "ERROR: count must be greater than zero"); if (bu_file_exists(outfile, NULL)) bu_exit(EXIT_FAILURE, "ERROR: %s already exists. Remove file and try again.", outfile); bu_log("Writing metaballs out to [%s]\n", outfile); /* make dinner */ make_spaghetti(outfile, "meatballs.s", count); bu_log("BRL-CAD geometry database file [%s] created.\nDone.\n", outfile); return EXIT_SUCCESS; }
/** * b u _ a r g v 0 _ f u l l _ p a t h * * returns the full path to argv0, regardless of how the application * was invoked. */ const char * bu_argv0_full_path(void) { static char buffer[MAXPATHLEN] = {0}; const char *argv0 = bu_argv0(); const char *ipwd = bu_ipwd(); const char *which = bu_which(argv0); if (argv0[0] == BU_DIR_SEPARATOR) { /* seems to be a full path */ snprintf(buffer, MAXPATHLEN, "%s", argv0); return buffer; } if (argv0[0] == '.' && argv0[1] == BU_DIR_SEPARATOR) { /* remove a ./ if present */ argv0 += 2; } /* running from installed */ if (which) { snprintf(buffer, MAXPATHLEN, "%s", which); return buffer; } /* running from source dir */ snprintf(buffer, MAXPATHLEN, "%s%c%s", ipwd, BU_DIR_SEPARATOR, argv0); if (bu_file_exists(buffer)) { return buffer; } /* give up */ snprintf(buffer, MAXPATHLEN, "%s", argv0); return buffer; }
int ged_lc(struct ged *gedp, int argc, const char *argv[]) { char *file_name = NULL; int file_name_flag_cnt = 0; int sort_column = 1; int sort_column_flag_cnt = 0; int find_duplicates_flag = 0; int skip_special_duplicates_flag = 0; int skip_subtracted_regions_flag = 0; int descending_sort_flag = 0; int unrecognized_flag_cnt = 0; int orig_argc; const char **orig_argv; static const char *usage = "[-d|-s] [-r] [-z] [-0|-1|-2|-3|-4|-5] [-f {FileName}] {GroupName}"; int c; int error_cnt = 0; FILE *outfile = NULL; struct bu_vls *output; const char *group_name; size_t i,j; struct bu_ptbl results1 = BU_PTBL_INIT_ZERO; struct bu_ptbl results2 = BU_PTBL_INIT_ZERO; char *path; char *plan; struct db_full_path root; int matches; struct region_record *regions; size_t ignored_cnt = 0; /* The defaults are the minimum widths to accommodate column headers */ size_t region_id_len_max = 2; size_t material_id_len_max = 3; size_t los_len_max = 3; size_t obj_len_max = 6; /* For the output at the end */ size_t start, end, incr; /* initialize result */ bu_vls_trunc(gedp->ged_result_str, 0); if (argc == 1) { bu_vls_printf(gedp->ged_result_str, "Usage: %s\n", usage); return GED_HELP; } GED_CHECK_DATABASE_OPEN(gedp, GED_ERROR); GED_CHECK_ARGC_GT_0(gedp, argc, GED_ERROR); bu_optind = 1; /* re-init bu_getopt() */ while ((c = bu_getopt(argc, (char * const *)argv, "dsrz012345f:")) != -1) { switch (c) { case '0': case '1': case '2': case '3': case '4': case '5': sort_column_flag_cnt++; sort_column = c - '0'; break; case 'f': file_name_flag_cnt++; file_name = bu_optarg; break; case 's': skip_special_duplicates_flag = 1; /* FALLTHROUGH */ case 'd': find_duplicates_flag = 1; break; case 'r': skip_subtracted_regions_flag = 1; break; case 'z': descending_sort_flag = 1; break; default: unrecognized_flag_cnt++; } } orig_argc = argc; orig_argv = argv; argc -= (bu_optind - 1); argv += (bu_optind - 1); /* Attempt to recreate the exact error messages from the original lc.tcl */ if (file_name_flag_cnt > 1) { bu_vls_printf(gedp->ged_result_str, "Error: '-f' used more than once.\n"); error_cnt++; } if (sort_column_flag_cnt > 1) { bu_vls_printf(gedp->ged_result_str, "Error: Sort column defined more than once.\n"); error_cnt++; } if (file_name_flag_cnt + argc + unrecognized_flag_cnt > 3) { bu_vls_printf(gedp->ged_result_str, "Error: More than one group name and/or file name was specified.\n"); error_cnt++; } else if (argc < 2) { if (file_name_flag_cnt && !file_name) { bu_vls_printf(gedp->ged_result_str, "Error: Group name and file name not specified\n"); } else { bu_vls_printf(gedp->ged_result_str, "Error: Group name not specified.\n"); } error_cnt++; } else if (argc + unrecognized_flag_cnt > 2) { bu_vls_printf(gedp->ged_result_str, "Error: More than one group name was specified.\n"); error_cnt++; } else if (file_name_flag_cnt && !file_name) { bu_vls_printf(gedp->ged_result_str, "Error: File name not specified.\n"); error_cnt++; } if (file_name) { char *norm_name; norm_name = bu_realpath(file_name, NULL); if (file_name[0] == '-') { bu_vls_printf(gedp->ged_result_str, "Error: File name can not start with '-'.\n"); error_cnt++; } else if (bu_file_exists(file_name, NULL)) { bu_vls_printf(gedp->ged_result_str, "Error: Output file %s already exists.\n",norm_name); error_cnt++; } else { outfile = fopen(file_name, "w"); if (!outfile) { bu_vls_printf(gedp->ged_result_str, "Error: %d\n", errno); error_cnt++; } } bu_vls_printf(gedp->ged_result_str, "Output filename: %s\n", norm_name); bu_free(norm_name, "ged_lc"); output = bu_vls_vlsinit(); } else { output = gedp->ged_result_str; } if (error_cnt > 0) { return GED_ERROR; } group_name = argv[1]; /* The 7 is for the "-name" and '\0' */ plan = (char *) bu_malloc(sizeof(char) * (strlen(group_name) + 7), "ged_lc"); sprintf(plan, "-name %s", group_name); matches = db_search(&results1, DB_SEARCH_TREE, plan, 0, NULL, gedp->ged_wdbp->dbip); if (matches < 1) { bu_vls_printf(gedp->ged_result_str, "Error: Group '%s' does not exist.\n", group_name); return GED_ERROR; } bu_free(plan, "ged_lc"); db_search_free(&results1); if (skip_subtracted_regions_flag) { plan = "-type region ! -bool -"; } else { plan = "-type region"; } path = (char *) bu_malloc(sizeof(char) * (strlen(group_name) + 2), "ged_lc"); sprintf(path, "/%s", group_name); db_string_to_path(&root, gedp->ged_wdbp->dbip, path); matches = db_search(&results2, DB_SEARCH_TREE, plan, root.fp_len, root.fp_names, gedp->ged_wdbp->dbip); bu_free(path, "ged_lc"); if (matches < 1) { return GED_ERROR; } regions = (struct region_record *) bu_malloc(sizeof(struct region_record) * BU_PTBL_LEN(&results2), "ged_lc"); for (i = 0; i < BU_PTBL_LEN(&results2); i++) { struct db_full_path *entry = (struct db_full_path *)BU_PTBL_GET(&results2, i); struct directory *dp_curr_dir = DB_FULL_PATH_CUR_DIR(entry); struct bu_attribute_value_set avs; j = BU_PTBL_LEN(&results2) - i - 1 ; regions[j].ignore = 0; bu_avs_init_empty(&avs); db5_get_attributes(gedp->ged_wdbp->dbip, &avs, dp_curr_dir); regions[j].region_id = get_attr(&avs, "region_id"); V_MAX(region_id_len_max, strlen(regions[j].region_id)); regions[j].material_id = get_attr(&avs, "material_id"); V_MAX(material_id_len_max, strlen(regions[j].material_id)); regions[j].los = get_attr(&avs, "los"); V_MAX(los_len_max, strlen(regions[j].los)); regions[j].obj_name = dp_curr_dir->d_namep; V_MAX(obj_len_max, strlen(regions[j].obj_name)); if (entry->fp_len > 1) { struct directory *dp_parent = DB_FULL_PATH_GET(entry, entry->fp_len - 2); regions[j].obj_parent = dp_parent->d_namep; } else { regions[j].obj_parent = "--"; } } if (find_duplicates_flag) { bu_sort((void *) regions, BU_PTBL_LEN(&results2), sizeof(struct region_record), cmp_regions, NULL); for (i = 1; i < BU_PTBL_LEN(&results2); i++) { int same; if (skip_special_duplicates_flag) { same = !cmp_regions((void *)&(regions[i - 1]), (void *)&(regions[i]), NULL); } else { same = !bu_strcmp(regions[i - 1].region_id, regions[i].region_id); } if (same) { regions[i].ignore = 1; ignored_cnt++; } } if (ignored_cnt == BU_PTBL_LEN(&results2)) { if (file_name) { print_cmd_args(output, orig_argc, orig_argv); bu_vls_printf(output, "No duplicate region_id\n"); bu_vls_fwrite(outfile, output); fclose(outfile); } bu_vls_printf(gedp->ged_result_str, "No duplicate region_id\n"); bu_vls_printf(gedp->ged_result_str, "Done.\n"); bu_free(regions, "ged_lc"); return GED_ERROR; } } if (sort_column > 0) { bu_sort((void *) regions, BU_PTBL_LEN(&results2), sizeof(struct region_record), sort_regions, (void *)&sort_column); } if (file_name) { print_cmd_args(output, orig_argc, orig_argv); } bu_vls_printf(output, "List length: %d\n", BU_PTBL_LEN(&results2) - ignored_cnt); bu_vls_printf(output, "%-*s %-*s %-*s %-*s %s\n", region_id_len_max + 1, "ID", material_id_len_max + 1, "MAT", los_len_max, "LOS", obj_len_max, "REGION", "PARENT"); end = BU_PTBL_LEN(&results2); if (descending_sort_flag) { start = end - 1; end = -1; incr = -1; } else { start = 0; incr = 1; } for (i = start; i != end; i += incr) { if (regions[i].ignore) { continue; } bu_vls_printf(output, "%-*s %-*s %-*s %-*s %s\n", region_id_len_max + 1, regions[i].region_id, material_id_len_max + 1, regions[i].material_id, los_len_max, regions[i].los, obj_len_max, regions[i].obj_name, regions[i].obj_parent); } bu_vls_printf(gedp->ged_result_str, "Done.\n"); if (file_name) { bu_vls_fwrite(outfile, output); fclose(outfile); } bu_free(regions, "ged_lc"); return GED_OK; }
int ged_saveview(struct ged *gedp, int argc, const char *argv[]) { struct ged_display_list *gdlp; struct ged_display_list *next_gdlp; int i; FILE *fp; char *base; int c; char rtcmd[255] = {'r', 't', 0}; char outlog[255] = {0}; char outpix[255] = {0}; char inputg[255] = {0}; static const char *usage = "[-e] [-i] [-l] [-o] filename [args]"; 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; } bu_optind = 1; while ((c = bu_getopt(argc, (char * const *)argv, "e:i:l:o:")) != -1) { switch (c) { case 'e': snprintf(rtcmd, 255, "%s", bu_optarg); break; case 'l': snprintf(outlog, 255, "%s", bu_optarg); break; case 'o': snprintf(outpix, 255, "%s", bu_optarg); break; case 'i': snprintf(inputg, 255, "%s", bu_optarg); break; default: { bu_vls_printf(gedp->ged_result_str, "Option '%c' unknown\n", c); bu_vls_printf(gedp->ged_result_str, "help saveview"); return GED_ERROR; } } } argc -= bu_optind-1; argv += bu_optind-1; if (argc < 2) { 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 GED_ERROR; } (void)bu_fchmod(fileno(fp), 0755); /* executable */ if (!gedp->ged_wdbp->dbip->dbi_filename) { bu_log("Error: geometry file is not specified\n"); fclose(fp); return GED_ERROR; } if (!bu_file_exists(gedp->ged_wdbp->dbip->dbi_filename, NULL)) { bu_log("Error: %s does not exist\n", gedp->ged_wdbp->dbip->dbi_filename); fclose(fp); return GED_ERROR; } base = basename_without_suffix(argv[1], ".sh"); if (outpix[0] == '\0') { snprintf(outpix, 255, "%s.pix", base); } if (outlog[0] == '\0') { snprintf(outlog, 255, "%s.log", base); } /* Do not specify -v option to rt; batch jobs must print everything. -Mike */ fprintf(fp, "#!/bin/sh\n%s -M ", rtcmd); if (gedp->ged_gvp->gv_perspective > 0) fprintf(fp, "-p%g ", gedp->ged_gvp->gv_perspective); for (i = 2; i < argc; i++) fprintf(fp, "%s ", argv[i]); if (bu_strncmp(rtcmd, "nirt", 4) != 0) fprintf(fp, "\\\n -o %s\\\n $*\\\n", outpix); if (inputg[0] == '\0') { snprintf(inputg, 255, "%s", gedp->ged_wdbp->dbip->dbi_filename); } fprintf(fp, " '%s'\\\n ", inputg); gdlp = BU_LIST_NEXT(ged_display_list, gedp->ged_gdp->gd_headDisplay); while (BU_LIST_NOT_HEAD(gdlp, gedp->ged_gdp->gd_headDisplay)) { next_gdlp = BU_LIST_PNEXT(ged_display_list, gdlp); fprintf(fp, "'%s' ", bu_vls_addr(&gdlp->gdl_path)); gdlp = next_gdlp; } fprintf(fp, "\\\n 2>> %s\\\n", outlog); fprintf(fp, " <<EOF\n"); { vect_t eye_model; _ged_rt_set_eye_model(gedp, eye_model); _ged_rt_write(gedp, fp, eye_model); } fprintf(fp, "\nEOF\n"); (void)fclose(fp); return GED_OK; }
int main(int argc, char **argv) { int i = 0; int diff_state = 0; struct bu_ptbl results; struct db_i *dbip1 = DBI_NULL; struct db_i *dbip2 = DBI_NULL; /*struct bu_vls diff_log = BU_VLS_INIT_ZERO;*/ struct bn_tol *diff_tol; BU_GET(diff_tol, struct bn_tol); diff_tol->dist = BN_TOL_DIST; BU_PTBL_INIT(&results); if (argc != 3) { bu_log("Error - please specify two .g files\n"); bu_exit(EXIT_FAILURE, NULL); } if (!bu_file_exists(argv[1], NULL)) { bu_exit(1, "Cannot stat file %s\n", argv[1]); } if (!bu_file_exists(argv[2], NULL)) { bu_exit(1, "Cannot stat file %s\n", argv[2]); } if ((dbip1 = db_open(argv[1], DB_OPEN_READONLY)) == DBI_NULL) { bu_exit(1, "Cannot open geometry database file %s\n", argv[1]); } RT_CK_DBI(dbip1); if (db_dirbuild(dbip1) < 0) { db_close(dbip1); bu_exit(1, "db_dirbuild failed on geometry database file %s\n", argv[1]); } /* Reset the material head so we don't get warnings when the global * is overwritten. This will go away when material_head ceases to * be a librt global.*/ rt_new_material_head(MATER_NULL); if ((dbip2 = db_open(argv[2], DB_OPEN_READONLY)) == DBI_NULL) { bu_exit(1, "Cannot open geometry database file %s\n", argv[2]); } RT_CK_DBI(dbip2); if (db_dirbuild(dbip2) < 0) { db_close(dbip1); db_close(dbip2); bu_exit(1, "db_dirbuild failed on geometry database file %s\n", argv[1]); } diff_state = db_diff(dbip1, dbip2, diff_tol, DB_COMPARE_ALL, &results); if (diff_state == DIFF_UNCHANGED) { bu_log("No differences found.\n"); } else { print_diff_summary(&results); } for (i = 0; i < (int)BU_PTBL_LEN(&results); i++) { struct diff_result *result = (struct diff_result *)BU_PTBL_GET(&results, i); diff_free_result(result); } bu_ptbl_free(&results); BU_PUT(diff_tol, struct bn_tol); db_close(dbip1); db_close(dbip2); return 0; }
const char * bu_whereis(const char *cmd) { static const char *gotpath = NULL; char PATH[MAXPATHENV]; char *directory = NULL; char *position = NULL; if (UNLIKELY(bu_debug & BU_DEBUG_PATHS)) { bu_log("bu_whereis: [%s]\n", cmd); } if (UNLIKELY(!cmd)) { return NULL; } /* start fresh */ memset(PATH, 0, MAXPATHENV); memset(bu_whereis_result, 0, MAXPATHLEN); /* check for full/relative path match */ bu_strlcpy(bu_whereis_result, cmd, MAXPATHLEN); if (!BU_STR_EQUAL(bu_whereis_result, cmd)) { if (UNLIKELY(bu_debug & BU_DEBUG_PATHS)) { bu_log("command [%s] is too long\n", cmd); } return NULL; } if (bu_file_exists(bu_whereis_result, NULL) && strchr(bu_whereis_result, BU_DIR_SEPARATOR)) { if (bu_whereis_result[0] == '\0') return NULL; /* never return empty */ return bu_whereis_result; } #if defined(HAVE_SYSCTL) && defined(CTL_USER) && defined(USER_CS_PATH) { int mib[2] = { CTL_USER, USER_CS_PATH }; size_t len = MAXPATHENV; /* use sysctl() to get the PATH */ if (sysctl(mib, 2, PATH, &len, NULL, 0) != 0) { if (UNLIKELY(bu_debug & BU_DEBUG_PATHS)) { perror("sysctl of user.cs_path"); bu_log("user.cs_path is unusable\n"); } return NULL; } if (UNLIKELY(bu_debug & BU_DEBUG_PATHS)) { bu_log("PATH is %s\n", PATH); } } #endif /* HAVE_SYSCTL */ /* search for the executable */ directory = PATH; do { position = strchr(directory, BU_PATH_SEPARATOR); if (position) { *position = '\0'; } /* empty means use current dir */ if (strlen(directory) == 0) { directory = "."; } snprintf(bu_whereis_result, MAXPATHLEN, "%s/%s", directory, cmd); if (bu_file_exists(bu_whereis_result, NULL)) { if (bu_whereis_result[0] == '\0') return NULL; /* never return empty */ return bu_whereis_result; } if (position) { directory = position + 1; } else { directory = NULL; } } while (directory); /* iterate over PATH directories */ /* no path or no match */ if (UNLIKELY(bu_debug & BU_DEBUG_PATHS)) { bu_log("no %s in %s\n", cmd, gotpath ? gotpath : "(no path)"); } return NULL; }
static int get_args(int argc, char **argv) { int c; while ((c = bu_getopt(argc, argv, "cF:ds:w:n:S:W:N:X:Y:C:h?")) != -1) { switch (c) { case 'c': crunch = 1; break; case 'F': framebuffer = bu_optarg; break; case 's': /* square file size */ file_height = file_width = atoi(bu_optarg); break; case 'S': screen_height = screen_width = atoi(bu_optarg); break; case 'w': file_width = atoi(bu_optarg); break; case 'W': screen_width = atoi(bu_optarg); break; case 'n': file_height = atoi(bu_optarg); break; case 'N': screen_height = atoi(bu_optarg); break; case 'X': screen_xoff = atoi(bu_optarg); break; case 'Y': screen_yoff = atoi(bu_optarg); break; case 'C': { char *cp = bu_optarg; int *conp = background; /* premature null => atoi gives zeros */ for (c=0; c < 3; c++) { *conp++ = atoi(cp); while (*cp && *cp++ != '/') ; } } break; default: return 0; } } if (argv[bu_optind] != NULL) { if (bu_file_exists(argv[bu_optind], NULL)) { (void) fprintf(stderr, "\"%s\" already exists.\n", argv[bu_optind]); bu_exit(1, NULL); } if ((outrle.rle_file = fopen(argv[bu_optind], "wb")) == NULL) { perror(argv[bu_optind]); return 0; } } if (argc > ++bu_optind) (void) fprintf(stderr, "fb-rle: Excess arguments ignored\n"); if (isatty(fileno(outrle.rle_file))) return 0; return 1; }
int main(int ac, char *av[]) { struct rt_wdb *db_fp = NULL; struct bu_vls lens_type = BU_VLS_INIT_ZERO; struct bu_vls name = BU_VLS_INIT_ZERO; int lens_1side_2side; fastf_t ref_ind, thickness, diameter, focal_length; bu_vls_trunc(&lens_type, 0); bu_vls_trunc(&name, 0); ref_ind = 1.5; diameter = 200; thickness = diameter/5; focal_length = 600; lens_1side_2side = 2; bu_vls_printf(&lens_type, "DCX"); bu_vls_printf(&name, "lens_%s_f%.1f_d%.1f", bu_vls_addr(&lens_type), focal_length, diameter); /* Process arguments */ ReadArgs(ac, av, &lens_1side_2side, &ref_ind, &diameter, &thickness, &focal_length); /* Create file name if supplied, else use "lens.g" */ if (av[bu_optind]) { if (!bu_file_exists(av[bu_optind], NULL)) { db_fp = wdb_fopen(av[bu_optind]); } else { bu_exit(-1, "Error - refusing to overwrite pre-existing file %s", av[bu_optind]); } } if (!av[bu_optind]) { if (!bu_file_exists(DEFAULT_LENS_FILENAME, NULL)) { db_fp = wdb_fopen(DEFAULT_LENS_FILENAME); } else { bu_exit(-1, "Error - no filename supplied and lens.g exists."); } } /* Make the requested lens*/ if (lens_1side_2side == 1 && focal_length > 0) { bu_log("Making Plano-Convex lens...\n"); bu_vls_trunc(&lens_type, 0); bu_vls_trunc(&name, 0); bu_vls_printf(&lens_type, "PCX"); bu_vls_printf(&name, "lens_%s_f%.1f_d%.1f", bu_vls_addr(&lens_type), focal_length, diameter); MakeP(db_fp, bu_vls_addr(&name), diameter, focal_length, ref_ind, thickness); } if (lens_1side_2side == 1 && focal_length < 0) { bu_log("Making Plano-Concave lens...\n"); bu_vls_trunc(&lens_type, 0); bu_vls_trunc(&name, 0); bu_vls_printf(&lens_type, "PCV"); bu_vls_printf(&name, "lens_%s_f%.1f_d%.1f", bu_vls_addr(&lens_type), focal_length, diameter); MakeP(db_fp, bu_vls_addr(&name), diameter, focal_length, ref_ind, thickness); } if (lens_1side_2side == 2 && focal_length > 0) { bu_log("Making BiConvex lens...\n"); bu_vls_trunc(&lens_type, 0); bu_vls_trunc(&name, 0); bu_vls_printf(&lens_type, "DCX"); bu_vls_printf(&name, "lens_%s_f%.1f_d%.1f", bu_vls_addr(&lens_type), focal_length, diameter); MakeD(db_fp, bu_vls_addr(&name), diameter, focal_length, ref_ind, thickness); } if (lens_1side_2side == 2 && focal_length < 0) { bu_log("Making BiConcave lens...\n"); bu_vls_trunc(&lens_type, 0); bu_vls_trunc(&name, 0); bu_vls_printf(&lens_type, "DCV"); bu_vls_printf(&name, "lens_%s_f%.1f_d%.1f", bu_vls_addr(&lens_type), focal_length, diameter); MakeD(db_fp, bu_vls_addr(&name), diameter, focal_length, ref_ind, thickness); } /* Close database */ wdb_close(db_fp); return 0; }
char * bu_getcwd(char *buf, size_t size) { char *cwd = NULL; char *pwd = NULL; char cbuf[MAXPATHLEN] = {0}; size_t sz = size; /* NULL buf means allocate */ if (!buf) { sz = MAXPATHLEN; buf = (char *)bu_calloc(1, sz, "alloc bu_getcwd"); } /* FIRST: try getcwd */ #ifdef HAVE_GETCWD cwd = getcwd(cbuf, MAXPATHLEN); if (cwd && strlen(cwd) > 0 && bu_file_exists(cwd, NULL)) { #if defined(HAVE_WORKING_REALPATH_FUNCTION) /* FIXME: shouldn't have gotten here with -std=c99 (HAVE_REALPATH test not working right?) */ char rbuf[MAXPATHLEN] = {0}; char *rwd = bu_realpath(cbuf, rbuf); if (rwd && strlen(rwd) > 0 && bu_file_exists(rwd, NULL)) { BU_ASSERT(sz > strlen(rwd)+1); bu_strlcpy(buf, rwd, strlen(rwd)+1); return buf; } #endif /* HAVE_WORKING_REALPATH_FUNCTION */ BU_ASSERT(sz > strlen(cwd)+1); bu_strlcpy(buf, cwd, strlen(cwd)+1); return buf; } #else /* quellage */ cwd = memset(cbuf, 0, MAXPATHLEN); #endif /* HAVE_GETCWD */ /* SECOND: try environment */ pwd = getenv("PWD"); if (pwd && strlen(pwd) > 0 && bu_file_exists(pwd, NULL)) { #if defined(HAVE_WORKING_REALPATH_FUNCTION) char rbuf[MAXPATHLEN] = {0}; char *rwd = realpath(pwd, rbuf); if (rwd && strlen(rwd) > 0 && bu_file_exists(rwd, NULL)) { BU_ASSERT(sz > strlen(rwd)+1); bu_strlcpy(buf, rwd, strlen(rwd)+1); return buf; } #endif /* HAVE_WORKING_REALPATH_FUNCTION */ BU_ASSERT(sz > strlen(pwd)+1); bu_strlcpy(buf, pwd, strlen(pwd)+1); return buf; } /* LAST: punt (but do not return NULL) */ BU_ASSERT(sz > strlen(".")+1); bu_strlcpy(buf, ".", strlen(".")+1); return buf; }
int main(int argc, char *argv[]) { int ret = 0; int convert_tops_list = 0; struct directory **paths; int path_cnt = 0; AP203_Contents *sc = new AP203_Contents; // process command line arguments int c; char *output_file = (char *)NULL; while ((c = bu_getopt(argc, argv, "o:")) != -1) { switch (c) { case 'o': output_file = bu_optarg; break; default: usage(); bu_exit(1, NULL); break; } } if (bu_optind >= argc || output_file == (char *)NULL) { usage(); bu_exit(1, NULL); } argc -= bu_optind; argv += bu_optind; /* check our inputs/outputs */ if (bu_file_exists(output_file, NULL)) { bu_exit(1, "ERROR: refusing to overwrite existing output file:\"%s\". Please remove file or change output file name and try again.", output_file); } if (!bu_file_exists(argv[0], NULL) && !BU_STR_EQUAL(argv[0], "-")) { bu_exit(2, "ERROR: unable to read input \"%s\" .g file", argv[0]); } if (argc < 2) { convert_tops_list = 1; } std::string iflnm = argv[0]; std::string oflnm = output_file; /* load .g file */ BRLCADWrapper *dotg = new BRLCADWrapper(); if (!dotg) { std::cerr << "ERROR: unable to create BRL-CAD instance" << std::endl; return 3; } if (!dotg->load(iflnm)) { std::cerr << "ERROR: unable to open BRL-CAD input file [" << oflnm << "]" << std::endl; delete dotg; return 2; } struct db_i *dbip = dotg->GetDBIP(); struct rt_wdb *wdbp = wdb_dbopen(dbip, RT_WDB_TYPE_DB_DISK); if (convert_tops_list) { /* Need db_update_nref for DB_LS_TOPS to work */ db_update_nref(dbip, &rt_uniresource); path_cnt = db_ls(dbip, DB_LS_TOPS, &paths); if (!path_cnt) { std::cerr << "ERROR: no objects found in .g file" << "\n" << std::endl; delete dotg; return 1; } } else { int i = 1; paths = (struct directory **)bu_malloc(sizeof(struct directory *) * argc, "dp array"); while (i < argc) { bu_log("%d: %s\n", i, argv[i]); struct directory *dp = db_lookup(dbip, argv[i], LOOKUP_QUIET); if (dp == RT_DIR_NULL) { std::cerr << "ERROR: cannot find " << argv[i] << "\n" << std::endl; delete dotg; bu_free(paths, "free path memory"); return 1; } else { paths[i-1] = dp; path_cnt++; i++; } } paths[i-1] = RT_DIR_NULL; } struct bu_vls scratch_string; bu_vls_init(&scratch_string); Registry *registry = new Registry(SchemaInit); InstMgr instance_list; STEPfile *sfile = new STEPfile(*registry, instance_list); registry->ResetSchemas(); registry->ResetEntities(); /* Populate the header instances */ InstMgr *header_instances = sfile->HeaderInstances(); /* 1 - Populate File_Name */ SdaiFile_name * fn = (SdaiFile_name *)sfile->HeaderDefaultFileName(); bu_vls_sprintf(&scratch_string, "'%s'", output_file); fn->name_(bu_vls_addr(&scratch_string)); fn->time_stamp_(""); StringAggregate_ptr author_tmp = new StringAggregate; author_tmp->AddNode(new StringNode("''")); fn->author_(author_tmp); StringAggregate_ptr org_tmp = new StringAggregate; org_tmp->AddNode(new StringNode("''")); fn->organization_(org_tmp); fn->preprocessor_version_("'BRL-CAD g-step exporter'"); fn->originating_system_("''"); fn->authorization_("''"); header_instances->Append((SDAI_Application_instance *)fn, completeSE); /* 2 - Populate File_Description */ SdaiFile_description * fd = (SdaiFile_description *)sfile->HeaderDefaultFileDescription(); StringAggregate_ptr description_tmp = new StringAggregate; description_tmp->AddNode(new StringNode("''")); fd->description_(description_tmp); fd->implementation_level_("'2;1'"); header_instances->Append((SDAI_Application_instance *)fd, completeSE); /* 3 - Populate File_Schema */ SdaiFile_schema *fs = (SdaiFile_schema *)sfile->HeaderDefaultFileSchema(); StringAggregate_ptr schema_tmp = new StringAggregate; schema_tmp->AddNode(new StringNode("'CONFIG_CONTROL_DESIGN'")); fs->schema_identifiers_(schema_tmp); header_instances->Append((SDAI_Application_instance *)fs, completeSE); sc->registry = registry; sc->instance_list = &instance_list; sc->default_context = Add_Default_Geometric_Context(sc); sc->application_context = (SdaiApplication_context *)sc->registry->ObjCreate("APPLICATION_CONTEXT"); sc->instance_list->Append((STEPentity *)sc->application_context, completeSE); sc->application_context->application_("'CONFIGURATION CONTROLLED 3D DESIGNS OF MECHANICAL PARTS AND ASSEMBLIES'"); sc->design_context = (SdaiDesign_context *)sc->registry->ObjCreate("DESIGN_CONTEXT"); sc->instance_list->Append((STEPentity *)sc->design_context, completeSE); sc->design_context->name_("''"); sc->design_context->life_cycle_stage_("'design'"); sc->design_context->frame_of_reference_(sc->application_context); sc->solid_to_step = new std::map<struct directory *, STEPentity *>; sc->solid_to_step_shape = new std::map<struct directory *, STEPentity *>; sc->solid_to_step_manifold = new std::map<struct directory *, STEPentity *>; sc->comb_to_step = new std::map<struct directory *, STEPentity *>; sc->comb_to_step_shape = new std::map<struct directory *, STEPentity *>; sc->comb_to_step_manifold = new std::map<struct directory *, STEPentity *>; for (int i = 0; i < path_cnt; i++) { /* Now, add actual DATA */ struct directory *dp = paths[i]; struct rt_db_internal intern; rt_db_get_internal(&intern, dp, dbip, bn_mat_identity, &rt_uniresource); RT_CK_DB_INTERNAL(&intern); Object_To_STEP(dp, &intern, wdbp, sc); rt_db_free_internal(&intern); } /* Write STEP file */ if (!bu_file_exists(output_file, NULL)) { std::ofstream stepout(output_file); sfile->WriteExchangeFile(stepout); } /* Free memory */ header_instances->DeleteInstances(); instance_list.DeleteInstances(); delete dotg; delete registry; delete sfile; delete sc->solid_to_step; delete sc->solid_to_step_shape; delete sc->solid_to_step_manifold; delete sc->comb_to_step; delete sc->comb_to_step_shape; delete sc->comb_to_step_manifold; delete sc; bu_vls_free(&scratch_string); bu_free(paths, "free dp list"); return ret; }
void direct_output(const char *buffer, com_table *ctp, struct rt_i *UNUSED(rtip)) { size_t i = 0; /* current position on the *buffer */ size_t j = 0; /* position of last non-whitespace char in the *buffer */ FILE *newf; static char *new_dest; static FILE *(*openfunc)() = 0; while (isspace((int)*(buffer+i))) ++i; if (*(buffer+i) == '\0') { /* display current destination */ #if defined(HAVE_POPEN) && !defined(STRICT_FLAGS) printf("destination = %s%s'\n", (openfunc == popen) ? "'| " : "'", dest_string); #endif return; } if (BU_STR_EQUAL(buffer + i, "?")) { com_usage(ctp); return; } if (BU_STR_EQUAL(buffer + i, "default")) { newf = stdout; new_dest = def_dest_string; openfunc = 0; } else { if (*(buffer + i) == '|') { #if defined(HAVE_POPEN) && !defined(STRICT_FLAGS) openfunc=popen; ++i; #else fprintf(stderr, "Error, support for pipe output is disabled. Try a redirect instead.\n"); return; #endif } else { openfunc=fopen; } /*Find last non-whitespace character*/ j = strlen(buffer); while (isspace((int)*(buffer+j-1))) j--; new_dest = bu_malloc(strlen(buffer + i)+1, "new_dest"); snprintf(new_dest, j-i+1, "%s", buffer + i); if (bu_file_exists(new_dest, NULL)) { fprintf(stderr, "File %s already exists.\n", new_dest); return; } if ((newf = (*openfunc)(new_dest, "w")) == NULL) { #if defined(HAVE_POPEN) && !defined(STRICT_FLAGS) fprintf(stderr, "Cannot open %s '%s'\n", (openfunc == popen) ? "pipe" : "file", new_dest); #endif fprintf(stderr, "Destination remains = '%s'\n", dest_string); bu_free(new_dest, "new(now old)dest"); return; } } /* Clean up from previous output destination */ if (outf != (FILE *)NULL && outf != stdout) fclose(outf); if (dest_string != def_dest_string) bu_free(dest_string, "free dest_string"); /* Establish the new destination */ outf = newf; dest_string = new_dest; }