/* Add ext to fnm, inserting an FNM_SEP_EXT if appropriate */
extern char *
add_ext(const char *fnm, const char *ext)
{
char * fnmNew;
int len, len_total;
#ifdef FNM_SEP_EXT
bool fAddSep = fFalse;
#endif
len = strlen(fnm);
len_total = len + strlen(ext) + 1;
#ifdef FNM_SEP_EXT
if (ext[0] != FNM_SEP_EXT) {
fAddSep = fTrue;
len_total++;
}
#endif
fnmNew = osmalloc(len_total);
strcpy(fnmNew, fnm);
#ifdef FNM_SEP_EXT
if (fAddSep) fnmNew[len++] = FNM_SEP_EXT;
#endif
strcpy(fnmNew + len, ext);
return fnmNew;
}
extern char *
path_from_fnm(const char *fnm)
{
char *pth;
const char *lf;
int lenpth = 0;
lf = strrchr(fnm, FNM_SEP_LEV);
#ifdef FNM_SEP_LEV2
{
const char *lf2 = strrchr(lf ? lf + 1 : fnm, FNM_SEP_LEV2);
if (lf2) lf = lf2;
}
#endif
#ifdef FNM_SEP_DRV
if (!lf) lf = strrchr(fnm, FNM_SEP_DRV);
#endif
if (lf) lenpth = lf - fnm + 1;
pth = osmalloc(lenpth + 1);
memcpy(pth, fnm, lenpth);
pth[lenpth] = '\0';
return pth;
}
/* Make fnm from pth and lf, inserting an FNM_SEP_LEV if appropriate */
extern char *
use_path(const char *pth, const char *lf)
{
char *fnm;
int len, len_total;
bool fAddSep = fFalse;
len = strlen(pth);
len_total = len + strlen(lf) + 1;
/* if there's a path and it doesn't end in a separator, insert one */
if (len && pth[len - 1] != FNM_SEP_LEV) {
#ifdef FNM_SEP_LEV2
if (pth[len - 1] != FNM_SEP_LEV2) {
#endif
#ifdef FNM_SEP_DRV
if (pth[len - 1] != FNM_SEP_DRV) {
#endif
fAddSep = fTrue;
len_total++;
#ifdef FNM_SEP_DRV
}
#endif
#ifdef FNM_SEP_LEV2
}
#endif
}
fnm = osmalloc(len_total);
strcpy(fnm, pth);
if (fAddSep) fnm[len++] = FNM_SEP_LEV;
strcpy(fnm + len, lf);
return fnm;
}
char *
osstrdup(const char *str)
{
char *p;
OSSIZE_T len;
len = strlen(str) + 1;
p = osmalloc(len);
memcpy(p, str, len);
return p;
}
static void
add_leg(point *fr, point *to, const char *prefix, int flags)
{
leg *l;
fr->order++;
to->order++;
l = osmalloc(ossizeof(leg));
l->fr = fr;
l->to = to;
if (prefix)
l->prefix = find_prefix(prefix);
else
l->prefix = NULL;
l->next = headleg.next;
l->dir = 0;
l->fDone = 0;
l->broken = 0;
l->flags = flags;
headleg.next = l;
}
static point *
find_point(const img_point *pt)
{
point *p;
for (p = headpoint.next; p != NULL; p = p->next) {
if (pt->x == p->p.x && pt->y == p->p.y && pt->z == p->p.z) {
return p;
}
}
p = osmalloc(ossizeof(point));
p->p = *pt;
p->stns = NULL;
p->order = 0;
p->dir = 0;
p->fDone = 0;
p->fBroken = 0;
p->next = headpoint.next;
headpoint.next = p;
return p;
}
extern char *
base_from_fnm(const char *fnm)
{
char *p;
p = strrchr(fnm, FNM_SEP_EXT);
/* Trim off any leaf extension, but dirs can have extensions too */
if (p && !strchr(p, FNM_SEP_LEV)
#ifdef FNM_SEP_LEV2
&& !strchr(p, FNM_SEP_LEV2)
#endif
) {
size_t len = (const char *)p - fnm;
p = osmalloc(len + 1);
memcpy(p, fnm, len);
p[len] = '\0';
return p;
}
return osstrdup(fnm);
}
static void
default_translate(settings *s)
{
int i;
short *t;
if (s->next && s->next->Translate == s->Translate) {
t = ((short*)osmalloc(ossizeof(short) * 257)) + 1;
memcpy(t - 1, s->Translate - 1, sizeof(short) * 257);
s->Translate = t;
}
/* SVX_ASSERT(EOF==-1);*/ /* important, since we rely on this */
t = s->Translate;
memset(t - 1, 0, sizeof(short) * 257);
for (i = '0'; i <= '9'; i++) t[i] = SPECIAL_NAMES;
for (i = 'A'; i <= 'Z'; i++) t[i] = SPECIAL_NAMES;
for (i = 'a'; i <= 'z'; i++) t[i] = SPECIAL_NAMES;
t['\t'] |= SPECIAL_BLANK;
t[' '] |= SPECIAL_BLANK;
t[','] |= SPECIAL_BLANK;
t[';'] |= SPECIAL_COMMENT;
t['\032'] |= SPECIAL_EOL; /* Ctrl-Z, so olde DOS text files are handled ok */
t[EOF] |= SPECIAL_EOL;
t['\n'] |= SPECIAL_EOL;
t['\r'] |= SPECIAL_EOL;
t['*'] |= SPECIAL_KEYWORD;
t['-'] |= SPECIAL_OMIT;
t['\\'] |= SPECIAL_ROOT;
t['.'] |= SPECIAL_SEPARATOR;
t['_'] |= SPECIAL_NAMES;
t['-'] |= SPECIAL_NAMES; /* Added in 0.97 prerelease 4 */
t['.'] |= SPECIAL_DECIMAL;
t['-'] |= SPECIAL_MINUS;
t['+'] |= SPECIAL_PLUS;
#if 0 /* FIXME */
t['{'] |= SPECIAL_OPEN;
t['}'] |= SPECIAL_CLOSE;
#endif
}
extern char *
baseleaf_from_fnm(const char *fnm)
{
const char *p;
char *q;
size_t len;
p = fnm;
q = strrchr(p, FNM_SEP_LEV);
if (q) p = q + 1;
#ifdef FNM_SEP_LEV2
q = strrchr(p, FNM_SEP_LEV2);
if (q) p = q + 1;
#endif
q = strrchr(p, FNM_SEP_EXT);
if (q) len = (const char *)q - p; else len = strlen(p);
q = osmalloc(len + 1);
memcpy(q, p, len);
q[len] = '\0';
return q;
}
static void
cmd_require(void)
{
const unsigned int version[] = {COMMAVERSION};
const unsigned int *ver = version;
filepos fp;
skipblanks();
get_pos(&fp);
while (1) {
int diff = *ver++ - read_uint();
if (diff > 0) break;
if (diff < 0) {
size_t i, len;
char *v;
filepos fp_tmp;
/* find end of version number */
while (isdigit(ch) || ch == '.') nextch();
get_pos(&fp_tmp);
len = (size_t)(fp_tmp.offset - fp.offset);
v = osmalloc(len + 1);
set_pos(&fp);
for (i = 0; i < len; i++) {
v[i] = ch;
nextch();
}
v[i] = '\0';
fatalerror_in_file(file.filename, file.line, /*Survex version %s or greater required to process this survey data.*/2, v);
}
if (ch != '.') break;
nextch();
if (!isdigit(ch) || ver == version + sizeof(version)) break;
}
/* skip rest of version number */
while (isdigit(ch) || ch == '.') nextch();
}
/* read token */
extern void
get_token(void)
{
int i = -1;
s_zero(&buffer);
osfree(ucbuffer);
skipblanks();
while (isalpha(ch)) {
s_catchar(&buffer, &buf_len, (char)ch);
nextch();
}
if (!buffer) s_catchar(&buffer, &buf_len, '\0');
ucbuffer = osmalloc(buf_len);
do {
i++;
ucbuffer[i] = toupper(buffer[i]);
} while (buffer[i]);
#if 0
printf("get_token() got “%s”\n", buffer);
#endif
}
static void
cmd_set(void)
{
static sztok chartab[] = {
{"BLANK", SPECIAL_BLANK },
/*FIXME {"CLOSE", SPECIAL_CLOSE }, */
{"COMMENT", SPECIAL_COMMENT },
{"DECIMAL", SPECIAL_DECIMAL },
{"EOL", SPECIAL_EOL }, /* EOL won't work well */
{"KEYWORD", SPECIAL_KEYWORD },
{"MINUS", SPECIAL_MINUS },
{"NAMES", SPECIAL_NAMES },
{"OMIT", SPECIAL_OMIT },
/*FIXME {"OPEN", SPECIAL_OPEN }, */
{"PLUS", SPECIAL_PLUS },
#ifndef NO_DEPRECATED
{"ROOT", SPECIAL_ROOT },
#endif
{"SEPARATOR", SPECIAL_SEPARATOR },
{NULL, SPECIAL_UNKNOWN }
};
int mask;
int i;
get_token();
mask = match_tok(chartab, TABSIZE(chartab));
if (mask == SPECIAL_UNKNOWN) {
file.lpos += strlen(buffer);
compile_error_skip(-/*Unknown character class “%s”*/42, buffer);
return;
}
#ifndef NO_DEPRECATED
if (mask == SPECIAL_ROOT) {
if (root_depr_count < 5) {
file.lpos += strlen(buffer);
compile_warning(-/*ROOT is deprecated*/25);
if (++root_depr_count == 5)
compile_warning(/*Further uses of this deprecated feature will not be reported*/95);
}
}
#endif
/* if we're currently using an inherited translation table, allocate a new
* table, and copy old one into it */
if (pcs->next && pcs->next->Translate == pcs->Translate) {
short *p;
p = ((short*)osmalloc(ossizeof(short) * 257)) + 1;
memcpy(p - 1, pcs->Translate - 1, sizeof(short) * 257);
pcs->Translate = p;
}
skipblanks();
/* clear this flag for all non-alphanums */
for (i = 0; i < 256; i++)
if (!isalnum(i)) pcs->Translate[i] &= ~mask;
/* now set this flag for all specified chars */
while (!isEol(ch)) {
if (!isalnum(ch)) {
pcs->Translate[ch] |= mask;
} else if (tolower(ch) == 'x') {
int hex;
filepos fp;
get_pos(&fp);
nextch();
if (!isxdigit(ch)) {
set_pos(&fp);
break;
}
hex = isdigit(ch) ? ch - '0' : tolower(ch) - 'a';
nextch();
if (!isxdigit(ch)) {
set_pos(&fp);
break;
}
hex = hex << 4 | (isdigit(ch) ? ch - '0' : tolower(ch) - 'a');
pcs->Translate[hex] |= mask;
} else {
break;
}
nextch();
}
}
/* if prefix is omitted: if PFX_OPT set return NULL, otherwise use longjmp */
extern prefix *
read_prefix(unsigned pfx_flags)
{
bool f_optional = !!(pfx_flags & PFX_OPT);
bool fSurvey = !!(pfx_flags & PFX_SURVEY);
bool fSuspectTypo = !!(pfx_flags & PFX_SUSPECT_TYPO);
prefix *back_ptr, *ptr;
char *name;
size_t name_len = 32;
size_t i;
bool fNew;
bool fImplicitPrefix = fTrue;
int depth = -1;
filepos fp_firstsep;
skipblanks();
#ifndef NO_DEPRECATED
if (isRoot(ch)) {
if (!(pfx_flags & PFX_ALLOW_ROOT)) {
compile_diagnostic(DIAG_ERR|DIAG_COL, /*ROOT is deprecated*/25);
LONGJMP(file.jbSkipLine);
}
if (root_depr_count < 5) {
compile_diagnostic(DIAG_WARN|DIAG_COL, /*ROOT is deprecated*/25);
if (++root_depr_count == 5)
compile_diagnostic(DIAG_WARN, /*Further uses of this deprecated feature will not be reported*/95);
}
nextch();
ptr = root;
if (!isNames(ch)) {
if (!isSep(ch)) return ptr;
/* Allow optional SEPARATOR after ROOT */
get_pos(&fp_firstsep);
nextch();
}
fImplicitPrefix = fFalse;
#else
if (0) {
#endif
} else {
if ((pfx_flags & PFX_ANON) &&
(isSep(ch) || (pcs->dash_for_anon_wall_station && ch == '-'))) {
int first_ch = ch;
filepos here;
get_pos(&here);
nextch();
if (isBlank(ch) || isEol(ch)) {
if (!isSep(first_ch))
goto anon_wall_station;
/* A single separator alone ('.' by default) is an anonymous
* station which is on a point inside the passage and implies
* the leg to it is a splay.
*/
if (TSTBIT(pcs->flags, FLAGS_ANON_ONE_END)) {
set_pos(&here);
compile_diagnostic(DIAG_ERR|DIAG_TOKEN, /*Can't have a leg between two anonymous stations*/3);
LONGJMP(file.jbSkipLine);
}
pcs->flags |= BIT(FLAGS_ANON_ONE_END) | BIT(FLAGS_IMPLICIT_SPLAY);
return new_anon_station();
}
if (isSep(first_ch) && ch == first_ch) {
nextch();
if (isBlank(ch) || isEol(ch)) {
/* A double separator ('..' by default) is an anonymous station
* which is on the wall and implies the leg to it is a splay.
*/
prefix * pfx;
anon_wall_station:
if (TSTBIT(pcs->flags, FLAGS_ANON_ONE_END)) {
set_pos(&here);
compile_diagnostic(DIAG_ERR|DIAG_TOKEN, /*Can't have a leg between two anonymous stations*/3);
LONGJMP(file.jbSkipLine);
}
pcs->flags |= BIT(FLAGS_ANON_ONE_END) | BIT(FLAGS_IMPLICIT_SPLAY);
pfx = new_anon_station();
pfx->sflags |= BIT(SFLAGS_WALL);
return pfx;
}
if (ch == first_ch) {
nextch();
if (isBlank(ch) || isEol(ch)) {
/* A triple separator ('...' by default) is an anonymous
* station, but otherwise not handled specially (e.g. for
* a single leg down an unexplored side passage to a station
* which isn't refindable).
*/
if (TSTBIT(pcs->flags, FLAGS_ANON_ONE_END)) {
set_pos(&here);
compile_diagnostic(DIAG_ERR|DIAG_TOKEN, /*Can't have a leg between two anonymous stations*/3);
LONGJMP(file.jbSkipLine);
}
pcs->flags |= BIT(FLAGS_ANON_ONE_END);
return new_anon_station();
}
}
}
set_pos(&here);
}
ptr = pcs->Prefix;
}
i = 0;
name = NULL;
do {
fNew = fFalse;
if (name == NULL) {
/* Need a new name buffer */
name = osmalloc(name_len);
}
/* i==0 iff this is the first pass */
if (i) {
i = 0;
nextch();
}
while (isNames(ch)) {
if (i < pcs->Truncate) {
/* truncate name */
name[i++] = (pcs->Case == LOWER ? tolower(ch) :
(pcs->Case == OFF ? ch : toupper(ch)));
if (i >= name_len) {
name_len = name_len + name_len;
name = osrealloc(name, name_len);
}
}
nextch();
}
if (isSep(ch)) {
fImplicitPrefix = fFalse;
get_pos(&fp_firstsep);
}
if (i == 0) {
osfree(name);
if (!f_optional) {
if (isEol(ch)) {
if (fSurvey) {
compile_diagnostic(DIAG_ERR|DIAG_COL, /*Expecting survey name*/89);
} else {
compile_diagnostic(DIAG_ERR|DIAG_COL, /*Expecting station name*/28);
}
} else {
/* TRANSLATORS: Here "station" is a survey station, not a train station. */
compile_diagnostic(DIAG_ERR|DIAG_COL, /*Character “%c” not allowed in station name (use *SET NAMES to set allowed characters)*/7, ch);
}
LONGJMP(file.jbSkipLine);
}
return (prefix *)NULL;
}
name[i++] = '\0';
back_ptr = ptr;
ptr = ptr->down;
if (ptr == NULL) {
/* Special case first time around at each level */
name = osrealloc(name, i);
ptr = osnew(prefix);
ptr->ident = name;
name = NULL;
ptr->right = ptr->down = NULL;
ptr->pos = NULL;
ptr->shape = 0;
ptr->stn = NULL;
ptr->up = back_ptr;
ptr->filename = file.filename;
ptr->line = file.line;
ptr->min_export = ptr->max_export = 0;
ptr->sflags = BIT(SFLAGS_SURVEY);
if (fSuspectTypo && !fImplicitPrefix)
ptr->sflags |= BIT(SFLAGS_SUSPECTTYPO);
back_ptr->down = ptr;
fNew = fTrue;
} else {
/* Use caching to speed up adding an increasing sequence to a
* large survey */
static prefix *cached_survey = NULL, *cached_station = NULL;
prefix *ptrPrev = NULL;
int cmp = 1; /* result of strcmp ( -ve for <, 0 for =, +ve for > ) */
if (cached_survey == back_ptr) {
cmp = strcmp(cached_station->ident, name);
if (cmp <= 0) ptr = cached_station;
}
while (ptr && (cmp = strcmp(ptr->ident, name))<0) {
ptrPrev = ptr;
ptr = ptr->right;
}
if (cmp) {
/* ie we got to one that was higher, or the end */
prefix *newptr;
name = osrealloc(name, i);
newptr = osnew(prefix);
newptr->ident = name;
name = NULL;
if (ptrPrev == NULL)
back_ptr->down = newptr;
else
ptrPrev->right = newptr;
newptr->right = ptr;
newptr->down = NULL;
newptr->pos = NULL;
newptr->shape = 0;
newptr->stn = NULL;
newptr->up = back_ptr;
newptr->filename = file.filename;
newptr->line = file.line;
newptr->min_export = newptr->max_export = 0;
newptr->sflags = BIT(SFLAGS_SURVEY);
if (fSuspectTypo && !fImplicitPrefix)
newptr->sflags |= BIT(SFLAGS_SUSPECTTYPO);
ptr = newptr;
fNew = fTrue;
}
cached_survey = back_ptr;
cached_station = ptr;
}
depth++;
f_optional = fFalse; /* disallow after first level */
if (isSep(ch)) get_pos(&fp_firstsep);
} while (isSep(ch));
if (name) osfree(name);
/* don't warn about a station that is referred to twice */
if (!fNew) ptr->sflags &= ~BIT(SFLAGS_SUSPECTTYPO);
if (fNew) {
/* fNew means SFLAGS_SURVEY is currently set */
SVX_ASSERT(TSTBIT(ptr->sflags, SFLAGS_SURVEY));
if (!fSurvey) {
ptr->sflags &= ~BIT(SFLAGS_SURVEY);
if (TSTBIT(pcs->infer, INFER_EXPORTS)) ptr->min_export = USHRT_MAX;
}
} else {
/* check that the same name isn't being used for a survey and station */
if (fSurvey ^ TSTBIT(ptr->sflags, SFLAGS_SURVEY)) {
/* TRANSLATORS: Here "station" is a survey station, not a train station.
*
* Here "survey" is a "cave map" rather than list of questions - it should be
* translated to the terminology that cavers using the language would use.
*/
compile_diagnostic(DIAG_ERR, /*“%s” can’t be both a station and a survey*/27,
sprint_prefix(ptr));
}
if (!fSurvey && TSTBIT(pcs->infer, INFER_EXPORTS)) ptr->min_export = USHRT_MAX;
}
/* check the export level */
#if 0
printf("R min %d max %d depth %d pfx %s\n",
ptr->min_export, ptr->max_export, depth, sprint_prefix(ptr));
#endif
if (ptr->min_export == 0 || ptr->min_export == USHRT_MAX) {
if (depth > ptr->max_export) ptr->max_export = depth;
} else if (ptr->max_export < depth) {
prefix *survey = ptr;
char *s;
const char *p;
int level;
for (level = ptr->max_export + 1; level; level--) {
survey = survey->up;
SVX_ASSERT(survey);
}
s = osstrdup(sprint_prefix(survey));
p = sprint_prefix(ptr);
if (survey->filename) {
compile_diagnostic_pfx(DIAG_ERR, survey,
/*Station “%s” not exported from survey “%s”*/26,
p, s);
} else {
compile_diagnostic(DIAG_ERR, /*Station “%s” not exported from survey “%s”*/26, p, s);
}
osfree(s);
#if 0
printf(" *** pfx %s warning not exported enough depth %d "
"ptr->max_export %d\n", sprint_prefix(ptr),
depth, ptr->max_export);
#endif
}
if (!fImplicitPrefix && (pfx_flags & PFX_WARN_SEPARATOR)) {
filepos fp_tmp;
get_pos(&fp_tmp);
set_pos(&fp_firstsep);
compile_diagnostic(DIAG_WARN|DIAG_COL, /*Separator in survey name*/392);
set_pos(&fp_tmp);
}
return ptr;
}
/* if numeric expr is omitted: if f_optional return HUGE_REAL, else longjmp */
static real
read_number(bool f_optional)
{
bool fPositive, fDigits = fFalse;
real n = (real)0.0;
filepos fp;
int ch_old;
get_pos(&fp);
ch_old = ch;
fPositive = !isMinus(ch);
if (isSign(ch)) nextch();
while (isdigit(ch)) {
n = n * (real)10.0 + (char)(ch - '0');
nextch();
fDigits = fTrue;
}
if (isDecimal(ch)) {
real mult = (real)1.0;
nextch();
while (isdigit(ch)) {
mult *= (real).1;
n += (char)(ch - '0') * mult;
fDigits = fTrue;
nextch();
}
}
/* !'fRead' => !fDigits so fDigits => 'fRead' */
if (fDigits) return (fPositive ? n : -n);
/* didn't read a valid number. If it's optional, reset filepos & return */
set_pos(&fp);
if (f_optional) {
return HUGE_REAL;
}
if (isOmit(ch_old)) {
compile_diagnostic(DIAG_ERR|DIAG_COL, /*Field may not be omitted*/8);
} else {
compile_diagnostic_token_show(DIAG_ERR, /*Expecting numeric field, found “%s”*/9);
}
LONGJMP(file.jbSkipLine);
return 0.0; /* for brain-fried compilers */
}
/*
* Parse a file
*/
int CTadsGameInfo::parse_file(osfildef *fp, unsigned long res_seek_pos,
unsigned long res_size)
{
/* find the tail of the existing list */
tads_valinfo *last_val;
for (last_val = first_val_ ; last_val != 0 && last_val->nxt != 0 ;
last_val = last_val->nxt) ;
/* we found the resource - seek to it in the file */
if (osfseek(fp, res_seek_pos, OSFSK_SET))
return FALSE;
/*
* Allocate a block of memory for loading the game information. The
* game information resource is typically fairly small, so for
* simplicity we'll just allocate a single block of memory and load
* the whole resource into the block. Allocate space for one extra
* byte, so that we can ensure we have a newline at the end of the
* buffer.
*/
buf_ = (char *)osmalloc(res_size + 1);
if (buf_ == 0)
return FALSE;
/* read the data */
if (osfrb(fp, buf_, res_size))
return FALSE;
/*
* store an extra newline at the end of the buffer, so that we can be
* certain that the last line ends in a newline - at worst, this will
* add an extra blank line to the end, but since we ignore blank lines
* this will do no harm
*/
buf_[res_size++] = '\n';
/* parse the data */
utf8_ptr p(buf_);
for (size_t rem = res_size ; rem != 0 ; )
{
/* skip any leading whitespace */
while (rem != 0 && is_space(p.getch()))
p.inc(&rem);
/* if the line starts with '#', it's a comment, so skip it */
if (rem != 0 && p.getch() == '#')
{
/* skip the entire line, and go back for the next one */
skip_to_next_line(&p, &rem);
continue;
}
/* we must have the start of a name - note it */
utf8_ptr name_start = p;
/* skip ahead to a space or colon */
while (rem != 0 && p.getch() != ':' && !is_hspace(p.getch()))
p.inc(&rem);
/* note the length of the name */
size_t name_len = p.getptr() - name_start.getptr();
/* skip any whitespace before the presumed colon */
while (rem != 0 && is_hspace(p.getch()))
p.inc(&rem);
/* if we're not at a colon, the line is ill-formed, so skip it */
if (rem == 0 || p.getch() != ':')
{
/* skip the entire line, and go back for the next one */
skip_to_next_line(&p, &rem);
continue;
}
/* skip the colon and any whitespace immediately after it */
for (p.inc(&rem) ; rem != 0 && is_hspace(p.getch()) ; p.inc(&rem)) ;
/*
* Whatever terminated the name, replace it with a null character
* - this is safe, since we at least have a colon character to
* replace, and we've already skipped it so we can overwrite it
* now. A null character in utf-8 is simply a single zero byte,
* so we can store our byte directly without worrying about any
* utf-8 multi-byte strangeness.
*/
*(name_start.getptr() + name_len) = '\0';
/* note where the value starts */
utf8_ptr val_start = p;
/* set up to write to the buffer at the current point */
utf8_ptr dst = p;
/*
* Now find the end of the value. The value can span multiple
* lines; if we find a newline followed by a space, it means that
* the next line is a continuation of the current value, and that
* the entire sequence of newlines and immediately following
* whitespace should be converted to a single space in the value.
*
* Note that we copy the transformed value directly over the old
* version of the value in the buffer. This is safe because the
* transformation can only remove characters - we merely collapse
* each newline-whitespace sequence into a single space.
*/
while (rem != 0)
{
/* get this character */
wchar_t ch = p.getch();
/* check for a newline */
if (is_vspace(ch))
{
/*
* it's a newline - skip it (and any other characters in
* the newline sequence)
*/
skip_newline(&p, &rem);
/*
* if there's no leading whitespace on the next line,
* we've reached the end of this value
*/
if (rem == 0 || !is_hspace(p.getch()))
{
/*
* no whitespace -> end of the value - stop scanning
* the value
*/
break;
}
/* skip leading whitespace on the line */
while (rem != 0 && is_hspace(p.getch()))
p.inc(&rem);
/*
* add a single whitespace character to the output for the
* entire sequence of the newline plus the leading
* whitespace on the line
*/
dst.setch(' ');
}
else if (ch == 0)
{
/* change null bytes to spaces */
dst.setch(' ');
/* skip this character */
p.inc(&rem);
}
else
{
/* it's not a newline - simply copy it out and keep going */
dst.setch(ch);
/* skip this character */
p.inc(&rem);
}
}
/*
* Store a null terminator at the end of the value (it's safe to
* write this to the buffer because at worst it'll overwrite the
* newline at the end of the last line, which we've already
* skipped in the source). Note that we obtain the length of the
* value string before storing the null terminator, because we
* don't want to count the null byte in the value's length.
*/
dst.setch('\0');
/*
* Create a new value list entry. Point the entry directly into
* our buffer, since we're keeping the buffer around as long as
* the value list is around.
*/
tads_valinfo *val_info =
(tads_valinfo *)osmalloc(sizeof(tads_valinfo));
val_info->name = name_start.getptr();
val_info->name_len = name_len;
val_info->val = store_value(val_start.getptr(),
dst.getptr() - val_start.getptr());
val_info->nxt = 0;
/* link the new value at the end of our list */
if (last_val != 0)
last_val->nxt = val_info;
else
first_val_ = val_info;
last_val = val_info;
}
/* success */
return TRUE;
}
int
main(int argc, char **argv)
{
const char *fnm_in, *fnm_out;
char *desc;
img_point pt;
int result;
point *fr = NULL, *to;
double zMax = -DBL_MAX;
point *p;
const char *survey = NULL;
const char *specfile = NULL;
img *pimg;
int have_xsect = 0;
msg_init(argv);
/* TRANSLATORS: Part of extend --help */
cmdline_set_syntax_message(/*INPUT_3D_FILE [OUTPUT_3D_FILE]*/267, 0, NULL);
cmdline_init(argc, argv, short_opts, long_opts, NULL, help, 1, 2);
while (1) {
int opt = cmdline_getopt();
if (opt == EOF) break;
if (opt == 's') survey = optarg;
if (opt == 'p') specfile = optarg;
}
fnm_in = argv[optind++];
if (argv[optind]) {
fnm_out = argv[optind];
} else {
char * base_in = base_from_fnm(fnm_in);
char * base_out = osmalloc(strlen(base_in) + 8);
strcpy(base_out, base_in);
strcat(base_out, "_extend");
fnm_out = add_ext(base_out, EXT_SVX_3D);
osfree(base_in);
osfree(base_out);
}
/* try to open image file, and check it has correct header */
pimg = img_open_survey(fnm_in, survey);
if (pimg == NULL) fatalerror(img_error2msg(img_error()), fnm_in);
putnl();
puts(msg(/*Reading in data - please wait…*/105));
htab = osmalloc(ossizeof(pfx*) * HTAB_SIZE);
{
int i;
for (i = 0; i < HTAB_SIZE; ++i) htab[i] = NULL;
}
do {
result = img_read_item(pimg, &pt);
switch (result) {
case img_MOVE:
fr = find_point(&pt);
break;
case img_LINE:
if (!fr) {
result = img_BAD;
break;
}
to = find_point(&pt);
if (!(pimg->flags & (img_FLAG_SURFACE|img_FLAG_SPLAY)))
add_leg(fr, to, pimg->label, pimg->flags);
fr = to;
break;
case img_LABEL:
to = find_point(&pt);
add_label(to, pimg->label, pimg->flags);
break;
case img_BAD:
(void)img_close(pimg);
fatalerror(img_error2msg(img_error()), fnm_in);
break;
case img_XSECT:
have_xsect = 1;
break;
}
} while (result != img_STOP);
desc = osstrdup(pimg->title);
if (specfile) {
FILE *fs = NULL;
char *fnm_used;
/* TRANSLATORS: for extend: */
printf(msg(/*Applying specfile: “%s”*/521), specfile);
putnl();
fs = fopenWithPthAndExt("", specfile, NULL, "r", &fnm_used);
if (fs == NULL) fatalerror(/*Couldn’t open file “%s”*/93, specfile);
while (!feof(fs)) {
char *lbuf = getline_alloc(fs, 32);
lineno++;
if (!lbuf)
fatalerror_in_file(fnm_used, lineno, /*Error reading file*/18);
parseconfigline(fnm_used, lbuf);
osfree(lbuf);
}
osfree(fnm_used);
}
if (start == NULL) { /* i.e. start wasn't specified in specfile */
/* start at the highest entrance with some legs attached */
for (p = headpoint.next; p != NULL; p = p->next) {
if (p->order > 0 && p->p.z > zMax) {
const stn *s;
for (s = p->stns; s; s = s->next) {
if (s->flags & img_SFLAG_ENTRANCE) {
start = p;
zMax = p->p.z;
break;
}
}
}
}
if (start == NULL) {
/* if no entrances with legs, start at the highest 1-node */
for (p = headpoint.next; p != NULL; p = p->next) {
if (p->order == 1 && p->p.z > zMax) {
start = p;
zMax = p->p.z;
}
}
/* of course we may have no 1-nodes... */
if (start == NULL) {
for (p = headpoint.next; p != NULL; p = p->next) {
if (p->order != 0 && p->p.z > zMax) {
start = p;
zMax = p->p.z;
}
}
if (start == NULL) {
/* There are no legs - just pick the highest station... */
for (p = headpoint.next; p != NULL; p = p->next) {
if (p->p.z > zMax) {
start = p;
zMax = p->p.z;
}
}
if (!start) fatalerror(/*No survey data*/43);
}
}
}
}
/* TRANSLATORS: for extend:
* Used to tell the user that a file is being written - %s is the filename
*/
printf(msg(/*Writing %s…*/522), fnm_out);
putnl();
pimg_out = img_open_write(fnm_out, desc, img_FFLAG_EXTENDED);
/* Only does single connected component currently. */
do_stn(start, 0.0, NULL, ERIGHT, 0);
if (have_xsect) {
img_rewind(pimg);
/* Read ahead on pimg before writing pimg_out so we find out if an
* img_XSECT_END comes next. */
char * label = NULL;
int flags = 0;
do {
result = img_read_item(pimg, &pt);
if (result == img_XSECT || result == img_XSECT_END) {
if (label) {
if (result == img_XSECT_END)
flags |= img_XFLAG_END;
img_write_item(pimg_out, img_XSECT, flags, label, 0, 0, 0);
osfree(label);
label = NULL;
}
}
if (result == img_XSECT) {
label = osstrdup(pimg->label);
flags = pimg->flags;
pimg_out->l = pimg->l;
pimg_out->r = pimg->r;
pimg_out->u = pimg->u;
pimg_out->d = pimg->d;
}
} while (result != img_STOP);
}
(void)img_close(pimg);
if (!img_close(pimg_out)) {
(void)remove(fnm_out);
fatalerror(img_error2msg(img_error()), fnm_out);
}
return EXIT_SUCCESS;
}
static void
parse_msg_file(int charset_code)
{
FILE *fh;
unsigned char header[20];
int i;
unsigned len;
unsigned char *p;
char *fnm, *s;
int n;
#ifdef DEBUG
fprintf(stderr, "parse_msg_file(%d)\n", charset_code);
#endif
/* sort out messages we need to print if we can't open the message file */
dontextract = parse_msgs(N_DONTEXTRACTMSGS, dontextractmsgs, charset_code);
fnm = osstrdup(msg_lang);
/* trim off charset from stuff like "de_DE.iso8859_1" */
s = strchr(fnm, '.');
if (s) *s = '\0';
/* trim off any "@<something>" modifier. */
s = strchr(fnm, '@');
if (s) *s = '\0';
fh = fopenWithPthAndExt(pth_cfg_files, fnm, EXT_SVX_MSG, "rb", NULL);
if (!fh && strlen(fnm) > 3 && fnm[2] == '_') {
/* e.g. if 'en_GB' is unknown, see if we know 'en' */
fnm[2] = '\0';
fh = fopenWithPthAndExt(pth_cfg_files, fnm, EXT_SVX_MSG, "rb", NULL);
if (!fh) fnm[2] = '_'; /* for error reporting */
}
if (!fh && !msg_lang_explicit) {
/* If msg_lang wasn't specified using environment variable SURVEXLANG,
* then default to 'en' if we don't find messages for language msg_lang.
*/
if (fnm[0] && fnm[1]) {
strcpy(fnm, "en");
} else {
osfree(fnm);
fnm = osstrdup("en");
}
fh = fopenWithPthAndExt(pth_cfg_files, fnm, EXT_SVX_MSG, "rb", NULL);
}
if (!fh) {
fatalerror(/*Can't open message file “%s” using path “%s”*/1000,
fnm, pth_cfg_files);
}
if (fread(header, 1, 20, fh) < 20 ||
memcmp(header, "Svx\nMsg\r\n\xfe\xff", 12) != 0) {
fatalerror(/*Problem with message file “%s”*/1001, fnm);
}
if (header[12] != 0)
fatalerror(/*I don't understand this message file version*/1002);
n = (header[14] << 8) | header[15];
len = 0;
for (i = 16; i < 20; i++) len = (len << 8) | header[i];
p = osmalloc(len);
if (fread(p, 1, len, fh) < len)
fatalerror(/*Message file truncated?*/1003);
fclose(fh);
#ifdef DEBUG
fprintf(stderr, "fnm = “%s”, n = %d, len = %d\n", fnm, n, len);
#endif
osfree(fnm);
msg_array = parse_msgs(n, p, charset_code);
num_msgs = n;
}
static void
cmd_data(void)
{
static sztok dtab[] = {
{"ALTITUDE", Dz },
{"BACKBEARING", BackComp },
{"BACKCLINO", BackClino }, /* alternative name */
{"BACKCOMPASS", BackComp }, /* alternative name */
{"BACKGRADIENT", BackClino },
{"BEARING", Comp },
{"CEILING", Up }, /* alternative name */
{"CLINO", Clino }, /* alternative name */
{"COMPASS", Comp }, /* alternative name */
{"COUNT", Count }, /* FrCount&ToCount in multiline */
{"DEPTH", Depth }, /* FrDepth&ToDepth in multiline */
{"DEPTHCHANGE", DepthChange },
{"DIRECTION", Dir },
{"DOWN", Down },
{"DX", Dx },
{"DY", Dy },
{"DZ", Dz },
{"EASTING", Dx },
{"FLOOR", Down }, /* alternative name */
{"FROM", Fr },
{"FROMCOUNT", FrCount },
{"FROMDEPTH", FrDepth },
{"GRADIENT", Clino },
{"IGNORE", Ignore },
{"IGNOREALL", IgnoreAll },
{"LEFT", Left },
{"LENGTH", Tape },
{"NEWLINE", Newline },
{"NORTHING", Dy },
{"RIGHT", Right },
{"STATION", Station }, /* Fr&To in multiline */
{"TAPE", Tape }, /* alternative name */
{"TO", To },
{"TOCOUNT", ToCount },
{"TODEPTH", ToDepth },
{"UP", Up },
{NULL, End }
};
#define MASK_stns BIT(Fr) | BIT(To) | BIT(Station)
#define MASK_tape BIT(Tape) | BIT(FrCount) | BIT(ToCount) | BIT(Count)
#define MASK_dpth BIT(FrDepth) | BIT(ToDepth) | BIT(Depth) | BIT(DepthChange)
#define MASK_comp BIT(Comp) | BIT(BackComp)
#define MASK_clin BIT(Clino) | BIT(BackClino)
#define MASK_NORMAL MASK_stns | BIT(Dir) | MASK_tape | MASK_comp | MASK_clin
#define MASK_DIVING MASK_stns | BIT(Dir) | MASK_tape | MASK_comp | MASK_dpth
#define MASK_CARTESIAN MASK_stns | BIT(Dx) | BIT(Dy) | BIT(Dz)
#define MASK_CYLPOLAR MASK_stns | BIT(Dir) | MASK_tape | MASK_comp | MASK_dpth
#define MASK_PASSAGE BIT(Station) | BIT(Left) | BIT(Right) | BIT(Up) | BIT(Down)
#define MASK_NOSURVEY MASK_stns
/* readings which may be given for each style */
static const unsigned long mask[] = {
MASK_NORMAL, MASK_DIVING, MASK_CARTESIAN, MASK_CYLPOLAR, MASK_NOSURVEY,
MASK_PASSAGE
};
/* readings which may be omitted for each style */
static const unsigned long mask_optional[] = {
BIT(Dir) | BIT(Clino) | BIT(BackClino),
BIT(Dir),
0,
BIT(Dir),
0,
0 /* BIT(Left) | BIT(Right) | BIT(Up) | BIT(Down), */
};
/* all valid readings */
static const unsigned long mask_all[] = {
MASK_NORMAL | BIT(Newline) | BIT(Ignore) | BIT(IgnoreAll) | BIT(End),
MASK_DIVING | BIT(Newline) | BIT(Ignore) | BIT(IgnoreAll) | BIT(End),
MASK_CARTESIAN | BIT(Newline) | BIT(Ignore) | BIT(IgnoreAll) | BIT(End),
MASK_CYLPOLAR | BIT(Newline) | BIT(Ignore) | BIT(IgnoreAll) | BIT(End),
MASK_NOSURVEY | BIT(Ignore) | BIT(IgnoreAll) | BIT(End),
MASK_PASSAGE | BIT(Ignore) | BIT(IgnoreAll) | BIT(End)
};
#define STYLE_DEFAULT -2
#define STYLE_UNKNOWN -1
static sztok styletab[] = {
{"CARTESIAN", STYLE_CARTESIAN },
{"CYLPOLAR", STYLE_CYLPOLAR },
{"DEFAULT", STYLE_DEFAULT },
{"DIVING", STYLE_DIVING },
{"NORMAL", STYLE_NORMAL },
{"NOSURVEY", STYLE_NOSURVEY },
{"PASSAGE", STYLE_PASSAGE },
{"TOPOFIL", STYLE_NORMAL },
{NULL, STYLE_UNKNOWN }
};
#define m_multi (BIT(Station) | BIT(Count) | BIT(Depth))
int style, k = 0, kMac;
reading *new_order, d;
unsigned long mUsed = 0;
char *style_name;
/* after a bad *data command ignore survey data until the next
* *data command to avoid an avalanche of errors */
pcs->style = STYLE_IGNORE;
kMac = 6; /* minimum for NORMAL style */
new_order = osmalloc(kMac * sizeof(reading));
get_token();
style = match_tok(styletab, TABSIZE(styletab));
if (style == STYLE_DEFAULT) {
default_style(pcs);
return;
}
if (style == STYLE_UNKNOWN) {
file.lpos += strlen(buffer);
compile_error_skip(-/*Data style “%s” unknown*/65, buffer);
return;
}
skipblanks();
#ifndef NO_DEPRECATED
/* Olde syntax had optional field for survey grade, so allow an omit
* but issue a warning about it */
if (isOmit(ch)) {
static int data_depr_count = 0;
if (data_depr_count < 5) {
file.lpos += strlen(buffer);
compile_warning(-/*“*data %s %c …” is deprecated - use “*data %s …” instead*/104,
buffer, ch, buffer);
if (++data_depr_count == 5)
compile_warning(/*Further uses of this deprecated feature will not be reported*/95);
}
nextch();
}
#endif
style_name = osstrdup(buffer);
do {
filepos fp;
get_pos(&fp);
get_token();
d = match_tok(dtab, TABSIZE(dtab));
/* only token allowed after IGNOREALL is NEWLINE */
if (k && new_order[k - 1] == IgnoreAll && d != Newline) {
set_pos(&fp);
break;
}
/* Note: an unknown token is reported as trailing garbage */
if (!TSTBIT(mask_all[style], d)) {
file.lpos += strlen(buffer);
compile_error_skip(-/*Reading “%s” not allowed in data style “%s”*/63,
buffer, style_name);
osfree(style_name);
osfree(new_order);
return;
}
if (TSTBIT(mUsed, Newline) && TSTBIT(m_multi, d)) {
/* e.g. "*data diving station newline tape depth compass" */
file.lpos += strlen(buffer);
compile_error_skip(-/*Reading “%s” must occur before NEWLINE*/225, buffer);
osfree(style_name);
osfree(new_order);
return;
}
/* Check for duplicates unless it's a special reading:
* IGNOREALL,IGNORE (duplicates allowed) ; END (not possible)
*/
if (!((BIT(Ignore) | BIT(End) | BIT(IgnoreAll)) & BIT(d))) {
if (TSTBIT(mUsed, d)) {
file.lpos += strlen(buffer);
compile_error_skip(-/*Duplicate reading “%s”*/67, buffer);
osfree(style_name);
osfree(new_order);
return;
} else {
/* Check for previously listed readings which are incompatible
* with this one - e.g. Count vs FrCount */
bool fBad = fFalse;
switch (d) {
case Station:
if (mUsed & (BIT(Fr) | BIT(To))) fBad = fTrue;
break;
case Fr: case To:
if (TSTBIT(mUsed, Station)) fBad = fTrue;
break;
case Count:
if (mUsed & (BIT(FrCount) | BIT(ToCount) | BIT(Tape)))
fBad = fTrue;
break;
case FrCount: case ToCount:
if (mUsed & (BIT(Count) | BIT(Tape)))
fBad = fTrue;
break;
case Depth:
if (mUsed & (BIT(FrDepth) | BIT(ToDepth) | BIT(DepthChange)))
fBad = fTrue;
break;
case FrDepth: case ToDepth:
if (mUsed & (BIT(Depth) | BIT(DepthChange))) fBad = fTrue;
break;
case DepthChange:
if (mUsed & (BIT(FrDepth) | BIT(ToDepth) | BIT(Depth)))
fBad = fTrue;
break;
case Newline:
if (mUsed & ~m_multi) {
/* e.g. "*data normal from to tape newline compass clino" */
file.lpos += strlen(buffer);
compile_error_skip(-/*NEWLINE can only be preceded by STATION, DEPTH, and COUNT*/226);
osfree(style_name);
osfree(new_order);
return;
}
if (k == 0) {
file.lpos += strlen(buffer);
compile_error_skip(-/*NEWLINE can’t be the first reading*/222);
osfree(style_name);
osfree(new_order);
return;
}
break;
default: /* avoid compiler warnings about unhandled enums */
break;
}
if (fBad) {
/* Not entirely happy with phrasing this... */
file.lpos += strlen(buffer);
compile_error_skip(-/*Reading “%s” duplicates previous reading(s)*/77,
buffer);
osfree(style_name);
osfree(new_order);
return;
}
mUsed |= BIT(d); /* used to catch duplicates */
}
}
if (k && new_order[k - 1] == IgnoreAll) {
SVX_ASSERT(d == Newline);
k--;
d = IgnoreAllAndNewLine;
}
if (k >= kMac) {
kMac = kMac * 2;
new_order = osrealloc(new_order, kMac * sizeof(reading));
}
new_order[k++] = d;
} while (d != End);
if (k >= 2 && new_order[k - 2] == Newline) {
file.lpos += strlen(buffer);
compile_error_skip(-/*NEWLINE can’t be the last reading*/223);
osfree(style_name);
osfree(new_order);
return;
}
if (style == STYLE_NOSURVEY) {
if (TSTBIT(mUsed, Station)) {
if (k >= kMac) {
kMac = kMac * 2;
new_order = osrealloc(new_order, kMac * sizeof(reading));
}
new_order[k - 1] = Newline;
new_order[k++] = End;
}
} else if (style == STYLE_PASSAGE) {
/* Station doesn't mean "multiline" for STYLE_PASSAGE. */
} else if (!TSTBIT(mUsed, Newline) && (m_multi & mUsed)) {
/* This is for when they write
* *data normal station tape compass clino
* (i.e. no newline, but interleaved readings)
*/
compile_error_skip(/*Interleaved readings, but no NEWLINE*/224);
osfree(style_name);
osfree(new_order);
return;
}
#if 0
printf("mUsed = 0x%x\n", mUsed);
#endif
/* Check the supplied readings form a sufficient set. */
if (style != STYLE_PASSAGE) {
if (mUsed & (BIT(Fr) | BIT(To)))
mUsed |= BIT(Station);
else if (TSTBIT(mUsed, Station))
mUsed |= BIT(Fr) | BIT(To);
}
if (mUsed & (BIT(Comp) | BIT(BackComp)))
mUsed |= BIT(Comp) | BIT(BackComp);
if (mUsed & (BIT(Clino) | BIT(BackClino)))
mUsed |= BIT(Clino) | BIT(BackClino);
if (mUsed & (BIT(FrDepth) | BIT(ToDepth)))
mUsed |= BIT(Depth) | BIT(DepthChange);
else if (TSTBIT(mUsed, Depth))
mUsed |= BIT(FrDepth) | BIT(ToDepth) | BIT(DepthChange);
else if (TSTBIT(mUsed, DepthChange))
mUsed |= BIT(FrDepth) | BIT(ToDepth) | BIT(Depth);
if (mUsed & (BIT(FrCount) | BIT(ToCount)))
mUsed |= BIT(Count) | BIT(Tape);
else if (TSTBIT(mUsed, Count))
mUsed |= BIT(FrCount) | BIT(ToCount) | BIT(Tape);
else if (TSTBIT(mUsed, Tape))
mUsed |= BIT(FrCount) | BIT(ToCount) | BIT(Count);
#if 0
printf("mUsed = 0x%x, opt = 0x%x, mask = 0x%x\n", mUsed,
mask_optional[style], mask[style]);
#endif
if (((mUsed &~ BIT(Newline)) | mask_optional[style]) != mask[style]) {
/* Test should only fail with too few bits set, not too many */
SVX_ASSERT((((mUsed &~ BIT(Newline)) | mask_optional[style])
&~ mask[style]) == 0);
compile_error_skip(/*Too few readings for data style “%s”*/64, style_name);
osfree(style_name);
osfree(new_order);
return;
}
/* don't free default ordering or ordering used by parent */
if (pcs->ordering != default_order &&
!(pcs->next && pcs->next->ordering == pcs->ordering))
osfree(pcs->ordering);
pcs->style = style;
pcs->ordering = new_order;
osfree(style_name);
if (style == STYLE_PASSAGE) {
lrudlist * new_psg = osnew(lrudlist);
new_psg->tube = NULL;
new_psg->next = model;
model = new_psg;
next_lrud = &(new_psg->tube);
}
}
extern CDECL int
main(int argc, char **argv)
{
int d;
time_t tmUserStart = time(NULL);
clock_t tmCPUStart = clock();
{
/* FIXME: localtime? */
struct tm * t = localtime(&tmUserStart);
int y = t->tm_year + 1900;
current_days_since_1900 = days_since_1900(y, t->tm_mon + 1, t->tm_mday);
}
/* Always buffer by line for aven's benefit. */
setvbuf(stdout, NULL, _IOLBF, 0);
msg_init(argv);
#if OS_WIN32 || OS_UNIX_MACOSX
pj_set_finder(msg_proj_finder);
#endif
pcs = osnew(settings);
pcs->next = NULL;
pcs->Translate = ((short*) osmalloc(ossizeof(short) * 257)) + 1;
pcs->meta = NULL;
pcs->proj = NULL;
pcs->declination = HUGE_REAL;
pcs->convergence = 0.0;
/* Set up root of prefix hierarchy */
root = osnew(prefix);
root->up = root->right = root->down = NULL;
root->stn = NULL;
root->pos = NULL;
root->ident = NULL;
root->min_export = root->max_export = 0;
root->sflags = BIT(SFLAGS_SURVEY);
root->filename = NULL;
nosurveyhead = NULL;
stnlist = NULL;
cLegs = cStns = cComponents = 0;
totadj = total = totplan = totvert = 0.0;
for (d = 0; d <= 2; d++) {
min[d] = HUGE_REAL;
max[d] = -HUGE_REAL;
pfxHi[d] = pfxLo[d] = NULL;
}
/* at least one argument must be given */
cmdline_init(argc, argv, short_opts, long_opts, NULL, help, 1, -1);
while (1) {
int opt = cmdline_getopt();
if (opt == EOF) break;
switch (opt) {
case 'p':
/* Ignore for compatibility with older versions. */
break;
case 'o': {
osfree(fnm_output_base); /* in case of multiple -o options */
/* can be a directory (in which case use basename of leaf input)
* or a file (in which case just trim the extension off) */
if (fDirectory(optarg)) {
/* this is a little tricky - we need to note the path here,
* and then add the leaf later on (in datain.c) */
fnm_output_base = base_from_fnm(optarg);
fnm_output_base_is_dir = 1;
} else {
fnm_output_base = base_from_fnm(optarg);
}
break;
}
case 'q':
if (fQuiet) fMute = 1;
fQuiet = 1;
break;
case 's':
fSuppress = 1;
break;
case 'v': {
int v = atoi(optarg);
if (v < IMG_VERSION_MIN || v > IMG_VERSION_MAX)
fatalerror(/*3d file format versions %d to %d supported*/88,
IMG_VERSION_MIN, IMG_VERSION_MAX);
img_output_version = v;
break;
}
case 'w':
f_warnings_are_errors = 1;
break;
case 'z': {
/* Control which network optimisations are used (development tool) */
static int first_opt_z = 1;
char c;
if (first_opt_z) {
optimize = 0;
first_opt_z = 0;
}
/* Lollipops, Parallel legs, Iterate mx, Delta* */
while ((c = *optarg++) != '\0')
if (islower((unsigned char)c)) optimize |= BITA(c);
break;
case 1:
fLog = fTrue;
break;
#if OS_WIN32
case 2:
atexit(pause_on_exit);
break;
#endif
}
}
}
if (fLog) {
char *fnm;
if (!fnm_output_base) {
char *p;
p = baseleaf_from_fnm(argv[optind]);
fnm = add_ext(p, EXT_LOG);
osfree(p);
} else if (fnm_output_base_is_dir) {
char *p;
fnm = baseleaf_from_fnm(argv[optind]);
p = use_path(fnm_output_base, fnm);
osfree(fnm);
fnm = add_ext(p, EXT_LOG);
osfree(p);
} else {
fnm = add_ext(fnm_output_base, EXT_LOG);
}
if (!freopen(fnm, "w", stdout))
fatalerror(/*Failed to open output file “%s”*/47, fnm);
osfree(fnm);
}
if (!fMute) {
const char *p = COPYRIGHT_MSG;
puts(PRETTYPACKAGE" "VERSION);
while (1) {
const char *q = p;
p = strstr(p, "(C)");
if (p == NULL) {
puts(q);
break;
}
fwrite(q, 1, p - q, stdout);
fputs(msg(/*©*/0), stdout);
p += 3;
}
}
atexit(delete_output_on_error);
/* end of options, now process data files */
while (argv[optind]) {
const char *fnm = argv[optind];
if (!fExplicitTitle) {
char *lf;
lf = baseleaf_from_fnm(fnm);
if (survey_title) s_catchar(&survey_title, &survey_title_len, ' ');
s_cat(&survey_title, &survey_title_len, lf);
osfree(lf);
}
/* Select defaults settings */
default_all(pcs);
data_file(NULL, fnm); /* first argument is current path */
optind++;
}
validate();
solve_network(/*stnlist*/); /* Find coordinates of all points */
validate();
/* close .3d file */
if (!img_close(pimg)) {
char *fnm = add_ext(fnm_output_base, EXT_SVX_3D);
fatalerror(img_error2msg(img_error()), fnm);
}
if (fhErrStat) safe_fclose(fhErrStat);
out_current_action(msg(/*Calculating statistics*/120));
if (!fMute) do_stats();
if (!fQuiet) {
/* clock() typically wraps after 72 minutes, but there doesn't seem
* to be a better way. Still 72 minutes means some cave!
* We detect if clock() could have wrapped and suppress CPU time
* printing in this case.
*/
double tmUser = difftime(time(NULL), tmUserStart);
double tmCPU;
clock_t now = clock();
#define CLOCK_T_WRAP \
(sizeof(clock_t)<sizeof(long)?(1ul << (CHAR_BIT * sizeof(clock_t))):0)
tmCPU = (now - (unsigned long)tmCPUStart)
/ (double)CLOCKS_PER_SEC;
if (now < tmCPUStart)
tmCPU += CLOCK_T_WRAP / (double)CLOCKS_PER_SEC;
if (tmUser >= tmCPU + CLOCK_T_WRAP / (double)CLOCKS_PER_SEC)
tmCPU = 0;
/* tmUser is integer, tmCPU not - equivalent to (ceil(tmCPU) >= tmUser) */
if (tmCPU + 1 > tmUser) {
printf(msg(/*CPU time used %5.2fs*/140), tmCPU);
} else if (tmCPU == 0) {
if (tmUser != 0.0) {
printf(msg(/*Time used %5.2fs*/141), tmUser);
} else {
fputs(msg(/*Time used unavailable*/142), stdout);
}
} else {
printf(msg(/*Time used %5.2fs (%5.2fs CPU time)*/143), tmUser, tmCPU);
}
putnl();
}
if (msg_warnings || msg_errors) {
if (msg_errors || (f_warnings_are_errors && msg_warnings)) {
printf(msg(/*There were %d warning(s) and %d error(s) - no output files produced.*/113),
msg_warnings, msg_errors);
putnl();
return EXIT_FAILURE;
}
printf(msg(/*There were %d warning(s).*/16), msg_warnings);
putnl();
}
return EXIT_SUCCESS;
}
extern void
articulate(void)
{
node *stn, *stnStart;
int i;
long cFixed;
component_list = NULL;
articulation_list = NULL;
artlist = NULL;
fixedlist = NULL;
/* find articulation points and components */
colour = 0;
stnStart = NULL;
cMaxVisits = 0;
FOR_EACH_STN(stn, stnlist) {
if (fixed(stn)) {
remove_stn_from_list(&stnlist, stn);
add_stn_to_list(&fixedlist, stn);
colour++;
stn->colour = -colour;
#ifdef DEBUG_ARTIC
printf("Putting stn ");
print_prefix(stn->name);
printf(" on fixedlist\n");
#endif
} else {
cMaxVisits++;
stn->colour = 0;
}
}
dirn_stack = osmalloc(cMaxVisits);
min_stack = osmalloc(cMaxVisits * sizeof(long));
/* fixedlist can be NULL here if we've had a *solve followed by survey
* which is all hanging. */
cFixed = colour;
while (fixedlist) {
int c;
stnStart = fixedlist;
stn = stnStart;
/* see if this is a fresh component - it may not be, we may be
* processing the other way from a fixed point cut-line */
if (stn->colour < 0) {
#ifdef DEBUG_ARTIC
printf("new component\n");
#endif
stn->colour = -stn->colour; /* fixed points are negative until we colour from them */
cComponents++;
/* FIXME: logic to count components isn't the same as the logic
* to start a new one - we should start a new one for a fixed point
* cut-line (see below) */
if (artlist) {
component *comp;
articulation *art;
art = osnew(articulation);
art->stnlist = artlist;
art->next = articulation_list;
articulation_list = art;
artlist = NULL;
comp = osnew(component);
comp->next = component_list;
comp->artic = articulation_list;
component_list = comp;
articulation_list = NULL;
}
#ifdef DEBUG_ARTIC
print_prefix(stn->name);
printf(" [%p] is root of component %ld\n", stn, cComponents);
printf(" and colour = %d/%d\n", stn->colour, cFixed);
#endif
}
c = 0;
for (i = 0; i <= 2 && stn->leg[i]; i++) {
node *stn2 = stn->leg[i]->l.to;
if (stn2->colour < 0) {
stn2->colour = -stn2->colour;
} else if (stn2->colour == 0) {
/* Special case to check if start station is an articulation point
* which it is iff we have to colour from it in more than one dirn
*
* We're looking for articulation legs - these are those where
* colouring from here doesn't reach a fixed point (including
* stn - the fixed point we've started from)
*
* FIXME: this is a "fixed point cut-line" case where we could
* start a new component.
*/
long col = visit(stn2, reverse_leg_dirn(stn->leg[i]));
#ifdef DEBUG_ARTIC
print_prefix(stn->name);
printf(" -> ");
print_prefix(stn2->name);
printf(" col %d cFixed %d\n", col, cFixed);
#endif
if (col > cFixed) {
/* start new articulation - FIXME - overeager */
articulation *art = osnew(articulation);
art->stnlist = artlist;
art->next = articulation_list;
articulation_list = art;
artlist = NULL;
c |= 1 << i;
}
}
}
switch (c) {
/* had to colour in 2 or 3 directions from start point */
case 3: case 5: case 6: case 7:
#ifdef DEBUG_ARTIC
print_prefix(stn->name);
printf(" is a special case start articulation point [%d]\n", c);
#endif
for (i = 0; i <= 2 && stn->leg[i]; i++) {
if (TSTBIT(c, i)) {
/* flag leg as an articulation for loop error reporting */
stn->leg[i]->l.reverse |= FLAG_ARTICULATION;
#ifdef DEBUG_ARTIC
print_prefix(stn->leg[i]->l.to->name);
putnl();
#endif
reverse_leg(stn->leg[i])->l.reverse |= FLAG_ARTICULATION;
}
}
}
#ifdef DEBUG_ARTIC
printf("Putting FIXED stn ");
print_prefix(stn->name);
printf(" on artlist\n");
#endif
remove_stn_from_list(&fixedlist, stn);
add_stn_to_list(&artlist, stn);
if (stnStart->colour == 1) {
#ifdef DEBUG_ARTIC
printf("%ld components\n",cComponents);
#endif
break;
}
}
osfree(dirn_stack);
dirn_stack = NULL;
osfree(min_stack);
min_stack = NULL;
if (artlist) {
articulation *art = osnew(articulation);
art->stnlist = artlist;
art->next = articulation_list;
articulation_list = art;
artlist = NULL;
}
if (articulation_list) {
component *comp = osnew(component);
comp->next = component_list;
comp->artic = articulation_list;
component_list = comp;
articulation_list = NULL;
}
if (stnlist) {
/* Any stations still in stnlist are unfixed, which is means we have
* one or more hanging surveys.
*
* The cause of the problem is pretty likely to be a typo, so run the
* checks which report errors and warnings about issues which such a
* typo is likely to result in.
*/
check_node_stats();
/* Actually this error is fatal, but we want to list the survey
* stations which aren't connected, so we report it as an error
* and die after listing them...
*/
bool fNotAttached = fFalse;
error(/*Survey not all connected to fixed stations*/45);
FOR_EACH_STN(stn, stnlist) {
/* Anonymous stations must be at the end of a trailing traverse (since
* the same anonymous station can't be referred to more than once),
* and trailing traverses have been removed at this point.
*/
SVX_ASSERT(!TSTBIT(stn->name->sflags, SFLAGS_ANON));
if (stn->name->ident) {
if (!fNotAttached) {
fNotAttached = fTrue;
puts(msg(/*The following survey stations are not attached to a fixed point:*/71));
}
puts(sprint_prefix(stn->name));
}
}
exit(EXIT_FAILURE);
}
