int
get_args(int argc, char **argv)
{
int ch;
char *ifname;
while ((ch = bu_getopt(argc, argv, OPT_STRING)) != -1) {
switch (ch) {
/*
* BRL-CAD image-size options
*/
case 'a':
autosize = 1;
break;
case 's':
/* square file size */
file_height = file_width = atol(bu_optarg);
autosize = 0;
break;
case 'n':
file_height = atol(bu_optarg);
autosize = 0;
break;
case 'w':
file_width = atol(bu_optarg);
autosize = 0;
break;
/*
* application-specific options
*/
case 'c':
make_cells = 1;
break;
case 'f':
if (format != 0)
bu_free(format, "format_string");
format = (char *)bu_malloc(strlen(bu_optarg)+1, "format string");
bu_strlcpy(format, bu_optarg, strlen(bu_optarg)+1);
break;
case '#':
d_per_l = atoi(bu_optarg);
break;
default:
print_usage(1);
}
}
if (argc == 1 && isatty(fileno(stdin)) && isatty(fileno(stdout)))
print_usage(0);
if (format == 0)
format = " %g";
/*
* Establish the input stream
*/
switch (argc - bu_optind) {
case 0:
file_name = "stdin";
infd = 0;
break;
case 1:
file_name = argv[bu_optind++];
ifname = bu_realpath(file_name, NULL);
if ((infd = open(ifname, O_RDONLY)) == -1) {
bu_free(ifname, "ifname alloc from bu_realpath");
bu_exit (1, "Cannot open file '%s'\n", file_name);
}
bu_free(ifname, "ifname alloc from bu_realpath");
fileinput = 1;
break;
default:
print_usage(1);
}
if (argc > ++bu_optind) {
print_usage(1);
}
return 1; /* OK */
}
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;
}
static int
get_args(int argc, char *argv[])
{
int c;
double d;
while ((c = bu_getopt(argc, argv, "a:s:m:d:Ae:r:h?")) != -1) {
switch (c) {
case 'a':
op[ numop ] = ADD;
val[ numop++ ] = atof(bu_optarg);
break;
case 's':
op[ numop ] = ADD;
val[ numop++ ] = - atof(bu_optarg);
break;
case 'm':
op[ numop ] = MULT;
val[ numop++ ] = atof(bu_optarg);
break;
case 'd':
op[ numop ] = MULT;
d = atof(bu_optarg);
if (ZERO(d)) {
bu_exit(2, "%s: divide by zero!\n", progname);
}
val[ numop++ ] = 1.0 / d;
break;
case 'A':
op[ numop ] = ABS;
val[ numop++ ] = 0;
break;
case 'e':
op[ numop ] = POW;
val[ numop++ ] = atof(bu_optarg);
break;
case 'r':
op[ numop ] = POW;
d = atof(bu_optarg);
if (ZERO(d)) {
bu_exit(2, "%s: zero root!\n", progname);
}
val[ numop++ ] = 1.0 / d;
break;
default: /* '?' */
bu_exit(1, "%s", usage);
}
}
if (bu_optind >= argc) {
if (isatty((int)fileno(stdin)))
return 0;
} else {
char *ifname;
const char *file_name = NULL;
file_name = argv[bu_optind];
ifname = bu_realpath(file_name, NULL);
if (freopen(ifname, "r", stdin) == NULL) {
fprintf(stderr,
"%s: cannot open \"%s(canonical %s)\" for reading\n",
progname, file_name, ifname);
bu_free(ifname, "ifname alloc from bu_realpath");
return 0;
}
bu_free(ifname, "ifname alloc from bu_realpath");
}
if (argc > ++bu_optind)
fprintf(stderr, "%s: excess argument(s) ignored\n", progname);
return 1; /* OK */
}
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;
}
struct bu_mapped_file *
bu_open_mapped_file(const char *name, const char *appl)
/* file name */
/* non-null only when app. will use 'apbuf' */
{
struct bu_mapped_file *mp = (struct bu_mapped_file *)NULL;
char *real_path = bu_realpath(name, NULL);
#ifdef HAVE_SYS_STAT_H
struct stat sb;
int fd = -1; /* unix file descriptor */
int readval;
ssize_t bytes_to_go, nbytes;
#else
FILE *fp = (FILE *)NULL; /* stdio file pointer */
#endif
int ret;
if (UNLIKELY(bu_debug&BU_DEBUG_MAPPED_FILE))
bu_log("bu_open_mapped_file(%s(canonical path - %s), %s)\n", name, real_path, appl?appl:"(NIL)");
/* See if file has already been mapped, and can be shared */
bu_semaphore_acquire(BU_SEM_MAPPEDFILE);
if (!BU_LIST_IS_INITIALIZED(&bu_mapped_file_list)) {
BU_LIST_INIT(&bu_mapped_file_list);
}
for (BU_LIST_FOR(mp, bu_mapped_file, &bu_mapped_file_list)) {
BU_CK_MAPPED_FILE(mp);
/* find a match */
if (!BU_STR_EQUAL(real_path, mp->name))
continue;
if (appl && !BU_STR_EQUAL(appl, mp->appl))
continue;
/* found a match */
/* if mapped file still exists, verify size and modtime */
if (!mp->dont_restat) {
bu_semaphore_acquire(BU_SEM_SYSCALL);
fd = open(real_path, O_RDONLY | O_BINARY);
bu_semaphore_release(BU_SEM_SYSCALL);
/* If file didn't vanish from disk, make sure it's the same file */
if (fd >= 0) {
#ifdef HAVE_SYS_STAT_H
bu_semaphore_acquire(BU_SEM_SYSCALL);
ret = fstat(fd, &sb);
bu_semaphore_release(BU_SEM_SYSCALL);
if (ret < 0) {
/* odd, open worked but fstat failed. assume it
* vanished from disk and the mapped copy is still
* OK.
*/
bu_semaphore_acquire(BU_SEM_SYSCALL);
(void)close(fd);
bu_semaphore_release(BU_SEM_SYSCALL);
fd = -1;
}
if ((size_t)sb.st_size != mp->buflen) {
bu_log("bu_open_mapped_file(%s) WARNING: File size changed from %ld to %ld, opening new version.\n", real_path, mp->buflen, sb.st_size);
/* mp doesn't reflect the file any longer. Invalidate. */
mp->appl = bu_strdup("__STALE__");
/* Can't invalidate old copy, it may still be in use. */
break;
}
if (sb.st_mtime != mp->modtime) {
bu_log("bu_open_mapped_file(%s) WARNING: File modified since last mapped, opening new version.\n", real_path);
/* mp doesn't reflect the file any longer. Invalidate. */
mp->appl = bu_strdup("__STALE__");
/* Can't invalidate old copy, it may still be in use. */
break;
}
/* To be completely safe, should check st_dev and st_inum */
#endif
}
/* It is safe to reuse mp */
mp->uses++;
bu_semaphore_release(BU_SEM_MAPPEDFILE);
if (UNLIKELY(bu_debug&BU_DEBUG_MAPPED_FILE))
bu_pr_mapped_file("open_reused", mp);
return mp;
}
/* It is safe to reuse mp */
mp->uses++;
return mp;
}
/* done iterating over mapped file list */
bu_semaphore_release(BU_SEM_MAPPEDFILE);
/* necessary in case we take a 'fail' path before BU_ALLOC() */
mp = NULL;
/* File is not yet mapped or has changed, open file read only if
* we didn't find it earlier.
*/
#ifdef HAVE_SYS_STAT_H
if (fd < 0) {
bu_semaphore_acquire(BU_SEM_SYSCALL);
fd = open(real_path, O_RDONLY | O_BINARY);
bu_semaphore_release(BU_SEM_SYSCALL);
}
if (UNLIKELY(fd < 0)) {
if (UNLIKELY(bu_debug&BU_DEBUG_MAPPED_FILE))
perror(real_path);
goto fail;
}
bu_semaphore_acquire(BU_SEM_SYSCALL);
ret = fstat(fd, &sb);
bu_semaphore_release(BU_SEM_SYSCALL);
if (UNLIKELY(ret < 0)) {
perror(real_path);
goto fail;
}
if (UNLIKELY(sb.st_size == 0)) {
bu_log("bu_open_mapped_file(%s) 0-length file\n", real_path);
goto fail;
}
#endif /* HAVE_SYS_STAT_H */
/* Optimistically assume that things will proceed OK */
BU_ALLOC(mp, struct bu_mapped_file);
mp->name = bu_strdup(real_path);
if (appl) mp->appl = bu_strdup(appl);
#ifdef HAVE_SYS_STAT_H
mp->buflen = sb.st_size;
mp->modtime = sb.st_mtime;
# ifdef HAVE_SYS_MMAN_H
/* Attempt to access as memory-mapped file */
bu_semaphore_acquire(BU_SEM_SYSCALL);
mp->buf = mmap(NULL, sb.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
bu_semaphore_release(BU_SEM_SYSCALL);
if (UNLIKELY(mp->buf == MAP_FAILED))
perror(real_path);
if (mp->buf != MAP_FAILED) {
/* OK, its memory mapped in! */
mp->is_mapped = 1;
/* It's safe to close the fd now, the manuals say */
} else
# endif /* HAVE_SYS_MMAN_H */
{
/* Allocate a local zero'd buffer, and slurp it in always
* leaving space for a trailing zero.
*/
mp->buf = bu_calloc(1, sb.st_size+1, real_path);
nbytes = 0;
bytes_to_go = sb.st_size;
bu_semaphore_acquire(BU_SEM_SYSCALL);
while (nbytes < sb.st_size) {
readval = read(fd, ((char *)(mp->buf)) + nbytes, ((bytes_to_go > INT_MAX) ? (INT_MAX) : (bytes_to_go)));
if (UNLIKELY(readval < 0)) {
bu_semaphore_release(BU_SEM_SYSCALL);
perror(real_path);
bu_free(mp->buf, real_path);
goto fail;
} else {
nbytes += readval;
bytes_to_go -= readval;
}
}
bu_semaphore_release(BU_SEM_SYSCALL);
if (UNLIKELY(nbytes != sb.st_size)) {
perror(real_path);
bu_free(mp->buf, real_path);
goto fail;
}
}
#else /* !HAVE_SYS_STAT_H */
/* Read it in with stdio, with no clue how big it is */
bu_semaphore_acquire(BU_SEM_SYSCALL);
fp = fopen(real_path, "rb");
bu_semaphore_release(BU_SEM_SYSCALL);
if (UNLIKELY(fp == NULL)) {
perror(real_path);
goto fail;
}
/* Read it once to see how large it is */
{
char buf[32768] = {0};
int got;
mp->buflen = 0;
bu_semaphore_acquire(BU_SEM_SYSCALL);
while ((got = fread(buf, 1, sizeof(buf), fp)) > 0)
mp->buflen += got;
rewind(fp);
bu_semaphore_release(BU_SEM_SYSCALL);
}
/* Allocate the necessary buffer */
mp->buf = bu_calloc(1, mp->buflen+1, real_path);
/* Read it again into the buffer */
bu_semaphore_acquire(BU_SEM_SYSCALL);
ret = fread(mp->buf, mp->buflen, 1, fp);
bu_semaphore_release(BU_SEM_SYSCALL);
if (UNLIKELY(ret != 1)) {
bu_semaphore_acquire(BU_SEM_SYSCALL);
perror("fread");
fclose(fp);
bu_semaphore_release(BU_SEM_SYSCALL);
bu_log("bu_open_mapped_file() 2nd fread failed? len=%d\n", mp->buflen);
bu_free(mp->buf, "non-unix fread buf");
goto fail;
}
bu_semaphore_acquire(BU_SEM_SYSCALL);
fclose(fp);
bu_semaphore_release(BU_SEM_SYSCALL);
#endif
if (fd >= 0) {
bu_semaphore_acquire(BU_SEM_SYSCALL);
(void)close(fd);
bu_semaphore_release(BU_SEM_SYSCALL);
}
mp->uses = 1;
mp->l.magic = BU_MAPPED_FILE_MAGIC;
bu_semaphore_acquire(BU_SEM_MAPPEDFILE);
BU_LIST_APPEND(&bu_mapped_file_list, &mp->l);
bu_semaphore_release(BU_SEM_MAPPEDFILE);
if (UNLIKELY(bu_debug&BU_DEBUG_MAPPED_FILE)) {
bu_pr_mapped_file("1st_open", mp);
}
if (real_path) {
bu_free(real_path, "real_path alloc from bu_realpath");
}
return mp;
fail:
if (fd >= 0) {
bu_semaphore_acquire(BU_SEM_SYSCALL);
(void)close(fd);
bu_semaphore_release(BU_SEM_SYSCALL);
}
if (mp) {
bu_free(mp->name, "mp->name");
if (mp->appl) bu_free(mp->appl, "mp->appl");
/* Don't free mp->buf here, it might not be bu_malloced but mmaped */
bu_free(mp, "mp from bu_open_mapped_file fail");
}
if (UNLIKELY(bu_debug&BU_DEBUG_MAPPED_FILE))
bu_log("bu_open_mapped_file(%s, %s) can't open file\n",
real_path, appl ? appl: "(NIL)");
if (real_path) {
bu_free(real_path, "real_path alloc from bu_realpath");
}
return (struct bu_mapped_file *)NULL;
}
Usage: pix-fb [-a -h -i -c -z -1] [-m #lines] [-F framebuffer]\n\
[-s squarefilesize] [-w file_width] [-n file_height]\n\
[-x file_xoff] [-y file_yoff] [-X scr_xoff] [-Y scr_yoff]\n\
[-S squarescrsize] [-W scr_width] [-N scr_height] [-p seconds]\n\
[file.pix]\n";
int
get_args(int argc, char **argv)
{
int c;
while ((c = bu_getopt(argc, argv, "1m:ahiczF:p:s:w:n:x:y:X:Y:S:W:N:")) != -1) {
switch (c) {
case '1':
one_line_only = 1;
break;
case 'm':
multiple_lines = atoi(bu_optarg);
break;
case 'a':
autosize = 1;
break;
case 'h':
/* high-res */
file_height = file_width = 1024;
scr_height = scr_width = 1024;
autosize = 0;
break;
case 'i':
inverse = 1;
break;
case 'c':
clear = 1;
break;
case 'z':
zoom = 1;
break;
case 'F':
framebuffer = bu_optarg;
break;
case 's':
/* square file size */
file_height = file_width = atoi(bu_optarg);
autosize = 0;
break;
case 'w':
file_width = atoi(bu_optarg);
autosize = 0;
break;
case 'n':
file_height = atoi(bu_optarg);
autosize = 0;
break;
case 'x':
file_xoff = atoi(bu_optarg);
break;
case 'y':
file_yoff = atoi(bu_optarg);
break;
case 'X':
scr_xoff = atoi(bu_optarg);
break;
case 'Y':
scr_yoff = atoi(bu_optarg);
break;
case 'S':
scr_height = scr_width = atoi(bu_optarg);
break;
case 'W':
scr_width = atoi(bu_optarg);
break;
case 'N':
scr_height = atoi(bu_optarg);
break;
case 'p':
pause_sec=atoi(bu_optarg);
break;
default: /* '?' */
return 0;
}
}
if (bu_optind >= argc) {
if (isatty(fileno(stdin)))
return 0;
file_name = "-";
infd = 0;
} else {
char *ifname;
file_name = argv[bu_optind];
ifname = bu_realpath(file_name, NULL);
if ((infd = open(ifname, 0)) < 0) {
perror(ifname);
fprintf(stderr,
"pix-fb: cannot open \"%s(canonical %s)\" for reading\n",
file_name,ifname);
bu_free(ifname,"ifname alloc from bu_realpath");
bu_exit(1, NULL);
}
bu_free(ifname,"ifname alloc from bu_realpath");
#ifdef _WIN32
setmode(infd, O_BINARY);
#endif
fileinput++;
}
if (argc > ++bu_optind)
fprintf(stderr, "pix-fb: excess argument(s) ignored\n");
return 1; /* OK */
}
