static void
check_reentry(prefix *tag)
{
/* Don't try to check "*prefix \" or "*begin \" */
if (!tag->up) return;
if (TSTBIT(tag->sflags, SFLAGS_PREFIX_ENTERED)) {
if (tag->line != file.line ||
strcmp(tag->filename, file.filename) != 0) {
const char *filename_store = file.filename;
unsigned int line_store = file.line;
static int reenter_depr_count = 0;
if (reenter_depr_count < 5) {
compile_warning(/*Reentering an existing prefix level is deprecated*/29);
if (++reenter_depr_count == 5)
compile_warning(/*Further uses of this deprecated feature will not be reported*/95);
}
file.filename = tag->filename;
file.line = tag->line;
compile_warning(/*Originally entered here*/30);
file.filename = filename_store;
file.line = line_store;
}
} else {
tag->sflags |= BIT(SFLAGS_PREFIX_ENTERED);
tag->filename = file.filename;
tag->line = file.line;
}
}
static void
cmd_default(void)
{
static sztok defaulttab[] = {
{ "CALIBRATE", CMD_CALIBRATE },
{ "DATA", CMD_DATA },
{ "UNITS", CMD_UNITS },
{ NULL, CMD_NULL }
};
static int default_depr_count = 0;
if (default_depr_count < 5) {
compile_warning(-/**DEFAULT is deprecated - use *CALIBRATE/DATA/SD/UNITS with argument DEFAULT instead*/20);
if (++default_depr_count == 5)
compile_warning(/*Further uses of this deprecated feature will not be reported*/95);
}
get_token();
switch (match_tok(defaulttab, TABSIZE(defaulttab))) {
case CMD_CALIBRATE:
default_calib(pcs);
break;
case CMD_DATA:
default_style(pcs);
default_grade(pcs);
break;
case CMD_UNITS:
default_units(pcs);
break;
default:
file.lpos += strlen(buffer);
compile_error_skip(-/*Unknown setting “%s”*/41, buffer);
}
}
static void
cmd_prefix(void)
{
static int prefix_depr_count = 0;
prefix *tag;
/* Issue warning first, so "*prefix \" warns first that *prefix is
* deprecated and then that ROOT is...
*/
if (prefix_depr_count < 5) {
compile_warning(-/**prefix is deprecated - use *begin and *end instead*/6);
if (++prefix_depr_count == 5)
compile_warning(/*Further uses of this deprecated feature will not be reported*/95);
}
tag = read_prefix(PFX_SURVEY|PFX_ALLOW_ROOT);
pcs->Prefix = tag;
check_reentry(tag);
}
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;
}
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;
}
void include_file( int bprepro )
{
static char buffer[1024];
char * buffer_ptr = buffer;
int actual_line = line_count;
SKIP_SPACES_UNTIL_LF_AND_COUNT_LINES;
if ( *source_ptr == '"' )
{
source_ptr++;
buffer_ptr = buffer;
while ( *source_ptr && *source_ptr != '"' )
{
if ( buffer_ptr == buffer + 1023 ) compile_error( MSG_IDENTIFIER_TOO_LONG );
*buffer_ptr++ = *source_ptr++;
}
if ( *source_ptr == '"' ) source_ptr++;
*buffer_ptr = 0;
if ( bprepro )
{
SKIP_SPACES_UNTIL_LF_AND_COUNT_LINES;
if ( *source_ptr == '\n' ) line_count--;
}
else
{
SKIP_SPACES;
}
if ( *source_ptr == ';' )
{
if ( bprepro )
{
compile_warning( "extra tokens at end of #include directive" );
SKIP_ALL_UNTIL_LF_AND_COUNT_LINES;
if ( *source_ptr == '\n' ) line_count--;
}
else
token_next();
}
load_file( buffer );
token_next();
return;
}
line_count = actual_line;
compile_error( MSG_FILENAME_EXP );
}
static void
cmd_end(void)
{
settings *pcsParent;
prefix *tag, *tagBegin;
pcsParent = pcs->next;
if (pcs->begin_lineno == 0) {
if (pcsParent == NULL) {
/* more ENDs than BEGINs */
compile_error_skip(/*No matching BEGIN*/192);
} else {
compile_error_skip(/*END with no matching BEGIN in this file*/22);
}
return;
}
tagBegin = pcs->tag;
SVX_ASSERT(pcsParent);
free_settings(pcs);
pcs = pcsParent;
/* note need to read using root *before* BEGIN */
tag = read_prefix(PFX_SURVEY|PFX_OPT|PFX_ALLOW_ROOT);
if (tag != tagBegin) {
if (tag) {
if (!tagBegin) {
/* "*begin" / "*end foo" */
compile_error_skip(-/*Matching BEGIN tag has no prefix*/36);
} else {
/* tag mismatch */
compile_error_skip(-/*Prefix tag doesn’t match BEGIN*/193);
}
} else {
/* close tag omitted; open tag given */
compile_warning(-/*Closing prefix omitted from END*/194);
}
}
}
int compile_varspace( VARSPACE * n, segment * data, int additive, int copies, int padding, VARSPACE ** collision, int alignment, int duplicateignore )
{
int i, j, total_count, last_count = 0 ;
int base_offset = data->current ;
int total_length ;
int size, count ;
int code ;
expresion_result res ;
VARIABLE * var ;
int unsigned_prefix = 0;
int signed_prefix = 0;
BASETYPE basetype = TYPE_UNDEFINED ;
TYPEDEF type, typeaux;
segment * segm = NULL ;
PROCDEF * proc = NULL;
/* Backup vars */
BASETYPE basetypeb = TYPE_UNDEFINED ;
TYPEDEF typeb;
segment * segmb = NULL ;
/* Initialize some stuffs */
type = typedef_new( TYPE_UNDEFINED ) ;
typeb = typedef_new( TYPE_UNDEFINED ) ;
for ( ;; )
{
if ( n->reserved == n->count ) varspace_alloc( n, 16 ) ;
if ( alignment && ( n->size % alignment ) > 0 )
{
int extra = alignment - ( n->size % alignment );
if ( n->reserved <= n->count + extra )
{
varspace_alloc( n, extra + 16 );
}
if ( data->reserved <= data->current + extra )
{
segment_alloc( data, extra + 16 );
}
n->size += extra;
data->current += extra;
}
token_next() ;
/* Se salta comas y puntos y coma */
if ( token.type == NOTOKEN ) break ;
if ( token.type != IDENTIFIER ) compile_error( MSG_INCOMP_TYPE ) ;
if ( token.code == identifier_comma )
{
basetype = basetypeb ;
type = typeb ;
segm = segmb ;
continue ;
}
else if ( token.code == identifier_semicolon )
{
basetype = TYPE_UNDEFINED ;
set_type( &type, TYPE_UNDEFINED ) ;
basetypeb = basetype ;
typeb = type ;
segm = NULL ;
proc = NULL ;
continue ;
}
else if ( token.code == identifier_end )
{
break ;
}
/* "Unsigned" */
if ( token.code == identifier_unsigned )
{
unsigned_prefix = 1;
token_next();
}
else if ( token.code == identifier_signed )
{
signed_prefix = 1;
token_next();
}
/* Tipos de datos básicos */
if ( token.code == identifier_dword )
{
basetype = signed_prefix ? TYPE_INT : TYPE_DWORD ;
signed_prefix = unsigned_prefix = 0;
token_next() ;
}
else if ( token.code == identifier_word )
{
basetype = signed_prefix ? TYPE_SHORT : TYPE_WORD ;
signed_prefix = unsigned_prefix = 0;
token_next() ;
}
else if ( token.code == identifier_byte )
{
basetype = signed_prefix ? TYPE_SBYTE : TYPE_BYTE ;
signed_prefix = unsigned_prefix = 0;
token_next() ;
}
else if ( token.code == identifier_int )
{
basetype = unsigned_prefix ? TYPE_DWORD : TYPE_INT;
signed_prefix = unsigned_prefix = 0;
token_next() ;
}
else if ( token.code == identifier_short )
{
basetype = unsigned_prefix ? TYPE_WORD : TYPE_SHORT;
signed_prefix = unsigned_prefix = 0;
token_next() ;
}
else if ( token.code == identifier_char )
{
basetype = TYPE_CHAR ;
token_next() ;
}
else if ( token.code == identifier_float )
{
basetype = TYPE_FLOAT ;
token_next() ;
}
else if ( token.code == identifier_string )
{
basetype = TYPE_STRING ;
token_next() ;
}
else
{
if ( !proc && ( proc = procdef_search( token.code ) ) ) /* Variables tipo proceso, Splinter */
{
basetype = TYPE_INT ;
token_next();
}
else
{
if (
token.type == IDENTIFIER &&
token.code >= reserved_words &&
!segment_by_name( token.code ) )
{
int code = token.code;
token_next();
if ( token.type == IDENTIFIER && token.code >= reserved_words )
{
proc = procdef_new( procdef_getid(), code );
basetype = TYPE_INT ;
}
else
{
token_back();
}
}
}
}
if ( signed_prefix || unsigned_prefix ) compile_error( MSG_INVALID_TYPE );
if ( basetype != TYPE_STRUCT ) type = typedef_new( basetype ) ;
if ( basetype == TYPE_UNDEFINED ) type = typedef_new( TYPE_INT ) ;
/* Tipos de datos definidos por el usuario */
if ( basetype != TYPE_STRUCT && ( segm = segment_by_name( token.code ) ) )
{
basetype = TYPE_STRUCT ;
type = * typedef_by_name( token.code ) ;
token_next() ;
}
if ( token.type == IDENTIFIER && token.code == identifier_struct )
{
type.chunk[0].type = TYPE_STRUCT ;
type.chunk[0].count = 1 ;
type.depth = 1 ;
token_next() ;
segm = 0 ;
}
basetypeb = basetype ;
typeb = type ;
segmb = segm ;
/* Tipos de datos derivados */
while ( token.type == IDENTIFIER && ( token.code == identifier_pointer || token.code == identifier_multiply ) )
{
type = typedef_enlarge( type ) ;
type.chunk[0].type = TYPE_POINTER ;
basetype = TYPE_POINTER ;
segm = NULL ;
token_next() ;
}
/* Nombre del dato */
if ( token.type != IDENTIFIER ) compile_error( MSG_IDENTIFIER_EXP ) ;
if ( token.code < reserved_words )
{
if ( proc ) compile_error( MSG_VARIABLE_ERROR );
token_back() ;
break ;
}
if (( var = varspace_search( n, token.code ) ) )
{
if ( duplicateignore )
{
int skip_all_until_semicolon = 0;
int skip_equal = 0;
if ( debug ) compile_warning( 0, MSG_VARIABLE_REDECLARE ) ;
for ( ;; )
{
token_next() ;
/* Se salta todo hasta el puntos y coma o en el end o la coma si no hay asignacion */
if ( token.type == NOTOKEN ) break ;
if ( token.type == IDENTIFIER )
{
if ( !skip_equal && token.code == identifier_equal )
{
skip_all_until_semicolon = 1;
continue;
}
if ( !skip_all_until_semicolon && token.code == identifier_comma ) break;
if ( token.code == identifier_semicolon ) break ;
if ( token.code == identifier_end ) break ;
}
}
token_back();
continue;
}
else
compile_error( MSG_VARIABLE_REDECLARE ) ;
}
/* (2006/11/19 19:34 GMT-03:00, Splinter - [email protected]) */
if ( collision )
for ( i = 0; collision[i];i++ )
if ( varspace_search( collision[i], token.code ) ) compile_error( MSG_VARIABLE_REDECLARE ) ;
/* (2006/11/19 19:34 GMT-03:00, Splinter - [email protected]) */
if ( constants_search( token.code ) ) compile_error( MSG_CONSTANT_REDECLARED_AS_VARIABLE ) ;
code = token.code ;
n->vars[n->count].code = token.code ;
n->vars[n->count].offset = data->current;
/* Non-additive STRUCT; use zero-based member offsets */
if ( !additive ) n->vars[n->count].offset -= base_offset;
token_next() ;
/* Compila una estructura no predefinida */
if ( !segm && typedef_is_struct( type ) )
{
VARSPACE * members ;
type.chunk[0].count = 1 ;
count = 1 ;
while ( token.type == IDENTIFIER && token.code == identifier_leftb )
{
res = compile_expresion( 1, 0, 0, TYPE_INT ) ;
if ( !typedef_is_integer( res.type ) ) compile_error( MSG_INTEGER_REQUIRED ) ;
count *= res.value + 1 ;
type = typedef_enlarge( type ) ;
type.chunk[0].type = TYPE_ARRAY ;
type.chunk[0].count = res.value + 1 ;
token_next() ;
if ( token.type != IDENTIFIER || token.code != identifier_rightb ) compile_error( MSG_EXPECTED, "]" ) ;
token_next() ;
}
token_back() ;
/* Da la vuelta a los índices [10][5] -> [5][10] */
for ( i = 0 ; i < type.depth ; i++ ) if ( type.chunk[i].type != TYPE_ARRAY ) break ;
i--;
for ( j = 0 ; j <= i ; j++ ) typeaux.chunk[ j ] = type.chunk[ i - j ];
for ( j = 0 ; j <= i ; j++ ) type.chunk[ j ] = typeaux.chunk[ j ];
members = ( VARSPACE * )calloc( 1, sizeof( VARSPACE ) ) ;
if ( !members )
{
fprintf( stdout, "compile_varspace: out of memory\n" ) ;
exit( 1 ) ;
}
varspace_init( members ) ;
size = compile_varspace( members, data, 0, count, 0, NULL, 0, duplicateignore ) ;
type.varspace = members ;
token_next() ;
if ( token.type == IDENTIFIER && token.code == identifier_equal )
{
i = data->current ;
data->current = n->vars[n->count].offset ;
compile_struct_data( members, data, count, 0 );
data->current = i ;
}
else
{
token_back() ;
}
for ( i = 0 ; i < members->stringvar_count ; i++ )
varspace_varstring( n, members->stringvars[i] ) ;
n->size += typedef_size( type ) ;
n->vars[n->count].type = type ;
n->count++ ;
continue ; /* No ; */
}
else if ( token.type == IDENTIFIER && token.code == identifier_leftb ) /* Compila un array */
{
total_count = 1 ;
while ( token.type == IDENTIFIER && token.code == identifier_leftb )
{
if ( type.depth == MAX_TYPECHUNKS ) compile_error( MSG_TOO_MANY_AL ) ;
type = typedef_enlarge( type ) ;
type.chunk[0].type = TYPE_ARRAY ;
token_next() ;
if ( token.type == IDENTIFIER && token.code == identifier_rightb )
{
type.chunk[0].count = 0 ;
if ( total_count != 1 ) compile_error( MSG_VTA ) ;
total_count = 0 ;
last_count = 0 ;
}
else
{
token_back() ;
res = compile_expresion( 1, 0, 0, TYPE_DWORD ) ;
if ( !total_count ) compile_error( MSG_VTA ) ;
total_count *= res.value + 1 ;
last_count = res.value + 1 ;
type.chunk[0].count = res.value + 1 ;
token_next() ;
if ( token.type != IDENTIFIER || token.code != identifier_rightb ) compile_error( MSG_EXPECTED, "]" ) ;
}
token_next() ;
}
/* Da la vuelta a los índices [10][5] -> [5][10] */
for ( i = 0 ; i < type.depth ; i++ ) if ( type.chunk[i].type != TYPE_ARRAY ) break ;
i--;
for ( j = 0 ; j <= i ; j++ ) typeaux.chunk[ j ] = type.chunk[ i - j ];
for ( j = 0 ; j <= i ; j++ ) type.chunk[ j ] = typeaux.chunk[ j ];
if ( segm && token.type == IDENTIFIER && token.code == identifier_equal )
{
for ( i = 0 ; i < total_count ; i++ ) segment_add_from( data, segm ) ;
i = data->current ;
data->current = n->vars[n->count].offset ;
compile_struct_data( type.varspace, data, typedef_count( type ), 0 );
if ( !type.chunk[0].count )
type.chunk[0].count = ( data->current - i ) / typedef_size( typeb );
else
data->current = i; /* Solo si ya habia sido alocada */
}
else if ( token.type == IDENTIFIER && token.code == identifier_equal )
{
/* if (basetype == TYPE_UNDEFINED) basetype = TYPE_INT; */
i = compile_array_data( n, data, total_count, last_count, &basetype ) ;
assert( basetype != TYPE_UNDEFINED ) ;
set_type( &type, basetype ) ;
if ( total_count == 0 )
{
type.chunk[0].count = i;
}
else if ( i < total_count )
{
for ( ; i < total_count; i++ )
{
if ( basetype == TYPE_STRING ) varspace_varstring( n, data->current ) ;
segment_add_as( data, 0, basetype ) ;
}
}
}
else if ( segm )
{
int string_offset = 0, j;
if ( total_count == 0 ) compile_error( MSG_EXPECTED, "=" ) ;
for ( i = 0; i < total_count; i++ )
{
segment_add_from( data, segm ) ;
for ( j = 0; j < type.varspace->stringvar_count; j++ )
varspace_varstring( n, type.varspace->stringvars[j] + string_offset );
string_offset += type.varspace->size;
}
token_back() ;
}
else
{
if ( basetype == TYPE_UNDEFINED )
{
basetype = TYPE_INT;
set_type( &type, basetype ) ;
}
if ( type.chunk[0].count == 0 ) compile_error( MSG_EXPECTED, "=" ) ;
for ( i = 0; i < total_count; i++ )
{
if ( basetype == TYPE_STRING ) varspace_varstring( n, data->current ) ;
segment_add_as( data, 0, basetype ) ;
}
token_back() ;
}
}
else if ( segm && token.type == IDENTIFIER && token.code == identifier_equal ) /* Compila una asignación de valores por defecto */
{
segment_add_from( data, segm ) ;
i = data->current ;
data->current = n->vars[n->count].offset ;
if ( !additive ) data->current += base_offset;
compile_struct_data( type.varspace, data, 1, 0 );
data->current = i ;
}
else if ( token.type == IDENTIFIER && token.code == identifier_equal )
{
res = compile_expresion( 1, 0, 0, basetype ) ;
if ( basetype == TYPE_UNDEFINED )
{
basetype = typedef_base( res.type ) ;
if ( basetype == TYPE_UNDEFINED ) compile_error( MSG_INCOMP_TYPE ) ;
set_type( &type, basetype ) ;
}
if ( basetype == TYPE_FLOAT )
{
segment_add_as( data, *( int * )&res.fvalue, basetype ) ;
}
else
{
if ( basetype == TYPE_STRING ) varspace_varstring( n, data->current ) ;
segment_add_as( data, res.value, basetype ) ;
}
}
else if ( !segm ) /* Asigna valores por defecto (0) */
{
if ( basetype == TYPE_UNDEFINED )
{
basetype = TYPE_INT;
set_type( &type, basetype ) ;
}
if ( basetype == TYPE_STRING ) varspace_varstring( n, data->current ) ;
segment_add_as( data, 0, basetype ) ;
token_back() ;
}
else
{
if ( typedef_is_struct( type ) )
for ( i = 0 ; i < type.varspace->stringvar_count ; i++ )
varspace_varstring( n, type.varspace->stringvars[i] + n->size );
segment_add_from( data, segm ) ;
token_back() ;
}
n->size += typedef_size( type ) ;
n->vars[n->count].type = type ;
/* Variables tipo proceso, asigno varspace al tipo. Splinter */
if ( proc ) n->vars[n->count].type.varspace = proc->pubvars;
n->count++ ;
token_next() ;
if ( token.type == IDENTIFIER && token.code == identifier_comma )
{
token_back() ;
continue ;
}
if ( token.type == IDENTIFIER && token.code == identifier_semicolon )
{
token_back() ;
continue ;
}
compile_error( MSG_EXPECTED, ";" ) ;
token_back() ;
break ;
}
if ( padding && ( data->current % padding ) > 0 )
{
padding -= data->current % padding;
data->current += padding;
n->size += padding;
if ( data->reserved <= data->current )
segment_alloc( data, data->reserved - data->current + 32 );
}
n->last_offset = data->current ;
total_length = data->current - base_offset ;
/* n->size *= copies ; */
while ( copies-- > 1 )
{
int i ;
for ( i = 0 ; i < n->stringvar_count ; i++ )
{
if ( n->stringvars[i] >= base_offset && n->stringvars[i] < base_offset + total_length )
{
varspace_varstring( n, n->stringvars[i] - base_offset + data->current ) ;
}
}
segment_copy( data, base_offset, total_length ) ;
base_offset += total_length ;
}
return total_length ;
}
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);
}
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();
}
}
void preprocessor()
{
int i, ifdef;
char * ptr;
int actual_line_count;
static int initialized = 0;
if ( !initialized )
{
id_define = identifier_search_or_add( "DEFINE" );
id_undef = identifier_search_or_add( "UNDEF" );
id_ifdef = identifier_search_or_add( "IFDEF" );
id_ifndef = identifier_search_or_add( "IFNDEF" );
id_else = identifier_search_or_add( "ELSE" );
id_endif = identifier_search_or_add( "ENDIF" );
id_if = identifier_search_or_add( "IF" );
initialized = 1;
}
token_next();
if ( token.type != IDENTIFIER ) compile_error( MSG_UNKNOWN_PREP );
/* #define TEXT value */
if ( token.code == id_define )
{
disable_expand_defines++;
token_next();
if ( token.type != IDENTIFIER ) compile_error( MSG_INVALID_IDENTIFIER );
if ( find_define( token.code ) != -1 ) compile_error( MSG_MACRO_ERROR, identifier_name( token.code ) );
/* Allocate the macro */
if ( defines_allocated == defines_count )
{
defines_allocated += 8;
defines = ( DEFINE * ) realloc( defines, sizeof( DEFINE ) * defines_allocated );
}
defines[defines_count].code = token.code;
/* Check for parameters: no space allowed between name and ( */
if ( *source_ptr == '(' )
{
source_ptr++;
for ( defines[defines_count].param_count = i = 0; *source_ptr != ')'; )
{
if ( !*source_ptr ) compile_error( MSG_EXPECTED, ")" );
if ( i == MAX_MACRO_PARAMS ) compile_error( MSG_TOO_MANY_PARAMS );
token_next();
if ( token.type != IDENTIFIER || token.code < reserved_words ) compile_error( MSG_INVALID_IDENTIFIER );
defines[defines_count].param_id[i++] = token.code;
defines[defines_count].param_count++;
SKIP_SPACES;
if ( *source_ptr == ',' ) source_ptr++;
}
source_ptr++;
}
else
{
/* No parameters and no parenthesis */
defines[defines_count].param_count = -1;
}
SKIP_SPACES_UNTIL_LF_AND_COUNT_LINES;
ptr = ( char * ) source_ptr;
while ( *ptr && *ptr != '\n' )
if ( *ptr == '\\' && *( ptr + 1 ) == '\n' )
{
*ptr = ' ';
ptr++;
*ptr = ' ';
ptr++;
line_count++;
}
else
ptr++;
while ( ptr > source_ptr && ( !*ptr || ISSPACE( *ptr ) ) ) ptr--;
defines[defines_count].text = ( char * )calloc( ptr - source_ptr + 2, sizeof( char ) );
strncpy( defines[defines_count].text, source_ptr, ptr - source_ptr + 1 );
defines[defines_count].text[ptr - source_ptr + 1] = 0;
defines_count++;
source_ptr = ptr + 1;
disable_expand_defines--;
return;
}
/* #undef TEXT */
if ( token.code == id_undef )
{
disable_expand_defines++;
token_next();
if ( token.type != IDENTIFIER ) compile_error( MSG_INVALID_IDENTIFIER );
if (( i = find_define( token.code ) ) != -1 )
{
defines_count--;
if ( defines[i].text ) free( defines[i].text );
memmove( &defines[i], &defines[i+1], ( defines_count - i ) * sizeof( DEFINE ) );
}
disable_expand_defines--;
return;
}
/* #ifdef CONST / #ifndef CONST*/
if ( token.code == id_ifdef || token.code == id_ifndef )
{
ifdef = token.code == id_ifdef;
prepro_stack[prepro_sp++] = token.code;
disable_expand_defines++;
token_next();
disable_expand_defines--;
if ( token.type != IDENTIFIER ) compile_error( MSG_INVALID_IDENTIFIER );
SKIP_SPACES_UNTIL_LF_AND_COUNT_LINES;
if ( *source_ptr && *source_ptr != '\n' )
{
if ( ifdef ) compile_warning( "extra tokens at end of #ifdef directive" );
else compile_warning( "extra tokens at end of #ifndef directive" );
SKIP_ALL_UNTIL_LF_AND_COUNT_LINES;
}
if ( *source_ptr == '\n' ) line_count--;
for ( i = 0; i < defines_count; i++ )
{
if ( defines[i].code == token.code )
{
if ( ifdef ) return;
break;
}
}
if ( !ifdef && i == defines_count ) return;
preprocessor_jumpto( id_else, id_endif );
SKIP_SPACES_UNTIL_LF_AND_COUNT_LINES;
if ( *source_ptr && *source_ptr != '\n' )
{
if ( token.code == id_else ) compile_warning( "extra tokens at end of #else directive" );
else if ( token.code == id_endif ) compile_warning( "extra tokens at end of #endif directive" );
SKIP_ALL_UNTIL_LF_AND_COUNT_LINES;
}
if ( *source_ptr == '\n' ) line_count--;
return;
}
/* #if */
if ( token.code == id_if )
{
int actual_sources;
expresion_result res;
char c;
prepro_stack[prepro_sp++] = token.code;
ptr = ( char * ) source_ptr;
while ( *ptr && *ptr != '\n' && *ptr != ';' )
if ( *ptr == '\\' && *( ptr + 1 ) == '\n' )
{
*ptr = ' ';
ptr++;
*ptr = ' ';
ptr++;
line_count++;
}
else
ptr++;
c = *ptr;
*ptr = '\0';
actual_line_count = line_count;
actual_sources = sources;
token_init( source_ptr, current_file );
identifiers_as_strings = 1;
res = compile_expresion( 0, 0, 1, TYPE_DWORD );
identifiers_as_strings = 0;
/*
printf ("exp: asignation: [%d] call: [%d] lvalue: [%d] constant: [%d] value: [%d] lvalue: [%f] type: [%d]\n",
res.asignation,
res.call,
res.lvalue,
res.constant,
res.value,
res.fvalue,
typedef_base(res.type));
*/
if ( sources != actual_sources ) token_endfile();
*ptr = c;
source_ptr = ptr;
line_count = actual_line_count;
SKIP_SPACES_UNTIL_LF_AND_COUNT_LINES;
if ( *source_ptr && *source_ptr != '\n' )
{
compile_warning( "extra tokens at end of #if directive" );
SKIP_ALL_UNTIL_LF_AND_COUNT_LINES;
}
if ( *source_ptr == '\n' ) line_count--;
use_saved = 0;
if ( !res.constant ) compile_error( MSG_CONSTANT_EXP );
if ( !res.value )
{
preprocessor_jumpto( id_else, id_endif );
SKIP_SPACES_UNTIL_LF_AND_COUNT_LINES;
if ( *source_ptr && *source_ptr != '\n' )
{
if ( token.code == id_else ) compile_warning( "extra tokens at end of #else directive" );
else if ( token.code == id_endif ) compile_warning( "extra tokens at end of #endif directive" );
SKIP_ALL_UNTIL_LF_AND_COUNT_LINES;
}
if ( *source_ptr == '\n' ) line_count--;
}
return;
}
/* #else */
if ( token.code == id_else )
{
if ( !prepro_sp ) compile_error( "#else without #if" );
int stck_code = prepro_stack[--prepro_sp];
if ( prepro_sp < 0 ||
(
stck_code != id_if &&
stck_code != id_ifdef &&
stck_code != id_ifndef
)
)
{
if ( stck_code == id_else )
{
compile_error( "#else after #else" );
}
else
{
compile_error( "#else without #if" );
}
}
prepro_stack[prepro_sp++] = token.code;
SKIP_SPACES_UNTIL_LF_AND_COUNT_LINES;
if ( *source_ptr && *source_ptr != '\n' )
{
compile_warning( "extra tokens at end of #else directive" );
SKIP_ALL_UNTIL_LF_AND_COUNT_LINES;
}
if ( *source_ptr == '\n' ) line_count--;
preprocessor_jumpto( id_endif, 0 );
SKIP_SPACES_UNTIL_LF_AND_COUNT_LINES;
if ( *source_ptr && *source_ptr != '\n' )
{
compile_warning( "extra tokens at end of #endif directive" );
SKIP_ALL_UNTIL_LF_AND_COUNT_LINES;
}
if ( *source_ptr == '\n' ) line_count--;
return;
}
/* #endif */
if ( token.code == id_endif )
{
int stck_code = prepro_stack[--prepro_sp];
if ( prepro_sp < 0 || (
stck_code != id_else &&
stck_code != id_if &&
stck_code != id_ifdef &&
stck_code != id_ifndef ) ) compile_error( "#endif without #if" );
SKIP_SPACES_UNTIL_LF_AND_COUNT_LINES;
if ( *source_ptr == '\n' ) line_count--;
return;
}
/* Unknown preprocessor directive */
compile_error( MSG_UNKNOWN_PREP );
}
/* 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;
skipblanks();
#ifndef NO_DEPRECATED
if (isRoot(ch)) {
if (!(pfx_flags & PFX_ALLOW_ROOT)) {
compile_error(-/*ROOT is deprecated*/25);
LONGJMP(file.jbSkipLine);
}
if (root_depr_count < 5) {
compile_warning(-/*ROOT is deprecated*/25);
if (++root_depr_count == 5)
compile_warning(/*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 */
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)) {
compile_error(-/*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)) {
compile_error(-/*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)) {
compile_error(-/*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;
if (i == 0) {
osfree(name);
if (!f_optional) {
if (isEol(ch)) {
if (fSurvey) {
compile_error(-/*Expecting survey name*/89);
} else {
compile_error(-/*Expecting station name*/28);
}
} else {
compile_error(-/*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 */
} 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)) {
compile_error(/*“%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) {
const char *filename_store = file.filename;
unsigned int line_store = file.line;
prefix *survey = ptr;
char *s;
int level;
for (level = ptr->max_export + 1; level; level--) {
survey = survey->up;
SVX_ASSERT(survey);
}
s = osstrdup(sprint_prefix(survey));
if (survey->filename) {
file.filename = survey->filename;
file.line = survey->line;
}
compile_error(/*Station “%s” not exported from survey “%s”*/26,
sprint_prefix(ptr), s);
if (survey->filename) {
file.filename = filename_store;
file.line = line_store;
}
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)) {
compile_warning(/*Separator in survey name*/392);
}
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_error(-/*Field may not be omitted*/8);
} else {
compile_error_token(-/*Expecting numeric field, found “%s”*/9);
}
LONGJMP(file.jbSkipLine);
return 0.0; /* for brain-fried compilers */
}
