extern real
read_numeric_multi(bool f_optional, int *p_n_readings)
{
size_t n_readings = 0;
real tot = (real)0.0;
skipblanks();
if (!isOpen(ch)) {
real r = read_number(f_optional);
if (p_n_readings) *p_n_readings = (r == HUGE_REAL ? 0 : 1);
return r;
}
nextch();
skipblanks();
do {
tot += read_number(fFalse);
++n_readings;
skipblanks();
} while (!isClose(ch));
nextch();
if (p_n_readings) *p_n_readings = n_readings;
/* FIXME: special averaging for bearings ... */
/* And for percentage gradient */
return tot / n_readings;
}
/*
return 1 if running background
return 0 if running frontground
return -1 when the input is blank line
*/
int parsecmd(char *cmd, char *argv[]) {
int argc = 0; // number of argv
int bg = 0;
cmd = skipblanks(cmd);
if (cmd == NULL) {
argv[0] = NULL;
return -1;
}
while (1) {
char *delim;
if ((delim = strchr(cmd, ' ')) == NULL)
break;
*delim = '\0';
argv[argc++] = cmd;
cmd = skipblanks(delim + 1);
}
char *delim = strchr(cmd, '\n');
*delim = '\0';
argv[argc++] = cmd;
argv[argc] = NULL;
if (!strcmp(argv[argc - 1], "&")) {
bg = 1;
argv[--argc] = NULL;
}
return bg;
}
void getdef(void)
{
int c, i;
char def[MAXWORD], dir[MAXWORD], name[MAXWORD];
skipblanks();
if (!isalpha(getword(dir, MAXWORD)))
error(dir[0], "getdef: expecting a directive after #");
else if (strcmp(dir, "define") == 0) {
skipblanks();
if (!isalpha(getword(name, MAXWORD)))
error(name[0], "getdef: non-alpha name expected");
else {
skipblanks();
for (i = 0; i < MAXWORD; i++)
if ((def[i] = getch()) == EOF || def[i] == '\n')
break;
def[i] = '\0';
if (i <= 0)
error('\n', "getdef: incomplete define");
else
install(name, def);
}
} else if (strcmp(dir, "undef") == 0) {
skipblanks();
if (!isalpha(getword(name, MAXWORD)))
error(name[0], "getdef: non-alpha in undef");
else
undef(name);
} else
error(dir[0], "getdef: expecting a directive after #");
}
int64_t parse_hex_skip(const char **cp)
{
skipblanks(cp);
int64_t val = 0;
int len = 8;
while(**cp && len--) {
if(**cp >= 'A' && **cp <= 'F') {
val <<= 4;
val |= **cp + 10 - 'A';
} else if(**cp >= 'a' && **cp <= 'f') {
val <<= 4;
val |= **cp + 10 - 'a';
} else if(**cp >= '0' && **cp <= '9') {
val <<= 4;
val |= **cp - '0';
} else {
break;
}
++(*cp);
}
return val;
}
void preSUBSTR(string &line, RawSource *) {
string e;
int pos=1,len=BIGVALUE;
string r,s,d=getid(line);
skipblanks(line);
line=ReplaceDefines(line);
getstring(line,e);
if(comma(line)) {
if(!ParseExpression(line,pos)) {
error("Syntax error");
pos=1;
}
if(comma(line)) {
if(!ParseExpression(line,len)) {
error("Syntax error");
len=BIGVALUE;
}
}
}
checkjunk(line);
if (pos<1 || pos>(int)e.size()) r="";
else r=e.substr(pos-1,len);
makestring(r);
deftab.add(d,'"'+r+'"');
}
void preTOSTR(string &line, RawSource *) {
string d=getid(line);
skipblanks(line);
string l=ReplaceDefines(line);
makestring(l);
line.clear();
deftab.add(d,'"'+l+'"');
}
void preSTRLEN(string &line, RawSource *) {
string e;
string d=getid(line);
skipblanks(line);
string p=ReplaceDefines(line);
line.clear();
getstring(p,e);
checkjunk(p);
deftab.add(d,tostr(e.size()));
}
void ifIFNUM(string &line, void(*push)(bool)) {
skipblanks(line);
if (isdigit(line[0]) || (line[0]=='#' && isalnum(line[1])) || (line[0]=='$' && isalnum(line[1])) || line[0]=='%' && isdigit(line[1])) {
int nval;
getConstant(line,nval);
(*push)(true);
} else {
line.clear();
(*push)(false);
}
}
void ifIFSTR(string &line, void(*push)(bool)) {
skipblanks(line);
if (line[0]=='"' || line[0]=='\'') {
string e;
getstring(line,e);
(*push)(true);
} else {
line.clear();
(*push)(false);
}
}
void getdef(){
char c;
char dir[MAXWORD], name[MAXWORD], defn[MAXWORD];
skipblanks();
c = getword(dir, MAXWORD);
if(!isalpha(dir[0])){
error(c, "getdef: expecting a directive after #");
}
if(strcmp(dir, "define") == 0){
skipblanks();
c = getword(name, MAXWORD);
if(!isalpha(name[0])){
error(c, "getdef: non-alpha - name expected");
}else{
skipblanks();
int i;
for(i = 0; i < MAXWORD - 1; i++){
defn[i] = getch();
if(defn[i] == '\n' || defn[i] == EOF){
break;
}
}
defn[i] = '\0';
if(i == 0){
error(c, "getdef: non-alpha - incompleted define");
}else{
install(name, defn);
}
}
}else if(strcmp(dir, "undef") == 0){
skipblanks();
c = getword(name, MAXWORD);
if(!isalpha(c)){
error(c, "getdef: non-alpha - in undef");
}else{
undef(name);
}
}else{
//error(c, "getdef: expecting a directive after #");
}
}
bool
parseargs::getline (vec<str> *args, int *linep)
{
args->setsize (0);
skipblanks ();
if (linep)
*linep = lineno;
while (str s = getarg ())
args->push_back (s);
return args->size ();
}
/* read word */
static void
get_word(void)
{
s_zero(&buffer);
skipblanks();
while (!isBlank(ch) && !isEol(ch)) {
s_catchar(&buffer, &buf_len, (char)ch);
nextch();
}
if (!buffer) s_catchar(&buffer, &buf_len, '\0');
#if 0
printf("get_word() got “%s”\n", buffer);
#endif
}
char *
html_decode_tag(const char *data, HtmlTagDef spec, void *dest)
{ const char *s = data;
for(;;)
{ const char *si; /* start-identifier */
const char *ei; /* end-identifier */
const char *sv; /* start-value */
const char *ev; /* end-value */
HtmlTagDef d;
s = skipblanks(s);
if ( *s == '>' )
return (char *)s+1;
if ( *s == '\0' )
return (char *)s;
si = s;
ei = skipidentifier(si);
if ( si == ei ) /* end of the file */
return (char *)s;
if ( *ei == '=' )
{ sv = ei+1;
if ( *sv == '"' )
{ ev = ++sv;
while(*ev && *ev != '"')
ev++;
s = (*ev ? ev+1 : ev);
} else
s = ev = skipidentifier(sv);
} else
{ s = ei;
ev = sv = NULL;
}
for(d=spec; d->tag; d++)
{ if ( strncmp(si, d->tag, ei-si) == 0 )
{ void *dst = (char *)dest + d->offset;
(*d->convert)(sv, ev-sv, dst, d->closure);
break;
}
}
}
}
extern void
read_date(int *py, int *pm, int *pd)
{
int y = 0, m = 0, d = 0;
filepos fp_date;
skipblanks();
get_pos(&fp_date);
y = read_uint_internal(/*Expecting date, found “%s”*/198, &fp_date);
/* Two digit year is 19xx. */
if (y < 100) y += 1900;
if (y < 1900 || y > 2078) {
set_pos(&fp_date);
compile_diagnostic(DIAG_WARN|DIAG_UINT, /*Invalid year (< 1900 or > 2078)*/58);
LONGJMP(file.jbSkipLine);
return; /* for brain-fried compilers */
}
if (ch == '.') {
filepos fp;
nextch();
get_pos(&fp);
m = read_uint_internal(/*Expecting date, found “%s”*/198, &fp_date);
if (m < 1 || m > 12) {
set_pos(&fp);
compile_diagnostic(DIAG_WARN|DIAG_UINT, /*Invalid month*/86);
LONGJMP(file.jbSkipLine);
return; /* for brain-fried compilers */
}
if (ch == '.') {
nextch();
get_pos(&fp);
d = read_uint_internal(/*Expecting date, found “%s”*/198, &fp_date);
if (d < 1 || d > last_day(y, m)) {
set_pos(&fp);
/* TRANSLATORS: e.g. 31st of April, or 32nd of any month */
compile_diagnostic(DIAG_WARN|DIAG_UINT, /*Invalid day of the month*/87);
LONGJMP(file.jbSkipLine);
return; /* for brain-fried compilers */
}
}
}
if (py) *py = y;
if (pm) *pm = m;
if (pd) *pd = d;
}
int64_t parse_int_skip(const char **cp)
{
skipblanks(cp);
int64_t val = 0;
int neg = 0;
if(**cp == '-') {
++(*cp);
neg = 1;
} else if(**cp == '~') {
++(*cp);
neg = 2;
}
if(**cp == '$') {
++(*cp);
val = parse_hex_skip(cp);
} else if(**cp == '0' && (cp[0][1] == 'x' || cp[0][1] == 'X')) {
(*cp) += 2;
val = parse_hex_skip(cp);
} else while(**cp) {
if(**cp >= '0' && **cp <= '9') {
val *= 10;
val += **cp - '0';
} else if(**cp == '*') {
++(*cp);
int64_t second = parse_int_skip(cp);
val *= second;
break;
} else {
break;
}
++(*cp);
}
if(neg == 1) {
val = neint(val);
} else if(neg == 2) {
val = not_int(val);
}
return val;
}
static void
cmd_date(void)
{
int year, month, day;
int days1, days2;
bool implicit_range = fFalse;
read_date(&year, &month, &day);
days1 = days_since_1900(year, month ? month : 1, day ? day : 1);
if (days1 > current_days_since_1900) {
compile_warning(-/*Date is in the future!*/80);
}
skipblanks();
if (ch == '-') {
nextch();
read_date(&year, &month, &day);
} else {
if (month && day) {
days2 = days1;
goto read;
}
implicit_range = fTrue;
}
if (month == 0) month = 12;
if (day == 0) day = last_day(year, month);
days2 = days_since_1900(year, month, day);
if (!implicit_range && days2 > current_days_since_1900) {
compile_warning(-/*Date is in the future!*/80);
}
if (days2 < days1) {
compile_error(-/*End of date range is before the start*/81);
}
read:
copy_on_write_meta(pcs);
pcs->meta->days1 = days1;
pcs->meta->days2 = days2;
}
int pregetdef(string &line,string &n, string &r, StringList &a) {
a.clear();
if ((n=getid(line)).empty()) {
error1("Illegal define name");
return 0;
}
if (line[0]=='(') {
line.erase(0,1);
while(1) {
a.push_back(getid(line));
if (sbcneed(line,')')) break;
if (!needcomma(line)) break;
}
}
skipblanks(line);
r=line;
line.clear();
return 1;
}
extern void
read_string(char **pstr, int *plen)
{
s_zero(pstr);
skipblanks();
if (ch == '\"') {
/* String quoted in "" */
nextch();
while (1) {
if (isEol(ch)) {
compile_error(-/*Missing \"*/69);
LONGJMP(file.jbSkipLine);
}
if (ch == '\"') break;
s_catchar(pstr, plen, ch);
nextch();
}
} else {
/* Unquoted string */
while (1) {
if (isEol(ch) || isComm(ch)) {
if (!*pstr || !(*pstr)[0]) {
compile_error(-/*Expecting string field*/121);
LONGJMP(file.jbSkipLine);
}
return;
}
if (isBlank(ch)) break;
s_catchar(pstr, plen, ch);
nextch();
}
}
nextch();
}
extern void
read_date(int *py, int *pm, int *pd)
{
int y = 0, m = 0, d = 0;
filepos fp;
skipblanks();
get_pos(&fp);
y = read_uint_internal(/*Expecting date, found “%s”*/198, &fp);
/* Two digit year is 19xx. */
if (y < 100) y += 1900;
if (y < 1900 || y > 2078) {
compile_warning(/*Invalid year (< 1900 or > 2078)*/58);
LONGJMP(file.jbSkipLine);
return; /* for brain-fried compilers */
}
if (ch == '.') {
nextch();
m = read_uint_internal(/*Expecting date, found “%s”*/198, &fp);
if (m < 1 || m > 12) {
compile_warning(/*Invalid month*/86);
LONGJMP(file.jbSkipLine);
return; /* for brain-fried compilers */
}
if (ch == '.') {
nextch();
d = read_uint_internal(/*Expecting date, found “%s”*/198, &fp);
if (d < 1 || d > last_day(y, m)) {
compile_warning(/*Invalid day of the month*/87);
LONGJMP(file.jbSkipLine);
return; /* for brain-fried compilers */
}
}
}
if (py) *py = y;
if (pm) *pm = m;
if (pd) *pd = d;
}
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
}
int
processBootOptions()
{
const char *cp = gBootArgs;
const char *val = 0;
const char *kernel;
int cnt;
int userCnt;
int cntRemaining;
char *argP;
char *configKernelFlags;
char *valueBuffer;
valueBuffer = malloc(VALUE_SIZE);
skipblanks( &cp );
// Update the unit and partition number.
if ( gBootVolume ) {
if (!( gBootVolume->flags & kBVFlagNativeBoot )) {
readBootSector( gBootVolume->biosdev, gBootVolume->part_boff, (void *) 0x7c00 );
//
// Setup edx, and signal intention to chain load the
// foreign booter.
//
chainbootdev = gBootVolume->biosdev;
chainbootflag = 1;
return 1;
}
setRootVolume(gBootVolume);
}
// If no boot volume fail immediately because we're just going to fail
// trying to load the config file anyway.
else {
return -1;
}
// Find out which version mac os we're booting.
strncpy(gMacOSVersion, gBootVolume->OSVersion, sizeof(gMacOSVersion));
// Load config table specified by the user, or use the default.
if (!getValueForBootKey(cp, "config", &val, &cnt)) {
val = 0;
cnt = 0;
}
// Load com.apple.Boot.plist from the selected volume
// and use its contents to override default bootConfig.
loadSystemConfig(&bootInfo->bootConfig);
loadChameleonConfig(&bootInfo->chameleonConfig, NULL);
// Use the kernel name specified by the user, or fetch the name
// in the config table, or use the default if not specified.
// Specifying a kernel name on the command line, or specifying
// a non-default kernel name in the config file counts as
// overriding the kernel, which causes the kernelcache not
// to be used.
gOverrideKernel = false;
if (( kernel = extractKernelName((char **)&cp) ))
{
strlcpy( bootInfo->bootFile, kernel, sizeof(bootInfo->bootFile) );
}
else
{
if ( getValueForKey( kKernelNameKey, &val, &cnt, &bootInfo->bootConfig ) )
{
strlcpy( bootInfo->bootFile, val, cnt+1 );
}
else
{
if( YOSEMITE ) // is 10.10
{
strlcpy( bootInfo->bootFile, kOSXKernel, sizeof(bootInfo->bootFile) );
//printf(HEADER "/System/Library/Kernels/%s\n", bootInfo->bootFile);
}
else
{ // OSX is not 10.10
strlcpy( bootInfo->bootFile, kDefaultKernel, sizeof(bootInfo->bootFile) );
//printf(HEADER "/%s\n", bootInfo->bootFile);
}
}
}
if (!YOSEMITE) // not 10.10 so 10.9 and previus
{
if (strcmp( bootInfo->bootFile, kDefaultKernel ) != 0)
{
//printf(HEADER "org.chameleon.Boot.plist found path for custom '%s' found!\n", bootInfo->bootFile);
gOverrideKernel = true;
}
}
else
{ // OSX is 10.10
if (strcmp( bootInfo->bootFile, kOSXKernel ) != 0)
{
//printf(HEADER "org.chameleon.Boot.plist found path for custom '%s' found!\n", bootInfo->bootFile);
gOverrideKernel = true;
}
}
// Ermac : Inject "kext-dev-mode=1" if OS X 10.10 is detected
if( YOSEMITE ) // is 10.10
{
addBootArg("kext-dev-mode=1");
}
cntRemaining = BOOT_STRING_LEN - 2; // save 1 for NULL, 1 for space
argP = bootArgs->CommandLine;
// Get config kernel flags, if not ignored.
if (getValueForBootKey(cp, kIgnoreBootFileFlag, &val, &cnt) ||
!getValueForKey( kKernelFlagsKey, &val, &cnt, &bootInfo->bootConfig ))
{
val = "";
cnt = 0;
}
configKernelFlags = malloc(cnt + 1);
strlcpy(configKernelFlags, val, cnt + 1);
// boot-uuid can be set either on the command-line or in the config file
if (!processBootArgument(kBootUUIDKey, cp, configKernelFlags, bootInfo->config,
&argP, &cntRemaining, gBootUUIDString, sizeof(gBootUUIDString)))
{
//
// Try an alternate method for getting the root UUID on boot helper partitions.
//
if (gBootVolume->flags & kBVFlagBooter)
{
// Load the configuration store in the boot helper partition
if (loadHelperConfig(&bootInfo->helperConfig) == 0)
{
val = getStringForKey(kHelperRootUUIDKey, &bootInfo->helperConfig);
if (val != NULL)
{
strlcpy(gBootUUIDString, val, sizeof(gBootUUIDString));
}
}
}
/*
// Try to get the volume uuid string
if (!strlen(gBootUUIDString) && gBootVolume->fs_getuuid)
{
gBootVolume->fs_getuuid(gBootVolume, gBootUUIDString);
}
*/
// If we have the volume uuid add it to the commandline arguments
if (strlen(gBootUUIDString))
{
copyArgument(kBootUUIDKey, gBootUUIDString, strlen(gBootUUIDString), &argP, &cntRemaining);
}
// Try to get the volume uuid string
if (!strlen(gBootUUIDString) && gBootVolume->fs_getuuid)
{
gBootVolume->fs_getuuid(gBootVolume, gBootUUIDString);
DBG("boot-uuid: %s\n", gBootUUIDString);
}
}
if (!processBootArgument(kRootDeviceKey, cp, configKernelFlags, bootInfo->config,
&argP, &cntRemaining, gRootDevice, ROOT_DEVICE_SIZE))
{
cnt = 0;
if ( getValueForKey( kBootDeviceKey, &val, &cnt, &bootInfo->chameleonConfig))
{
valueBuffer[0] = '*';
cnt++;
strlcpy(valueBuffer + 1, val, cnt);
val = valueBuffer;
}
else
{ /*
if (strlen(gBootUUIDString))
{
val = "*uuid";
cnt = 5;
}
else
{ */
// Don't set "rd=.." if there is no boot device key
// and no UUID.
val = "";
cnt = 0;
/* } */
}
if (cnt > 0)
{
copyArgument( kRootDeviceKey, val, cnt, &argP, &cntRemaining);
}
strlcpy( gRootDevice, val, (cnt + 1));
}
/*
* Removed. We don't need this anymore.
*
if (!processBootArgument(kPlatformKey, cp, configKernelFlags, bootInfo->config,
&argP, &cntRemaining, gPlatformName, sizeof(gCacheNameAdler)))
{
getPlatformName(gPlatformName);
copyArgument(kPlatformKey, gPlatformName, strlen(gPlatformName), &argP, &cntRemaining);
}
*/
if (!getValueForBootKey(cp, kSafeModeFlag, &val, &cnt) &&
!getValueForBootKey(configKernelFlags, kSafeModeFlag, &val, &cnt))
{
if (gBootMode & kBootModeSafe)
{
copyArgument(0, kSafeModeFlag, strlen(kSafeModeFlag), &argP, &cntRemaining);
}
}
// Store the merged kernel flags and boot args.
cnt = strlen(configKernelFlags);
if (cnt)
{
if (cnt > cntRemaining)
{
error("Warning: boot arguments too long, truncating\n");
cnt = cntRemaining;
}
strncpy(argP, configKernelFlags, cnt);
argP[cnt++] = ' ';
cntRemaining -= cnt;
}
userCnt = strlen(cp);
if (userCnt > cntRemaining)
{
error("Warning: boot arguments too long, truncating\n");
userCnt = cntRemaining;
}
strncpy(&argP[cnt], cp, userCnt);
argP[cnt+userCnt] = '\0';
if(!shouldboot)
{
gVerboseMode = getValueForKey( kVerboseModeFlag, &val, &cnt, &bootInfo->chameleonConfig ) ||
getValueForKey( kSingleUserModeFlag, &val, &cnt, &bootInfo->chameleonConfig );
gBootMode = ( getValueForKey( kSafeModeFlag, &val, &cnt, &bootInfo->chameleonConfig ) ) ?
kBootModeSafe : kBootModeNormal;
if ( getValueForKey( kIgnoreCachesFlag, &val, &cnt, &bootInfo->chameleonConfig ) )
{
gBootMode = kBootModeSafe;
}
}
if ( getValueForKey( kMKextCacheKey, &val, &cnt, &bootInfo->bootConfig ) )
{
strlcpy(gMKextName, val, cnt + 1);
}
else
{
gMKextName[0]=0;
}
free(configKernelFlags);
free(valueBuffer);
return 0;
}
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_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();
}
}
extern real
read_numeric(bool f_optional)
{
skipblanks();
return read_number(f_optional);
}
void dirERROR(string &line, RawSource *) {
skipblanks(line);
error(line,ERRPASS1);
line.clear();
}
void dirINCDIR(string &line, RawSource *) {
skipblanks(line);
paths.insert(paths.begin(),line);
}
/* 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 */
}
int
processBootOptions()
{
const char * cp = gBootArgs;
const char * val = 0;
const char * kernel;
int cnt;
int userCnt;
int cntRemaining;
char * argP;
char uuidStr[64];
bool uuidSet = false;
char * configKernelFlags;
char * valueBuffer;
valueBuffer = malloc(VALUE_SIZE);
skipblanks( &cp );
// Update the unit and partition number.
if ( gBootVolume )
{
if (!( gBootVolume->flags & kBVFlagNativeBoot ))
{
readBootSector( gBootVolume->biosdev, gBootVolume->part_boff,
(void *) 0x7c00 );
//
// Setup edx, and signal intention to chain load the
// foreign booter.
//
chainbootdev = gBootVolume->biosdev;
chainbootflag = 1;
return 1;
}
setRootVolume(gBootVolume);
}
// If no boot volume fail immediately because we're just going to fail
// trying to load the config file anyway.
else
return -1;
// Load config table specified by the user, or use the default.
if (!getValueForBootKey(cp, "config", &val, &cnt)) {
val = 0;
cnt = 0;
}
// Load com.apple.Boot.plist from the selected volume
// and use its contents to override default bootConfig.
// This is not a mandatory operation anymore.
loadOverrideConfig(&bootInfo->overrideConfig);
// Use the kernel name specified by the user, or fetch the name
// in the config table, or use the default if not specified.
// Specifying a kernel name on the command line, or specifying
// a non-default kernel name in the config file counts as
// overriding the kernel, which causes the kernelcache not
// to be used.
gOverrideKernel = false;
if (( kernel = extractKernelName((char **)&cp) )) {
strcpy( bootInfo->bootFile, kernel );
gOverrideKernel = true;
} else {
if ( getValueForKey( kKernelNameKey, &val, &cnt, &bootInfo->bootConfig ) ) {
strlcpy( bootInfo->bootFile, val, cnt+1 );
if (strcmp( bootInfo->bootFile, kDefaultKernel ) != 0) {
gOverrideKernel = true;
}
} else {
strcpy( bootInfo->bootFile, kDefaultKernel );
}
}
cntRemaining = BOOT_STRING_LEN - 2; // save 1 for NULL, 1 for space
argP = bootArgs->CommandLine;
// Get config table kernel flags, if not ignored.
if (getValueForBootKey(cp, kIgnoreBootFileFlag, &val, &cnt) ||
!getValueForKey( kKernelFlagsKey, &val, &cnt, &bootInfo->bootConfig )) {
val = "";
cnt = 0;
}
configKernelFlags = malloc(cnt + 1);
strlcpy(configKernelFlags, val, cnt + 1);
if (processBootArgument(kBootUUIDKey, cp, configKernelFlags, bootInfo->config, &argP, &cntRemaining, 0)) {
// boot-uuid was set either on the command-line
// or in the config file.
uuidSet = true;
} else {
//
// Try an alternate method for getting the root UUID on boot helper partitions.
//
if (gBootVolume->flags & kBVFlagBooter)
{
if((loadHelperConfig(&bootInfo->helperConfig) == 0)
&& getValueForKey(kHelperRootUUIDKey, &val, &cnt, &bootInfo->helperConfig) )
{
getValueForKey(kHelperRootUUIDKey, &val, &cnt, &bootInfo->helperConfig);
copyArgument(kBootUUIDKey, val, cnt, &argP, &cntRemaining);
uuidSet = true;
}
}
if (!uuidSet && gBootVolume->fs_getuuid && gBootVolume->fs_getuuid (gBootVolume, uuidStr) == 0) {
verbose("Setting boot-uuid to: %s\n", uuidStr);
copyArgument(kBootUUIDKey, uuidStr, strlen(uuidStr), &argP, &cntRemaining);
uuidSet = true;
}
}
if (!processBootArgument(kRootDeviceKey, cp, configKernelFlags, bootInfo->config, &argP, &cntRemaining, gRootDevice)) {
cnt = 0;
if ( getValueForKey( kBootDeviceKey, &val, &cnt, &bootInfo->bootConfig)) {
valueBuffer[0] = '*';
cnt++;
strlcpy(valueBuffer + 1, val, cnt);
val = valueBuffer;
} else {
if (uuidSet) {
val = "*uuid";
cnt = 5;
} else {
// Don't set "rd=.." if there is no boot device key
// and no UUID.
val = "";
cnt = 0;
}
}
if (cnt > 0) {
copyArgument( kRootDeviceKey, val, cnt, &argP, &cntRemaining);
}
strlcpy( gRootDevice, val, (cnt + 1));
}
/*
* Removed. We don't need this anymore.
*
if (!processBootArgument(kPlatformKey, cp, configKernelFlags, bootInfo->config, &argP, &cntRemaining, gPlatformName)) {
getPlatformName(gPlatformName);
copyArgument(kPlatformKey, gPlatformName, strlen(gPlatformName), &argP, &cntRemaining);
}
*/
if (!getValueForBootKey(cp, kSafeModeFlag, &val, &cnt) &&
!getValueForBootKey(configKernelFlags, kSafeModeFlag, &val, &cnt)) {
if (gBootMode & kBootModeSafe) {
copyArgument(0, kSafeModeFlag, strlen(kSafeModeFlag), &argP, &cntRemaining);
}
}
// Store the merged kernel flags and boot args.
cnt = strlen(configKernelFlags);
if (cnt) {
if (cnt > cntRemaining) {
error("Warning: boot arguments too long, truncating\n");
cnt = cntRemaining;
}
strncpy(argP, configKernelFlags, cnt);
argP[cnt++] = ' ';
cntRemaining -= cnt;
}
userCnt = strlen(cp);
if (userCnt > cntRemaining) {
error("Warning: boot arguments too long, truncating\n");
userCnt = cntRemaining;
}
strncpy(&argP[cnt], cp, userCnt);
argP[cnt+userCnt] = '\0';
if(!shouldboot)
{
gVerboseMode = getValueForKey( kVerboseModeFlag, &val, &cnt, &bootInfo->bootConfig ) ||
getValueForKey( kSingleUserModeFlag, &val, &cnt, &bootInfo->bootConfig );
gBootMode = ( getValueForKey( kSafeModeFlag, &val, &cnt, &bootInfo->bootConfig ) ) ?
kBootModeSafe : kBootModeNormal;
if ( getValueForKey( kIgnoreCachesFlag, &val, &cnt, &bootInfo->bootConfig ) ) {
gBootMode = kBootModeSafe;
}
}
if ( getValueForKey( kMKextCacheKey, &val, &cnt, &bootInfo->bootConfig ) )
{
strlcpy(gMKextName, val, cnt + 1);
}
free(configKernelFlags);
free(valueBuffer);
return 0;
}
extern unsigned int
read_uint(void)
{
skipblanks();
return read_uint_internal(/*Expecting numeric field, found “%s”*/9, NULL);
}
