// ParseIncludeDirective
//------------------------------------------------------------------------------
bool BFFParser::ParseIncludeDirective( BFFIterator & iter )
{
// Sanity check include depth to detect cyclic includes
if ( s_Depth >= 128 )
{
Error::Error_1035_ExcessiveDepthComplexity( iter );
return false;
}
// we expect a " quoted string
if ( *iter != '"' )
{
Error::Error_1031_UnexpectedCharFollowingDirectiveName( iter, AStackString<>( "include" ), '"' );
return false;
}
BFFIterator stringStart( iter );
stringStart++; // first actual character
// find end of string
if ( iter.ParseToNext( '"' ) == false )
{
Error::Error_1012_UnexpectedEndOfFile( iter );
return false;
}
// unescape and substitute variables
AStackString<> include;
if ( PerformVariableSubstitutions( stringStart, iter, include ) == false )
{
return false;
}
iter++; // skip closing quote before returning
FLOG_INFO( "Including: %s\n", include.Get() );
// open include
// 1) Try current directory
AStackString<> includeToUse;
if (PathUtils::IsFullPath(include) == false)
{
const char * lastSlash = iter.GetFileName().FindLast( NATIVE_SLASH );
lastSlash = lastSlash ? lastSlash : iter.GetFileName().FindLast( OTHER_SLASH );
lastSlash = lastSlash ? ( lastSlash + 1 ): iter.GetFileName().Get(); // file only, truncate to empty
includeToUse.Assign( iter.GetFileName().Get(), lastSlash );
}
includeToUse += include;
AStackString<> includeToUseClean;
NodeGraph::CleanPath( includeToUse, includeToUseClean );
FileStream f;
if ( f.Open( includeToUseClean.Get(), FileStream::READ_ONLY ) == false )
{
Error::Error_1032_UnableToOpenInclude( stringStart, includeToUseClean );
return false;
}
// check if include uses "once" pragma
if ( FBuild::Get().GetDependencyGraph().IsOneUseFile( includeToUseClean ) )
{
// already seen, and uses #once : don't include again
return true;
}
uint64_t includeTimeStamp = FileIO::GetFileLastWriteTime( includeToUseClean );
// read content of include
const uint32_t fileSize = (uint32_t)f.GetFileSize();
AutoPtr< char > mem( (char *)ALLOC( fileSize + 1 ) );
if ( f.Read( mem.Get(), fileSize ) != fileSize )
{
Error::Error_1033_ErrorReadingInclude( stringStart, include, Env::GetLastErr() );
return false;
}
mem.Get()[ fileSize ] = '\000'; // sentinel
BFFParser parser;
const bool pushStackFrame = false; // include is treated as if injected at this point
return parser.Parse( mem.Get(), fileSize, includeToUseClean.Get(), includeTimeStamp, pushStackFrame );
}
// FormatError
//------------------------------------------------------------------------------
void Error::FormatError( const BFFIterator & iter,
uint32_t errNum,
const Function * function,
const char * message, ... )
{
ASSERT( message );
AStackString< 4096 > buffer;
va_list args;
va_start(args, message);
buffer.VFormat( message, args );
va_end( args );
// get human readable info about the position of the error
uint32_t line = 0;
uint32_t column = 0;
const char * lineStart = nullptr;
iter.GetPosInfo( line, column, lineStart );
// convert to full path and '/'->'\' cleanup
const AStackString<> fileName( iter.GetFileName() );
AStackString<> fullPath;
NodeGraph::CleanPath( fileName, fullPath );
// deliberately using OUTPUT here to avoid "Error:" in front
OUTPUT( "%s(%u,%u): FASTBuild Error #%04u - %s%s%s\n",
fullPath.Get(),
line,
column,
errNum,
function ? function->GetName().Get() : "",
function ? "() - " : "",
buffer.Get() );
// find the line end
BFFIterator lineEnd( iter );
while ( !lineEnd.IsAtEnd() )
{
if (( *lineEnd != '\r' ) && ( *lineEnd != '\n' ))
{
lineEnd++;
continue;
}
break;
}
// if line is too crazy to be useful, don't print anything more
size_t lineLength = lineEnd.GetCurrent() - lineStart;
if ( lineLength >= 256 )
{
return;
}
// print the problematic line
AString::Copy( lineStart, buffer.Get(), lineLength );
FLOG_ERROR( "%s", buffer.Get() );
// point to the specific pos where parsing broke
// (taking into account tabs)
char * c = buffer.Get();
const char * end = c + column - 1;
for ( ; c < end; ++c )
{
if ( *c != '\t' )
{
*c = ' ';
}
}
AString::Copy( "^", c, 1 );
FLOG_ERROR( buffer.Get() );
AString::Copy( "\\--here", c, 8 );
FLOG_ERROR( buffer.Get() );
}
// ParseNamedVariableName
//------------------------------------------------------------------------------
/*static*/ bool BFFParser::ParseVariableName( BFFIterator & iter, AString & name, bool & parentScope )
{
// skip over the declaration symbol
ASSERT( *iter == BFF_DECLARE_VAR_INTERNAL ||
*iter == BFF_DECLARE_VAR_PARENT );
parentScope = ( *iter == BFF_DECLARE_VAR_PARENT );
const BFFIterator varNameStart = iter; // include type token in var name
iter++;
// make sure we haven't hit the end of the file
if ( iter.IsAtEnd() )
{
Error::Error_1012_UnexpectedEndOfFile( iter );
return false;
}
if ( *iter == '\'' || *iter == '"' )
{
// parse the string
const BFFIterator openToken = iter;
iter.SkipString( *openToken );
if ( *iter != *openToken )
{
Error::Error_1002_MatchingClosingTokenNotFound( openToken, nullptr, *openToken );
return false;
}
BFFIterator stringStart = openToken;
stringStart++;
// unescape and subsitute embedded variables
AStackString< 256 > value;
if ( PerformVariableSubstitutions( stringStart, iter, value ) == false )
{
return false;
}
iter++; // skip close token
BFFIterator varNameIter( value.Get(), value.GetLength(), iter.GetFileName().Get(), iter.GetFileTimeStamp() );
// sanity check it is a sensible length
if ( value.GetLength() + 1/* '.' will be added */ > MAX_VARIABLE_NAME_LENGTH )
{
Error::Error_1014_VariableNameIsTooLong( varNameIter, (uint32_t)value.GetLength(), (uint32_t)MAX_VARIABLE_NAME_LENGTH );
return false;
}
// sanity check it is a valid variable name
while ( varNameIter.IsAtEnd() == false )
{
if ( varNameIter.IsAtValidVariableNameCharacter() == false )
{
Error::Error_1013_UnexpectedCharInVariableName( varNameIter, nullptr );
return false;
}
varNameIter++;
}
// append '.' to variable name
name = ".";
name.Append( value );
}
else
{
// make sure immediately after the symbol starts a variable name
if ( iter.IsAtValidVariableNameCharacter() == false )
{
Error::Error_1013_UnexpectedCharInVariableName( iter, nullptr );
return false;
}
// find the end of the variable name
iter.SkipVariableName();
const BFFIterator varNameEnd = iter;
// sanity check it is a sensible length
size_t varNameLen = varNameStart.GetDistTo( varNameEnd );
if ( varNameLen > MAX_VARIABLE_NAME_LENGTH )
{
Error::Error_1014_VariableNameIsTooLong( iter, (uint32_t)varNameLen, (uint32_t)MAX_VARIABLE_NAME_LENGTH );
return false;
}
// store variable name
name.Assign( varNameStart.GetCurrent(), varNameEnd.GetCurrent() );
}
ASSERT( name.GetLength() > 0 );
if ( parentScope )
{
// exchange '^' with '.'
ASSERT( BFF_DECLARE_VAR_PARENT == name[0] );
name[0] = BFF_DECLARE_VAR_INTERNAL;
}
return true;
}