strepsirrhini/office-gobmx
9
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
office-gobmx/dmake/getinp.c
Oliver Bolte fabd0ae620 INTEGRATION: CWS dmake48 (1.8.2); FILE MERGED 
2007/03/17 19:00:37 vq 1.8.2.2: #i73499# Add new .WINPATH attribute to generate Windows style paths
(with regular slashes) instead of the default cygwin style (POSIX)
paths for dmake's dynamic macros.

This attribute is specific for cygwin dmake executables and non-cygwin
environments ignore this attribute.

The windows style paths use regular slashes ('/') instead of the
usual windows backslash ('\') as directory separator to avoid quoting
problems (It still is a cygwin dmake!) and cygwin as well as native
windows programs should have no problems using this (c:/foo/bar) path
representation.

The affected macros are $@, $*, $>, $?, $<, $&, $^ and $(PWD),
$(MAKEDIR) and $(TMD).

Examples:

Content of $(PWD) without .WINPATH (default):  /cygdrive/c/temp

Content of $(PWD) with .WINPATH set:           c:/temp
2007/01/23 02:25:52 vq 1.8.2.1: #i10000# Small cosmetic changes.
2007-06-12 05:05:42 +00:00

854 lines
25 KiB
C
Raw Blame History

/* RCS $Id: getinp.c,v 1.9 2007-06-12 06:05:42 obo 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 (Rule_tab from ruletab.c) 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. If fil equals NIL(FILE) then the next line from
*Rule_tab[] is used. Rule_tab is either the buildin rule table or points
to the current environment (used by ReadEnvironment()).
The function returns TRUE if the input file/buffer was read to the end
and FALSE otherwise. */
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 rule_ind to zero after the
* last entry so that 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;
/* fgets() reads at most one less than Buffer_size-pos characters. */
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++;
/* Set q to the last char in p before the \n\0. */
q = p+strlen(p)-2;
if( q >= p ) { /* Only check for special cases if p points
* to a non-empty line. */
/* 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--;
}
/* ignore input if ignore flag set and line ends in a continuation
character. */
if( ignore ) {
if( q[0] != CONTINUATION_CHAR || q[1] != '\n' ) ignore = FALSE;
*p = '\0';
continue;
}
/* If a comment is found the line does not end in \n anymore. */
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; /* Keep the \<nl>. */
}
else {
cont = FALSE;
}
q = ( c == NIL(char) ) ? q+2 : c;
}
else { /* empty line or "" */
cont = FALSE;
ignore = FALSE;
q = p+strlen(p); /* strlen(p) is 1 or 0 */
}
pos += q-p;
}
while( (cont || !*buf) && (pos < Buffer_size-1) );
if( pos >= Buffer_size-1 )
Fatal( "Input line too long, increase MAXLINELENGTH" );
/* Lines that had comments don't contain \n anymore. */
/* ??? Continued lines that are followed by an empty or comment only
* line will end in \<nl>. */
if( (q > p) && (buf[ pos-1 ] == '\n') )
buf[ --pos ] = '\0'; /* Remove the final \n. */
/* 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 {
/* Check/execute if shebang command is present. */
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;
#if defined(MSDOS)
Swap_on_exec = TRUE;
#endif
Wait_for_completion = TRUE;
Do_cmnd(cmnd, FALSE, TRUE, Current_target, A_DEFAULT, TRUE);
#if defined(MSDOS)
Swap_on_exec = FALSE;
#endif
Wait_for_completion = FALSE;
FREE(cmnd);
}
*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 *cst;
char *lhs, *expr, *expr_end;
char *lop;
int result;
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;
/* Remove CONTINUATION_CHAR<nl> and replace with " " so that line
* continuations are recognized as whitespace. */
for( cst=strchr(expr,CONTINUATION_CHAR); cst != NIL(char); cst=strchr(cst,CONTINUATION_CHAR) )
if( cst[1] == '\n' ) {
*cst = ' ';
cst[1] = ' ';
}
else
cst++;
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 ): Opcode: %d\n", n, expr, opcode );
#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); /* Left hand side is empty. */
/* 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 && lhs[0] == '"' ) lhs++;
if ( rhs && rhs[0] == '"' ) rhs++;
/* Empty strings evaluate to zero. */
lint = lhs ? atoi( lhs ) : 0;
rint = rhs ? atoi( rhs ) : 0;
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;
}
Reference in a new issue View git blame Copy permalink