char *GetMacroValue( const char *name ) /********************************************* * Now we need to check for string substitution * $(MACRONAME:oldstring=newstring) */ { char *InName; const char *beforeSub; char *afterSub; char *current; const char *new; const char *old; char *line; InName = StrDupSafe( name ); current = strchr( InName, COLON ); if( current == NULL ) { beforeSub = GetMacroValueProcess( InName ); if( beforeSub == NULL ) { afterSub = NULL; } else { afterSub = StrDupSafe( beforeSub ); } } else { *current++ = NULLCHAR; beforeSub = GetMacroValueProcess( InName ); if( beforeSub == NULL ) { afterSub = NULL; } else { line = NULL; // recursively expand so $(macro:sub) OK if macro contains another if( strchr( beforeSub, DOLLAR ) != NULL ) { UnGetCH( STRM_MAGIC ); InsString( beforeSub, FALSE ); beforeSub = line = DeMacro( TOK_MAGIC ); GetCHR(); // eat STRM_MAGIC } if( beforeSub == NULL ) { afterSub = NULL; } else { if( getOldNewString( current, &old, &new ) == RET_SUCCESS ) { afterSub = doStringSubstitute( beforeSub, old, new ); } else { afterSub = NULL; PrtMsg( ERR | LOC | INVALID_STRING_SUBSTITUTE ); } if( line ) { FreeSafe( line ); } } } }
STATIC char *DeMacroDoubleQuote( BOOLEAN IsDoubleQuote ) /******************************************************* * This procedure takes care of double quotes in the stream * Note: each double quote must be paired with a double quote in the * input stream or this will expand until the EOL a backlash double * quote will be considered as a non-double quote. */ { char buffer[_MAX_PATH]; char *current; char *p; VECSTR OutString; int pos; STRM_T s; BOOLEAN StartDoubleQuote; s = PreGetCH(); UnGetCH( s ); if( s == EOL || s == STRM_END || s == STRM_MAGIC ) { return( StrDupSafe( "" ) ); } if( s == STRM_TMP_LEX_START ) { PreGetCH(); /* Eat STRM_TMP_LEX_START */ pos = 0; for( s = PreGetCH(); s != STRM_MAGIC && pos < _MAX_PATH; s = PreGetCH() ) { assert( s != EOL || s != STRM_END ); buffer[pos++] = s; } if( pos >= _MAX_PATH ) { PrtMsgExit(( FTL | LOC | MAXIMUM_TOKEN_IS, _MAX_PATH - 1 )); // NOTREACHED } buffer[pos] = NULLCHAR; p = StrDupSafe( buffer ); } else { p = DeMacro( MAC_WS ); } StartDoubleQuote = IsDoubleQuote; for( current = p; *current != NULLCHAR; ++current ) { if( *current == DOUBLEQUOTE ) { if( !IsDoubleQuote ) { /* Found the start of a Double Quoted String */ if( current != p ) { UnGetCH( STRM_MAGIC ); InsString( StrDupSafe( current ), TRUE ); UnGetCH( STRM_TMP_LEX_START ); *current = NULLCHAR; return( p ); } IsDoubleQuote = TRUE; } else { /* Found the end of the Double Quoted String */ if( *(current + 1) != NULLCHAR) { UnGetCH( STRM_MAGIC ); InsString( StrDupSafe( current + 1 ), TRUE ); UnGetCH( STRM_TMP_LEX_START ); *(current + 1) = NULLCHAR; } return( p ); } } } if( !StartDoubleQuote && !IsDoubleQuote ) { /* there are no double quotes in the text */ /* so return text as is */ return( p ); } pos = 0; s = PreGetCH(); while( isws( s ) ) { buffer[pos++] = s; s = PreGetCH(); } buffer[pos] = NULLCHAR; UnGetCH( s ); OutString = StartVec(); CatStrToVec( OutString, p ); FreeSafe( p ); CatStrToVec( OutString, buffer ); p = DeMacroDoubleQuote( TRUE ); CatStrToVec( OutString, p ); FreeSafe( p ); return( FinishVec( OutString ) ); }
TOKEN_T LexPath( STRM_T s ) /********************************* * returns: ({filec}*";")+ TOK_PATH * EOL EOL * STRM_END STRM_END */ { char path[_MAX_PATH]; char string_open; unsigned pos; VECSTR vec; /* we'll store file/path here */ for( ;; ) { /* get first valid character */ if( s == EOL || s == STRM_END ) { /* now we pass this to LexParser() so that it can reset */ return( LexParser( s ) ); } if( s == STRM_MAGIC ) { InsString( DeMacro( TOK_EOL ), TRUE ); } else if( !isfilec( s ) && s != PATH_SPLIT && s != ';' && s != '\"' && !isws( s ) ) { PrtMsg( ERR | LOC | EXPECTING_M, M_PATH ); } else if( !isws( s ) ) { break; } s = PreGetCH(); /* keep fetching characters */ } /* just so you know what we've got now */ assert( isfilec( s ) || s == PATH_SPLIT || s == ';' || s == '\"' ); vec = StartVec(); pos = 0; for( ;; ) { /* * Extract path from stream. If double quote is found, start string mode * and ignore all filename character specifiers and just copy all * characters. String mode ends with another double quote. Backslash can * be used to escape only double quotes, otherwise they are recognized * as path seperators. If we are not in string mode character validity * is checked against isfilec(). */ string_open = 0; while( pos < _MAX_PATH && s != EOL && s != STRM_END ) { if( s == BACKSLASH ) { s = PreGetCH(); if( s == DOUBLEQUOTE ) { path[pos++] = DOUBLEQUOTE; } else if( s == EOL || s == STRM_END ) { // Handle special case when backslash is placed at end of // line or file path[pos++] = BACKSLASH; } else { path[pos++] = BACKSLASH; // make sure we don't cross boundaries if( pos < _MAX_PATH ) { path[pos++] = s; } } } else { if( s == DOUBLEQUOTE ) { string_open = !string_open; } else { if( string_open ) { path[pos++] = s; } else if( isfilec( s ) ) { path[pos++] = s; } else { break; // not valid path character, break out. } } } s = PreGetCH(); } if( string_open ) { FreeSafe( FinishVec( vec ) ); PrtMsgExit(( FTL | LOC | ERROR_STRING_OPEN )); } if( pos == _MAX_PATH ) { FreeSafe( FinishVec( vec ) ); PrtMsgExit(( FTL | LOC | MAXIMUM_TOKEN_IS, _MAX_PATH - 1 )); // NOTREACHED } path[pos] = NULLCHAR; WriteVec( vec, path ); if( s != PATH_SPLIT && s != ';' ) { break; } pos = 0; path[pos++] = PATH_SPLIT; s = PreGetCH(); /* use Pre here to allow path;&(nl)path */ } UnGetCH( s ); CurAttr.u.ptr = FinishVec( vec ); return( TOK_PATH ); }