static void add_label(point *p, const char *label, int flags) { stn *s = osnew(stn); s->label = osstrdup(label); s->flags = flags; s->next = p->stns; p->stns = s; }
static void tree_insert(const char *name, const img_point *pt) { int v = hash_string(name) & (TREE_SIZE - 1); station * stn = osnew(station); stn->name = osstrdup(name); stn->pt = *pt; stn->next = htab[v]; htab[v] = stn; }
static void filename_register_output_with_fh(const char *fnm, FILE *fh) { filelist *p = osnew(filelist); SVX_ASSERT(fnm); p->fnm = osstrdup(fnm); p->fh = fh; p->next = flhead; flhead = p; }
void filename_register_output(const char *fnm) { filelist *p = osnew(filelist); SVX_ASSERT(fnm); p->fnm = osstrdup(fnm); p->fh = NULL; p->next = flhead; flhead = p; }
static void tree_remove(const char *name, const img_point *pt) { /* We need to handle duplicate labels - normal .3d files shouldn't have them * (though some older ones do due to a couple of bugs in earlier versions of * Survex) but extended .3d files repeat the label where a loop is broken, * and data read from foreign formats might repeat labels. */ int v = hash_string(name) & (TREE_SIZE - 1); station **prev; station *p; station **found = NULL; bool was_close_enough = fFalse; for (prev = &htab[v]; *prev; prev = &((*prev)->next)) { if (strcmp((*prev)->name, name) == 0) { /* Handle stations with the same name. Stations are inserted at the * start of the linked list, so pick the *last* matching station in * the list as then we match the first stations with the same name in * each file. */ if (close_enough(pt, &((*prev)->pt))) { found = prev; was_close_enough = fTrue; } else if (!was_close_enough) { found = prev; } } } if (!found) { added *add = osnew(added); add->name = osstrdup(name); add->next = added_list; added_list = add; c_added++; fChanged = fTrue; return; } if (!was_close_enough) { printf(msg(/*Moved by (%3.2f,%3.2f,%3.2f): %s*/500), pt->x - (*found)->pt.x, pt->y - (*found)->pt.y, pt->z - (*found)->pt.z, name); putnl(); fChanged = fTrue; } osfree((*found)->name); p = *found; *found = p->next; osfree(p); }
/* allocate new meta_data if need be */ void copy_on_write_meta(settings *s) { if (!s->meta || s->meta->ref_count != 0) { meta_data * meta_new = osnew(meta_data); if (!s->meta) { meta_new->days1 = meta_new->days2 = -1; } else { *meta_new = *(s->meta); } meta_new->ref_count = 0; s->meta = meta_new; } }
static prefix * new_anon_station(void) { prefix *name = osnew(prefix); name->pos = NULL; name->ident = NULL; name->shape = 0; name->stn = NULL; name->up = pcs->Prefix; name->down = NULL; name->filename = file.filename; name->line = file.line; name->min_export = name->max_export = 0; name->sflags = BIT(SFLAGS_ANON); /* Keep linked list of anon stations for node stats. */ name->right = anon_list; anon_list = name; return name; }
static void cmd_begin(void) { prefix *tag; settings *pcsNew; pcsNew = osnew(settings); *pcsNew = *pcs; /* copy contents */ pcsNew->begin_lineno = file.line; pcsNew->next = pcs; pcs = pcsNew; tag = read_prefix(PFX_SURVEY|PFX_OPT|PFX_ALLOW_ROOT|PFX_WARN_SEPARATOR); pcs->tag = tag; if (tag) { pcs->Prefix = tag; check_reentry(tag); f_export_ok = fTrue; } }
static const char * find_prefix(const char *prefix) { pfx *p; int hash; SVX_ASSERT(prefix); hash = hash_string(prefix) & (HTAB_SIZE - 1); for (p = htab[hash]; p; p = p->next) { if (strcmp(prefix, p->label) == 0) return p->label; } p = osnew(pfx); p->label = osstrdup(prefix); p->next = htab[hash]; htab[hash] = p; return p->label; }
int select_charset(int charset_code) { int old_charset = charset; charset_li *p; #ifdef DEBUG fprintf(stderr, "select_charset(%d), old charset = %d\n", charset_code, charset); #endif charset = charset_code; /* check if we've already parsed messages for new charset */ for (p = charset_head; p; p = p->next) { #ifdef DEBUG printf("%p: code %d msg_array %p\n", p, p->code, p->msg_array); #endif if (p->code == charset) { msg_array = p->msg_array; return old_charset; } } /* nope, got to reparse message file */ parse_msg_file(charset_code); /* add to list */ p = osnew(charset_li); p->code = charset; p->msg_array = msg_array; p->next = charset_head; charset_head = p; return old_charset; }
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; }
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); } }
static void cmd_fix(void) { prefix *fix_name; node *stn = NULL; static node *stnOmitAlready = NULL; real x, y, z; int nx, ny, nz; filepos fp; fix_name = read_prefix(PFX_STATION|PFX_ALLOW_ROOT); fix_name->sflags |= BIT(SFLAGS_FIXED); get_pos(&fp); get_token(); if (strcmp(ucbuffer, "REFERENCE") == 0) { /* suppress "unused fixed point" warnings for this station */ fix_name->sflags |= BIT(SFLAGS_USED); } else { if (*ucbuffer) set_pos(&fp); } x = read_numeric(fTrue, &nx); if (x == HUGE_REAL) { /* If the end of the line isn't blank, read a number after all to * get a more helpful error message */ if (!isEol(ch) && !isComm(ch)) x = read_numeric(fFalse, &nx); } if (x == HUGE_REAL) { if (stnOmitAlready) { if (fix_name != stnOmitAlready->name) { compile_error_skip(/*More than one FIX command with no coordinates*/56); } else { compile_warning(/*Same station fixed twice with no coordinates*/61); } return; } stn = StnFromPfx(fix_name); compile_warning(/*FIX command with no coordinates - fixing at (0,0,0)*/54); x = y = z = (real)0.0; stnOmitAlready = stn; } else { real sdx; y = read_numeric(fFalse, &ny); z = read_numeric(fFalse, &nz); sdx = read_numeric(fTrue, NULL); if (sdx != HUGE_REAL) { real sdy, sdz; real cxy = 0, cyz = 0, czx = 0; sdy = read_numeric(fTrue, NULL); if (sdy == HUGE_REAL) { /* only one variance given */ sdy = sdz = sdx; } else { sdz = read_numeric(fTrue, NULL); if (sdz == HUGE_REAL) { /* two variances given - horizontal & vertical */ sdz = sdy; sdy = sdx; } else { cxy = read_numeric(fTrue, NULL); if (cxy != HUGE_REAL) { /* covariances given */ cyz = read_numeric(fFalse, NULL); czx = read_numeric(fFalse, NULL); } else { cxy = 0; } } } stn = StnFromPfx(fix_name); if (!fixed(stn)) { node *fixpt = osnew(node); prefix *name; name = osnew(prefix); name->pos = osnew(pos); name->ident = NULL; name->shape = 0; fixpt->name = name; name->stn = fixpt; name->up = NULL; if (TSTBIT(pcs->infer, INFER_EXPORTS)) { name->min_export = USHRT_MAX; } else { name->min_export = 0; } name->max_export = 0; name->sflags = 0; add_stn_to_list(&stnlist, fixpt); POS(fixpt, 0) = x; POS(fixpt, 1) = y; POS(fixpt, 2) = z; fix(fixpt); fixpt->leg[0] = fixpt->leg[1] = fixpt->leg[2] = NULL; addfakeleg(fixpt, stn, 0, 0, 0, sdx * sdx, sdy * sdy, sdz * sdz #ifndef NO_COVARIANCES , cxy, cyz, czx #endif ); } return; } stn = StnFromPfx(fix_name); } if (!fixed(stn)) { POS(stn, 0) = x; POS(stn, 1) = y; POS(stn, 2) = z; fix(stn); return; } if (x != POS(stn, 0) || y != POS(stn, 1) || z != POS(stn, 2)) { compile_error(/*Station already fixed or equated to a fixed point*/46); return; } compile_warning(/*Station already fixed at the same coordinates*/55); }
/* 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 */ }
static unsigned long visit(node *stn, int back) { long min_colour; int i; unsigned long tos = 0; SVX_ASSERT(dirn_stack && min_stack); #ifdef DEBUG_ARTIC printf("visit(%p, %d) called\n", stn, back); #endif iter: min_colour = stn->colour = ++colour; #ifdef DEBUG_ARTIC printf("visit: stn [%p] ", stn); print_prefix(stn->name); printf(" set to colour %ld -> min\n", colour); #endif for (i = 0; i <= 2 && stn->leg[i]; i++) { if (i != back) { node *to = stn->leg[i]->l.to; long col = to->colour; if (col == 0) { SVX_ASSERT(tos < cMaxVisits); dirn_stack[tos] = back; min_stack[tos] = min_colour; tos++; back = reverse_leg_dirn(stn->leg[i]); stn = to; goto iter; uniter: SVX_ASSERT(tos > 0); --tos; i = reverse_leg_dirn(stn->leg[back]); to = stn; stn = to->leg[back]->l.to; back = dirn_stack[tos]; if (min_stack[tos] < min_colour) min_colour = min_stack[tos]; #ifdef DEBUG_ARTIC printf("unwind: stn [%p] ", stn); print_prefix(stn->name); printf(" colour %d, min %d, station after %d\n", stn->colour, min_colour, to->colour); printf("Putting stn "); print_prefix(to->name); printf(" on artlist\n"); #endif remove_stn_from_list(&stnlist, to); add_stn_to_list(&artlist, to); if (to->colour <= min_colour) { articulation *art; min_colour = to->colour; /* FIXME: note down leg (<-), remove and replace: * /\ / /\ * [fixed point(s)] *-* -> [..] ) * \/ \ \/ * stn to */ /* flag leg as an articulation for loop error reporting */ to->leg[dirn_stack[tos]]->l.reverse |= FLAG_ARTICULATION; stn->leg[i]->l.reverse |= FLAG_ARTICULATION; /* start new articulation */ art = osnew(articulation); art->stnlist = artlist; art->next = articulation_list; articulation_list = art; artlist = NULL; #ifdef DEBUG_ARTIC printf("Articulate *-"); print_prefix(stn->name); printf("-"); print_prefix(to->name); printf("-...\n"); #endif } } else { /* back edge case */ if (col < 0) { /* we've found a fixed point */ col = -col; to->colour = col; #if 0 /* Removing this solves Graham Mullan's problem and makes more * sense since it means we'll recheck this point for further * legs. */ #ifdef DEBUG_ARTIC printf("Putting FOUND FIXED stn "); print_prefix(to->name); printf(" on artlist\n"); #endif remove_stn_from_list(&fixedlist, to); add_stn_to_list(&artlist, to); #endif } if (col < min_colour) min_colour = col; } } } SVX_ASSERT(!stn->leg[0] || stn->leg[0]->l.to->colour > 0); SVX_ASSERT(!stn->leg[1] || stn->leg[1]->l.to->colour > 0); SVX_ASSERT(!stn->leg[2] || stn->leg[2]->l.to->colour > 0); if (tos > 0) goto uniter; #ifdef DEBUG_ARTIC printf("Putting stn "); print_prefix(stn->name); printf(" on artlist\n"); #endif remove_stn_from_list(&stnlist, stn); add_stn_to_list(&artlist, stn); return min_colour; }
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); }