812 lines
24 KiB
C
812 lines
24 KiB
C
/* RCS $Id: getinp.c,v 1.5 2004-04-21 14:10:17 svesik Exp $
|
|
--
|
|
-- SYNOPSIS
|
|
-- Handle reading of input.
|
|
--
|
|
-- DESCRIPTION
|
|
-- The code in this file reads the input from the specified stream
|
|
-- into the provided buffer of size Buffer_size. In doing so it deletes
|
|
-- comments. Comments are delimited by the #, and
|
|
-- <nl> character sequences. An exception is \# which
|
|
-- is replaced by # in the input. Line continuations are signalled
|
|
-- at the end of a line and are recognized inside comments.
|
|
-- The line continuation is always <\><nl>.
|
|
--
|
|
-- If the file to read is NIL(FILE) then the Get_line routine returns the
|
|
-- next rule from the builtin rule table if there is one.
|
|
--
|
|
-- AUTHOR
|
|
-- Dennis Vadura, dvadura@dmake.wticorp.com
|
|
--
|
|
-- WWW
|
|
-- http://dmake.wticorp.com/
|
|
--
|
|
-- COPYRIGHT
|
|
-- Copyright (c) 1996,1997 by WTI Corp. All rights reserved.
|
|
--
|
|
-- This program is NOT free software; you can redistribute it and/or
|
|
-- modify it under the terms of the Software License Agreement Provided
|
|
-- in the file <distribution-root>/readme/license.txt.
|
|
--
|
|
-- LOG
|
|
-- Use cvs log to obtain detailed change logs.
|
|
*/
|
|
|
|
#include "extern.h"
|
|
|
|
#define IS_WHITE(A) ((A == ' ') || (A == '\t') || (A == '\n') || (A == '\r'))
|
|
#define SCAN_WHITE(A) \
|
|
while( IS_WHITE(*A) ) A++;
|
|
|
|
static int _is_conditional ANSI((char*));
|
|
static int _handle_conditional ANSI((int, TKSTRPTR));
|
|
|
|
static int rule_ind = 0; /* index of rule when reading Rule_tab */
|
|
static int skip = FALSE; /* if true the skip input */
|
|
|
|
int partcomp( char* lhs, int opcode );
|
|
int parse_complex_expression( char *expr, char **expr_end, int opcode );
|
|
|
|
|
|
PUBLIC int
|
|
Get_line( buf, fil )/*
|
|
======================
|
|
Read a line of input from the file stripping
|
|
off comments. The routine returns TRUE if EOF */
|
|
char *buf;
|
|
FILE *fil;
|
|
{
|
|
extern char **Rule_tab;
|
|
register char *p;
|
|
register char *c;
|
|
char *q;
|
|
char *buf_org;
|
|
static int ignore = FALSE;
|
|
int cont = FALSE;
|
|
int pos = 0;
|
|
int res = 0;
|
|
register char *tmp = NIL(char);
|
|
|
|
DB_ENTER( "Get_line" );
|
|
|
|
if( Skip_to_eof ) {
|
|
Skip_to_eof = FALSE;
|
|
rule_ind = 0;
|
|
|
|
if( Verbose & V_MAKE )
|
|
Warning("Ignoring remainder of file %s", Filename());
|
|
|
|
DB_RETURN(TRUE);
|
|
}
|
|
|
|
if( fil == NIL(FILE) ) {
|
|
/* Reading the internal rule table. Set the rule_index to zero.
|
|
* This way ReadEnvironment works as expected every time. */
|
|
|
|
while( (p = Rule_tab[ rule_ind++ ]) != NIL(char) )
|
|
/* The last test in this if *p != '~', handles the environment
|
|
* passing conventions used by MKS to pass arguments. We want to
|
|
* skip those environment entries. Also CYGWIN likes to export '!'
|
|
* prefixed environment variables that cause severe pain, axe them too */
|
|
if( !Readenv || (Readenv && (strchr(p,'=') != NIL(char)) && *p!='~' && *p!='!')){
|
|
strcpy( buf, p );
|
|
|
|
DB_PRINT( "io", ("Returning [%s]", buf) );
|
|
DB_RETURN( FALSE );
|
|
}
|
|
|
|
rule_ind = 0;
|
|
|
|
DB_PRINT( "io", ("Done Ruletab") );
|
|
DB_RETURN( TRUE );
|
|
}
|
|
|
|
buf_org = buf;
|
|
|
|
do_again:
|
|
do {
|
|
p = buf+pos;
|
|
if(feof( fil ) || (fgets( p, Buffer_size-pos, fil ) == NIL(char)))
|
|
DB_RETURN( TRUE );
|
|
|
|
#ifdef _MPW
|
|
if ( p[0] == 10 && p[1] == COMMENT_CHAR)
|
|
p[0] = ' ';
|
|
#endif
|
|
|
|
Line_number++;
|
|
|
|
/* ignore input if ignore flag set and line ends in a continuation
|
|
character. */
|
|
q = p+strlen(p)-2;
|
|
if( q<p ) q=p;
|
|
|
|
/* ignore each RETURN at the end of a line before any further
|
|
* processing */
|
|
if( q[0] == '\r' && q[1] == '\n' ) {
|
|
q[0] = '\n';
|
|
q[1] = '\0';
|
|
q--;
|
|
}
|
|
/* you also have to deal with END_OF_FILE chars to process raw
|
|
* DOS-Files. Normally they are the last chars in file, but after
|
|
* working on these file with vi, there is an additional NEWLINE
|
|
* after the last END_OF_FILE. So if the second last char in the
|
|
* actual line is END_OF_FILE, you can skip the last char. Then
|
|
* you can search the line back until you find no more END_OF_FILE
|
|
* and nuke each you found by string termination. */
|
|
if( q[0] == '\032' )
|
|
q--;
|
|
while( q[1] == '\032' ) {
|
|
q[1] = '\0';
|
|
q--;
|
|
}
|
|
|
|
if( ignore ) {
|
|
if( q[0] != CONTINUATION_CHAR || q[1] != '\n' ) ignore = FALSE;
|
|
*p = '\0';
|
|
continue;
|
|
}
|
|
|
|
c = Do_comment(p, &q, Group || (*buf == '\t') || (Notabs && *buf ==' '));
|
|
|
|
/* Does the end of the line end in a continuation sequence? */
|
|
|
|
if( (q[0] == CONTINUATION_CHAR) && (q[1] == '\n')) {
|
|
/* If the continuation was at the end of a comment then ignore the
|
|
* next input line, (or lines until we get one ending in just <nl>)
|
|
* else it's a continuation, so build the input line from several
|
|
* text lines on input. The maximum size of this is governened by
|
|
* Buffer_size */
|
|
if( q != p && q[-1] == CONTINUATION_CHAR ) {
|
|
strcpy( q, q+1 );
|
|
q--;
|
|
cont = FALSE;
|
|
}
|
|
else if( c != NIL(char) )
|
|
ignore = TRUE;
|
|
else
|
|
cont = TRUE;
|
|
}
|
|
else {
|
|
cont = FALSE;
|
|
}
|
|
|
|
q = ( c == NIL(char) ) ? q+2 : c;
|
|
pos += q-p;
|
|
}
|
|
while( (cont || !*buf) && (pos <= Buffer_size) );
|
|
|
|
if( buf[ pos-1 ] == '\n' )
|
|
buf[ --pos ] = '\0';
|
|
else
|
|
if( pos == Buffer_size-1 )
|
|
Fatal( "Input line too long, increase MAXLINELENGTH" );
|
|
|
|
/* STUPID AUGMAKE uses "include" at the start of a line as
|
|
* a signal to include a new file, so let's look for it.
|
|
* if we see it replace it by .INCLUDE: and stick this back
|
|
* into the buffer. We also allow GNU make if[n]eq/else/endif.
|
|
*
|
|
* These substitutions are made only if we are not parsing a group
|
|
* recipe. */
|
|
if( (p = DmStrSpn(buf, " \t\r\n")) == NIL(char) )
|
|
p = buf;
|
|
|
|
if (!Group) {
|
|
if( !strncmp( "include", p, 7 ) &&
|
|
(p[7] == ' ' || p[7] == '\t') )
|
|
tmp = DmStrJoin( ".INCLUDE:", p+7, -1, FALSE );
|
|
else if( !strncmp( "ifeq", p, 4 ) &&
|
|
(p[4] == ' ' || p[4] == '\t') )
|
|
tmp = DmStrJoin( ".IFEQ", p+4, -1, FALSE );
|
|
else if( !strncmp( "ifneq", p, 5 ) &&
|
|
(p[5] == ' ' || p[5] == '\t') )
|
|
tmp = DmStrJoin( ".IFNEQ", p+5, -1, FALSE );
|
|
else if( !strncmp( "elif", p, 4 ) &&
|
|
(p[4] == ' ' || p[4] == '\t') )
|
|
tmp = DmStrJoin( ".ELIF", p+4, -1, FALSE );
|
|
else if( !strncmp( "else", p, 4 ) &&
|
|
(p[4] == ' ' || p[4] == '\t' || p[4] == '\0') )
|
|
tmp = DmStrJoin( ".ELSE", p+4, -1, FALSE );
|
|
else if( !strncmp( "endif", p, 5 ) &&
|
|
(p[5] == ' ' || p[5] == '\t' || p[5] == '\0') )
|
|
tmp = DmStrJoin( ".END", p+5, -1, FALSE );
|
|
}
|
|
|
|
if( tmp != NIL(char)) {
|
|
strcpy( buf, tmp );
|
|
FREE( tmp );
|
|
tmp = NIL(char);
|
|
}
|
|
|
|
/* Now that we have the next line of input to make, we should check to
|
|
* see if it is a conditional expression. If it is then process it,
|
|
* otherwise pass it on to the parser. */
|
|
|
|
if( *(p = DmStrSpn(buf, " \t\r\n")) == CONDSTART ) {
|
|
TKSTR token;
|
|
|
|
SET_TOKEN( &token, p );
|
|
|
|
p = Get_token( &token, "", FALSE );
|
|
|
|
if( (res = _is_conditional(p)) != 0 ) /* ignore non-control special */
|
|
{ /* targets */
|
|
res = _handle_conditional( res, &token );
|
|
skip = TRUE;
|
|
}
|
|
else {
|
|
CLEAR_TOKEN( &token );
|
|
res = TRUE;
|
|
}
|
|
}
|
|
|
|
if( skip ) {
|
|
buf = buf_org; /* ignore line just read in */
|
|
pos = 0;
|
|
skip = res;
|
|
goto do_again;
|
|
}
|
|
|
|
DB_PRINT( "io", ("Returning [%s]", buf) );
|
|
DB_RETURN( FALSE );
|
|
}
|
|
|
|
|
|
PUBLIC char *
|
|
Do_comment(str, pend, keep)/*
|
|
=============================
|
|
Search the input string looking for comment chars. If it contains
|
|
comment chars then NUKE the remainder of the line, if the comment
|
|
char is preceeded by \ then shift the remainder of the line left
|
|
by one char. */
|
|
char *str;
|
|
char **pend;
|
|
int keep;
|
|
{
|
|
char *c = str;
|
|
|
|
while( (c = strchr(c, COMMENT_CHAR)) != NIL(char) ) {
|
|
if( Comment || State == NORMAL_SCAN )
|
|
if( c != str && c[-1] == ESCAPE_CHAR ) {
|
|
strcpy( c-1, c ); /* copy it left, due to \# */
|
|
if( pend ) (*pend)--; /* shift tail pointer left */
|
|
}
|
|
else {
|
|
if( !No_exec
|
|
&& c == str
|
|
&& c[1] == '!'
|
|
&& Line_number == 1
|
|
&& Nestlevel() == 1 ) {
|
|
char *cmnd;
|
|
|
|
cmnd = Expand(c+2);
|
|
cmnd[strlen(cmnd)-1] = '\0'; /* strip last newline */
|
|
Current_target = Root;
|
|
Swap_on_exec = TRUE;
|
|
Wait_for_completion = TRUE;
|
|
Do_cmnd(cmnd, FALSE, TRUE, Current_target, FALSE, FALSE, TRUE);
|
|
}
|
|
|
|
*c = '\0'; /* a true comment so break */
|
|
break;
|
|
}
|
|
else {
|
|
if( keep )
|
|
c = NIL(char);
|
|
else
|
|
*c = '\0';
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
return(c);
|
|
}
|
|
|
|
|
|
PUBLIC char *
|
|
Get_token( string, brk, anchor )/*
|
|
==================================
|
|
Return the next token in string.
|
|
|
|
Returns empty string when no more tokens in string.
|
|
brk is a list of chars that also cause breaks in addition to space and
|
|
tab, but are themselves returned as tokens. if brk is NULL then the
|
|
remainder of the line is returned as a single token.
|
|
|
|
'anchor' if 1, says break on chars in the brk list, but only if
|
|
the entire token begins with the first char of the brk list, if
|
|
0 then any char of brk will cause a break to occurr.
|
|
|
|
If 'anchor' is 2, then break only seeing the first char in the break
|
|
list allowing only chars in the break list to form the prefix. */
|
|
|
|
TKSTRPTR string;
|
|
char *brk;
|
|
int anchor;
|
|
{
|
|
register char *s;
|
|
register char *curp = 0;
|
|
register char *t;
|
|
int done = FALSE;
|
|
char space[100];
|
|
|
|
DB_ENTER( "Get_token" );
|
|
|
|
s = string->tk_str; /* Get string parameters */
|
|
*s = string->tk_cchar; /* ... and strip leading w/s */
|
|
|
|
SCAN_WHITE( s );
|
|
|
|
DB_PRINT( "tok", ("What's left [%s]", s) );
|
|
|
|
if( !*s ) {
|
|
DB_PRINT( "tok", ("Returning NULL token") );
|
|
DB_RETURN( "" );
|
|
}
|
|
|
|
|
|
/* Build the space list. space contains all those chars that may possibly
|
|
* cause breaks. This includes the brk list as well as white space. */
|
|
|
|
if( brk != NIL(char) ) {
|
|
strcpy( space, " \t\r\n" );
|
|
strcat( space, brk );
|
|
}
|
|
else {
|
|
space[0] = 0xff; /* a char we know will not show up */
|
|
space[1] = 0;
|
|
}
|
|
|
|
|
|
/* Handle processing of quoted tokens. Note that this is disabled if
|
|
* brk is equal to NIL */
|
|
|
|
while( *s == '\"' && ((brk != NIL(char)) || !string->tk_quote) ) {
|
|
s++;
|
|
if( string->tk_quote ) {
|
|
curp = s-1;
|
|
do { curp = strchr( curp+1, '\"' ); }
|
|
while( (curp != NIL(char)) && (*(curp+1) == '\"'));
|
|
|
|
if( curp == NIL(char) ) Fatal( "Unmatched quote in token" );
|
|
string->tk_quote = !string->tk_quote;
|
|
|
|
/* Check for "" case, and if found ignore it */
|
|
if( curp == s ) continue;
|
|
goto found_token;
|
|
}
|
|
else
|
|
SCAN_WHITE( s );
|
|
|
|
string->tk_quote = !string->tk_quote;
|
|
}
|
|
|
|
|
|
/* Check for a token break character at the beginning of the token.
|
|
* If found return the next set of break chars as a token. */
|
|
|
|
if( anchor == 2 && brk != NIL(char) ) {
|
|
curp = s;
|
|
while( *curp && (strchr(brk,*curp)!=NIL(char)) && (*curp!=*brk) ) curp++;
|
|
done = (*brk == *curp++);
|
|
}
|
|
else if( (brk != NIL(char)) && (strchr( brk, *s ) != NIL(char)) ) {
|
|
curp = DmStrSpn( s, brk );
|
|
done = (anchor == 0) ? TRUE :
|
|
((anchor == 1)?(*s == *brk) : (*brk == curp[-1]));
|
|
}
|
|
|
|
|
|
/* Scan for the next token in the list and return it less the break char
|
|
* that was used to terminate the token. It will possibly be returned in
|
|
* the next call to Get_token */
|
|
|
|
if( !done ) {
|
|
SCAN_WHITE( s );
|
|
|
|
t = s;
|
|
do {
|
|
done = TRUE;
|
|
curp = DmStrPbrk(t, space);
|
|
|
|
if( anchor && *curp && !IS_WHITE( *curp ) )
|
|
if( ((anchor == 1)?*curp:DmStrSpn(curp,brk)[-1]) != *brk ) {
|
|
t++;
|
|
done = FALSE;
|
|
}
|
|
}
|
|
while( !done );
|
|
|
|
if( (curp == s) && (strchr(brk, *curp) != NIL(char)) ) curp++;
|
|
}
|
|
|
|
found_token:
|
|
string->tk_str = curp;
|
|
string->tk_cchar = *curp;
|
|
*curp = '\0';
|
|
|
|
DB_PRINT( "tok", ("Returning [%s]", s) );
|
|
DB_RETURN( s );
|
|
}
|
|
|
|
|
|
static int
|
|
_is_conditional( tg )/*
|
|
=======================
|
|
Look at tg and return it's value if it is a conditional identifier
|
|
otherwise return 0. */
|
|
char *tg;
|
|
{
|
|
DB_ENTER( "_is_conditional" );
|
|
|
|
tg++;
|
|
switch( *tg )
|
|
{
|
|
case 'I':
|
|
if( !strcmp( tg, "IF" )) DB_RETURN( ST_IF );
|
|
else if( !strcmp( tg, "IFEQ" )) DB_RETURN( ST_IFEQ );
|
|
else if( !strcmp( tg, "IFNEQ" )) DB_RETURN( ST_IFNEQ );
|
|
break;
|
|
|
|
case 'E':
|
|
if( !strcmp( tg, "END" )) DB_RETURN( ST_END );
|
|
else if( !strcmp( tg, "ENDIF")) DB_RETURN( ST_END );
|
|
else if( !strcmp( tg, "ELSE" )) DB_RETURN( ST_ELSE );
|
|
else if( !strcmp( tg, "ELIF" )) DB_RETURN( ST_ELIF );
|
|
break;
|
|
}
|
|
|
|
DB_RETURN( 0 );
|
|
}
|
|
|
|
|
|
|
|
#define SEEN_END 0x00
|
|
#define SEEN_IF 0x01
|
|
#define SEEN_ELSE 0x02
|
|
#define SEEN_ELIF 0x04
|
|
|
|
#define ACCEPT_IF 0x10
|
|
#define ACCEPT_ELIF 0x20
|
|
|
|
static int
|
|
_handle_conditional( opcode, tg )
|
|
int opcode;
|
|
TKSTRPTR tg;
|
|
{
|
|
static short action[MAX_COND_DEPTH];
|
|
static char ifcntl[MAX_COND_DEPTH];
|
|
char *lhs, *expr, *expr_end;
|
|
char *lop, *partstr;
|
|
int result, n, m;
|
|
|
|
DB_ENTER( "_handle_conditional" );
|
|
|
|
switch( opcode ) {
|
|
case ST_ELIF:
|
|
if( !(ifcntl[Nest_level] & SEEN_IF) || (ifcntl[Nest_level]&SEEN_ELSE) )
|
|
Fatal(".ELIF without a preceeding .IF" );
|
|
/*FALLTHRU*/
|
|
|
|
case ST_IF:
|
|
case ST_IFEQ:
|
|
case ST_IFNEQ:
|
|
if( opcode != ST_ELIF && (Nest_level+1) == MAX_COND_DEPTH )
|
|
Fatal( ".IF .ELSE ... .END nesting too deep" );
|
|
|
|
If_expand = TRUE;
|
|
expr = Expand( Get_token( tg, NIL(char), FALSE ));
|
|
If_expand = FALSE;
|
|
lhs = DmStrSpn( expr, " \t" );
|
|
if( !*lhs ) lhs = NIL(char);
|
|
|
|
/* Don't support C-style define keyword */
|
|
if ( (lop = DmStrStr(lhs, "defined" )) != NIL(char) )
|
|
Fatal( ".IF do not support defined " );
|
|
if ( (lop = DmStrStr(lhs, "DEFINED" )) != NIL(char) )
|
|
Fatal( ".IF do not support defined " );
|
|
|
|
lhs = expr;
|
|
SCAN_WHITE( lhs );
|
|
/* Parse the expression and get its logical result */
|
|
if ( ((lop = DmStrStr(lhs, "||" )) != NIL(char)) || ((lop = DmStrStr(lhs, "&&" )) != NIL(char)) )
|
|
result = parse_complex_expression( lhs, &expr_end, opcode );
|
|
else
|
|
result = partcomp( lhs, opcode );
|
|
|
|
if( expr != NIL(char) ) FREE( expr );
|
|
|
|
if( opcode != ST_ELIF ) {
|
|
Nest_level++;
|
|
action[Nest_level] = 1;
|
|
}
|
|
ifcntl[Nest_level] |= (opcode==ST_ELIF)?SEEN_ELIF:SEEN_IF;
|
|
|
|
if( result ) {
|
|
if( !(ifcntl[Nest_level] & (ACCEPT_IF|ACCEPT_ELIF)) ) {
|
|
action[ Nest_level ] = action[ Nest_level-1 ];
|
|
ifcntl[Nest_level] |= (opcode==ST_ELIF)?ACCEPT_ELIF:ACCEPT_IF;
|
|
}
|
|
else
|
|
action[Nest_level] = 1;
|
|
}
|
|
else
|
|
action[Nest_level] = 1;
|
|
break;
|
|
|
|
case ST_ELSE:
|
|
if( Nest_level <= 0 ) Fatal( ".ELSE without .IF" );
|
|
if( ifcntl[Nest_level] & SEEN_ELSE )
|
|
Fatal( "Missing .IF or .ELIF before .ELSE" );
|
|
|
|
if( ifcntl[Nest_level] & (ACCEPT_IF|ACCEPT_ELIF) )
|
|
action[Nest_level] = 1;
|
|
else if( action[ Nest_level-1 ] != 1 )
|
|
action[ Nest_level ] ^= 0x1; /* flip between 0 and 1 */
|
|
|
|
ifcntl[Nest_level] |= SEEN_ELSE;
|
|
break;
|
|
|
|
case ST_END:
|
|
ifcntl[Nest_level] = SEEN_END;
|
|
Nest_level--;
|
|
if( Nest_level < 0 ) Fatal( "Unmatched .END[IF]" );
|
|
break;
|
|
}
|
|
|
|
DB_RETURN( action[ Nest_level ] );
|
|
}
|
|
|
|
/* uncomment to turn on expression debug statements */
|
|
/*#define PARSE_DEBUG /* */
|
|
#define PARSE_SKIP_WHITE(A) while( *A && ((*A==' ') || (*A=='\t')) ) A++;
|
|
|
|
#define OP_NONE 0
|
|
#define OP_AND 1
|
|
#define OP_OR 2
|
|
|
|
static int n = 1;
|
|
|
|
int parse_complex_expression( char *expr, char **expr_end, int opcode )
|
|
{
|
|
char *p = expr;
|
|
char *term_start = p;
|
|
char *term_end;
|
|
int local_term;
|
|
char *part;
|
|
int term_result = FALSE;
|
|
int final_result = TRUE;
|
|
unsigned int term_len;
|
|
unsigned int last_op = OP_NONE;
|
|
|
|
#ifdef PARSE_DEBUG
|
|
printf( "%d: parse_complex_expression( %s ): %d\n", n, expr, match_paren );
|
|
#endif
|
|
|
|
while ( 1 )
|
|
{
|
|
/* A new sub-expression */
|
|
local_term = TRUE;
|
|
if ( *p == '(' )
|
|
{
|
|
n++;
|
|
term_result = parse_complex_expression( p+1, &p, opcode );
|
|
n--;
|
|
PARSE_SKIP_WHITE( p );
|
|
term_start = p;
|
|
term_end = p;
|
|
local_term = FALSE;
|
|
}
|
|
else
|
|
term_end = p;
|
|
|
|
/* Lets do an operation!! */
|
|
if ( !(*p) /* at the end of the entire line */
|
|
|| ((*p == '&') && (*(p+1) && (*(p+1)=='&'))) /* found an && */
|
|
|| ((*p == '|') && (*(p+1) && (*(p+1)=='|'))) /* found an || */
|
|
|| (*p == ')') ) /* at the end of our term */
|
|
{
|
|
/* Grab the sub-expression if we parsed it. Otherwise,
|
|
* it was a () subexpression and we don't need to evaluate
|
|
* it since that was already done.
|
|
*/
|
|
if ( local_term == TRUE )
|
|
{
|
|
/* Back up 1 to the end of the actual term */
|
|
term_end--;
|
|
|
|
/* Evaluate the term */
|
|
PARSE_SKIP_WHITE( term_start );
|
|
term_len = term_end - term_start + 1;
|
|
part = MALLOC( term_len + 1, char );
|
|
strncpy( part, term_start, term_len );
|
|
*(part+term_len) = '\0';
|
|
#ifdef PARSE_DEBUG
|
|
printf( "%d: evaling '%s'\n", n, part );
|
|
#endif
|
|
term_result = partcomp( part, opcode );
|
|
#ifdef PARSE_DEBUG
|
|
printf( "%d: evaled, result %d\n", n, term_result );
|
|
#endif
|
|
FREE( part );
|
|
}
|
|
|
|
/* Do the actual logical operation using the _preceding_
|
|
* logical operator, NOT the one we just found.
|
|
*/
|
|
if ( last_op == OP_AND )
|
|
final_result = final_result && term_result;
|
|
else if ( last_op == OP_OR )
|
|
final_result = final_result || term_result;
|
|
else
|
|
final_result = term_result;
|
|
#ifdef PARSE_DEBUG
|
|
printf( "%d: final_result:%d\n", n, final_result );
|
|
#endif
|
|
|
|
/* If we're not at the end of the line, just keep going */
|
|
if ( *p )
|
|
{
|
|
/* Recognize the operator we just found above */
|
|
if ( *p == '&' )
|
|
last_op = OP_AND;
|
|
else if ( *p == '|' )
|
|
last_op = OP_OR;
|
|
if ( *p != ')' )
|
|
p += 2;
|
|
|
|
/* Get the start of the next term */
|
|
PARSE_SKIP_WHITE( p );
|
|
term_start = p;
|
|
|
|
/* If this is the close of a term, we are done and return
|
|
* to our caller.
|
|
*/
|
|
if ( *p == ')' )
|
|
{
|
|
p++;
|
|
break;
|
|
}
|
|
}
|
|
else break; /* At end of line, all done */
|
|
}
|
|
else if ( local_term == TRUE ) p++; /* Advance to next char in expression */
|
|
}
|
|
*expr_end = p;
|
|
|
|
#ifdef PARSE_DEBUG
|
|
printf( "%d: done, returning '%s', result %d\n", n, *expr_end, final_result );
|
|
#endif
|
|
return( final_result );
|
|
}
|
|
|
|
|
|
int partcomp( char* lhs, int opcode )
|
|
{
|
|
|
|
char *tok, *rhs, *op = 0;
|
|
int result, opsind;
|
|
const int localopscount=4;
|
|
char* localops[] = { "==", "!=", "<=", ">=" };
|
|
int lint, rint;
|
|
|
|
#define EQUAL 0
|
|
#define NOTEQUAL 1
|
|
#define LESS_EQUAL 2
|
|
#define GREATER_EQUAL 3
|
|
|
|
#ifdef PARSE_DEBUG
|
|
printf( "eval: %s\n", lhs);
|
|
#endif
|
|
|
|
opsind = 0;
|
|
if( opcode == ST_IFEQ || opcode == ST_IFNEQ )
|
|
{
|
|
/* IF[N]EQ syntax is: .IF[N]EQ <1> <2>
|
|
* Here, step over first argument and get to <2> if it exists.
|
|
*/
|
|
for( op = lhs; ((*op)&&(*op != ' ')&&(*op != '\t')); op++ );
|
|
if( *op ) op++; /* position op at start of <2> */
|
|
else op = NIL(char); /* only 1 argument given */
|
|
}
|
|
else
|
|
{
|
|
/* Find which logical operator we are to use for this expression,
|
|
* and jump to it */
|
|
while ( (opsind < localopscount) && ((op = DmStrStr(lhs, localops[opsind])) == NIL(char)) )
|
|
opsind++;
|
|
|
|
#ifdef PARSE_DEBUG
|
|
printf(" found op %d: %s\n", opsind, localops[opsind]);
|
|
#endif
|
|
}
|
|
|
|
/* If the opcode was IFEQ or IFNEQ and only 1 argument was given,
|
|
* or an unknown logical operator was encountered,
|
|
* return false if argument is empty string, true if !empty
|
|
*/
|
|
if( op == NIL(char) )
|
|
result = (*lhs != '\0');
|
|
else
|
|
{
|
|
/* Make both characters of the operation the same, replacing the = in op[1]
|
|
* Its easier to deal with this way???
|
|
*/
|
|
if( opcode != ST_IFEQ && opcode != ST_IFNEQ )
|
|
op[1] = op[0];
|
|
|
|
#ifdef PARSE_DEBUG
|
|
printf(" op:%s\n", op);
|
|
#endif
|
|
|
|
/* Isolate the left half of the expression */
|
|
if( lhs != op )
|
|
{
|
|
for( tok = op-1; (tok != lhs) && ((*tok == ' ')||(*tok == '\t')); tok-- );
|
|
tok[1] = '\0';
|
|
}
|
|
else
|
|
lhs = NIL(char);
|
|
|
|
/* Jump over the operation so we can grab the right half of the expression */
|
|
if( opcode == ST_IFEQ || opcode == ST_IFNEQ )
|
|
op--;
|
|
else
|
|
op++;
|
|
|
|
/* Isolate the right half of the expression */
|
|
rhs = DmStrSpn( op+1, " \t" );
|
|
if( !*rhs ) rhs = NIL(char);
|
|
|
|
#ifdef PARSE_DEBUG
|
|
printf(" lhs:%s, rhs:%s\n", lhs, rhs);
|
|
#endif
|
|
|
|
/* Do the actual logical operation on the expression */
|
|
if ( opsind > NOTEQUAL )
|
|
{
|
|
switch( opsind )
|
|
{
|
|
case LESS_EQUAL:
|
|
case GREATER_EQUAL:
|
|
/* Ignore quotes around the arguments */
|
|
if ( lhs[0] == '"' ) lhs++;
|
|
if ( rhs[0] == '"' ) rhs++;
|
|
lint = atoi( lhs );
|
|
rint = atoi( rhs );
|
|
result = ( lint >= rint ) ? TRUE : FALSE;
|
|
if ( opsind == LESS_EQUAL && lint != rint )
|
|
result = !result;
|
|
break;
|
|
default:
|
|
result = FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Use a simple string compare to determine equality */
|
|
if( (rhs == NIL(char)) || (lhs == NIL(char)) )
|
|
result = (rhs == lhs) ? TRUE : FALSE;
|
|
else
|
|
{
|
|
/* String off whitespace at the end of the right half of the expression */
|
|
tok = rhs + strlen( rhs );
|
|
for( tok=tok-1; (tok != lhs) && ((*tok == ' ')||(*tok == '\t')); tok--);
|
|
tok[1] = '\0';
|
|
|
|
result = (strcmp( lhs, rhs ) == 0) ? TRUE : FALSE;
|
|
}
|
|
|
|
if( *op == '!' || opcode == ST_IFNEQ ) result = !result;
|
|
}
|
|
}
|
|
|
|
#ifdef PARSE_DEBUG
|
|
printf("partresult %d\n\n",result);
|
|
#endif
|
|
return result;
|
|
}
|
|
|