bool cxxTokenChainTakeRecursive(CXXTokenChain * tc,CXXToken * t)
{
if(!tc)
return false;
CXXToken * aux = tc->pHead;
while(aux)
{
if(t == aux)
{
cxxTokenChainTake(tc,aux);
return true;
}
if(cxxTokenTypeIsOneOf(
aux,
CXXTokenTypeParenthesisChain | CXXTokenTypeAngleBracketChain |
CXXTokenTypeSquareParenthesisChain | CXXTokenTypeBracketChain
))
{
if(cxxTokenChainTakeRecursive(aux->pChain,t))
return true;
}
aux = aux->pNext;
}
return false;
}
static bool cxxParserSkipToClosingParenthesisOrEOF(void)
{
if(cxxTokenTypeIsOneOf(g_cxx.pToken,CXXTokenTypeClosingParenthesis | CXXTokenTypeEOF))
return true;
return cxxParserParseUpToOneOf(CXXTokenTypeClosingParenthesis | CXXTokenTypeEOF,
false);
}
//
// Parses a template<anything> prefix.
// The parsed template parameter definition is stored in a separate token chain.
//
boolean cxxParserParseTemplatePrefix(void)
{
CXX_DEBUG_ENTER();
CXX_DEBUG_ASSERT(cxxTokenTypeIs(cxxTokenChainLast(g_cxx.pTokenChain),CXXTokenTypeKeyword),"We should be pointing at the template keyword here");
cxxTokenChainDestroyLast(g_cxx.pTokenChain); // kill the template keyword
if(!cxxParserParseUpToOneOf(CXXTokenTypeSmallerThanSign | CXXTokenTypeEOF | CXXTokenTypeSemicolon))
{
CXX_DEBUG_LEAVE_TEXT("Failed to parse up to the < sign");
return FALSE;
}
if(cxxTokenTypeIsOneOf(g_cxx.pToken,CXXTokenTypeEOF | CXXTokenTypeSemicolon))
{
CXX_DEBUG_LEAVE_TEXT("Found EOF or semicolon: assuming this is unparseable");
cxxParserNewStatement();
return TRUE; // tolerate syntax error
}
CXXTokenChain * pSave = g_cxx.pTokenChain;
g_cxx.pTokenChain = cxxTokenChainCreate();
cxxTokenChainAppend(g_cxx.pTokenChain,cxxTokenChainTakeLast(pSave));
if(!cxxParserParseTemplatePrefixAngleBrackets())
{
CXX_DEBUG_LEAVE_TEXT("Failed to parse angle brackets");
cxxTokenChainDestroy(pSave);
return FALSE;
}
if(g_cxx.pTemplateTokenChain)
cxxTokenChainDestroy(g_cxx.pTemplateTokenChain);
g_cxx.pTemplateTokenChain = g_cxx.pTokenChain;
g_cxx.pTokenChain = pSave;
CXX_DEBUG_LEAVE();
return TRUE;
}
boolean cxxParserParseNamespace(void)
{
CXX_DEBUG_ENTER();
CXX_DEBUG_ASSERT(cxxParserCurrentLanguageIsCPP(),"This should be called only in C++");
/*
Spec is:
namespace ns_name { declarations } (1)
inline namespace ns_name { declarations } (2) (since C++11)
namespace { declarations } (3)
namespace name = qualified-namespace ; (7)
namespace ns_name::name { (8) (since C++17)
Note that the using clauses have their own parsing routine and do not end up here.
*/
// namespace <X> {
// namespace <X>::<Y>::<Z> {
// namespace <X>::<Y>::<Z>;
// namespace <X>;
// namespace;
unsigned int uProperties = 0;
if(cxxTagFieldEnabled(CXXTagFieldProperties))
{
if(g_cxx.uKeywordState & CXXParserKeywordStateSeenInline)
uProperties |= CXXTagPropertyInline;
}
cxxParserNewStatement(); // always a new statement
int iScopeCount = 0;
int i;
int aCorkQueueIndices[MAX_NESTED_NAMESPACES];
for(i=0;i<MAX_NESTED_NAMESPACES;i++)
aCorkQueueIndices[i] = CORK_NIL;
if(!cxxParserParseNextToken())
{
// syntax error, but we tolerate this
CXX_DEBUG_LEAVE_TEXT("Implicit EOF in cxxParserParseNextToken");
return TRUE; // EOF
}
if(cxxTokenTypeIs(g_cxx.pToken,CXXTokenTypeIdentifier))
{
// OK, check next token to see what's coming after
CXX_DEBUG_PRINT("Got identifier %s",g_cxx.pToken->pszWord->buffer);
CXXToken * pFirstIdentifier = g_cxx.pToken;
CXXToken * pLastIdentifier = g_cxx.pToken;
if(!cxxParserParseNextToken())
{
// syntax error, but we tolerate this
CXX_DEBUG_LEAVE_TEXT("EOF in cxxParserParseNextToken");
return TRUE; // EOF
}
switch(g_cxx.pToken->eType)
{
case CXXTokenTypeAssignment:
{
// probably namespace alias
CXX_DEBUG_PRINT("Found assignment");
if(!cxxParserParseNextToken())
{
// syntax error, but we tolerate this
CXX_DEBUG_LEAVE_TEXT("EOF in cxxParserParseNextToken");
return TRUE; // EOF
}
if(!cxxTokenTypeIsOneOf(
g_cxx.pToken,
CXXTokenTypeIdentifier | CXXTokenTypeMultipleColons
))
{
CXX_DEBUG_LEAVE_TEXT("Some kind of syntax error here");
return cxxParserSkipToSemicolonOrEOF();
}
CXXToken * pAlias = pFirstIdentifier;
pFirstIdentifier = g_cxx.pToken;
if(!cxxParserParseToEndOfQualifedName())
{
CXX_DEBUG_LEAVE_TEXT("Failed to parse the aliased name");
return cxxParserSkipToSemicolonOrEOF();
}
pLastIdentifier = g_cxx.pToken->pPrev;
tagEntryInfo * tag = cxxTagBegin(CXXTagCPPKindALIAS,pAlias);
if(tag)
{
// This is highly questionable but well.. it's how old ctags did, so we do.
tag->isFileScope = !isInputHeaderFile();
CXXToken * pAliasedName = cxxTokenChainExtractRange(
pFirstIdentifier,
pLastIdentifier,
CXXTokenChainExtractRangeNoTrailingSpaces
);
cxxTagSetField(
CXXTagCPPFieldAliasedName,
vStringValue(pAliasedName->pszWord)
);
cxxTagCommit();
cxxTokenDestroy(pAliasedName);
}
CXX_DEBUG_LEAVE_TEXT("Finished parsing namespace alias");
return cxxParserSkipToSemicolonOrEOF();
}
break;
case CXXTokenTypeMultipleColons:
// multi-namespace
CXX_DEBUG_PRINT("Found multiple colons");
if(!cxxParserParseToEndOfQualifedName())
{
CXX_DEBUG_LEAVE_TEXT("Failed to parse the namespace name");
return cxxParserSkipToSemicolonOrEOF();
}
pLastIdentifier = g_cxx.pToken->pPrev;
CXX_DEBUG_ASSERT(
pFirstIdentifier != pLastIdentifier,
"We expected multiple identifiers here"
);
if(!cxxTokenTypeIs(g_cxx.pToken,CXXTokenTypeOpeningBracket))
{
if(!cxxParserParseUpToOneOf(
CXXTokenTypeOpeningBracket | CXXTokenTypeSemicolon | CXXTokenTypeEOF
))
{
CXX_DEBUG_LEAVE_TEXT("Failed to parse up to an opening bracket");
return FALSE;
}
if(!cxxTokenTypeIs(g_cxx.pToken,CXXTokenTypeOpeningBracket))
{
// tolerate syntax error
CXX_DEBUG_LEAVE_TEXT("Found semicolon just after namespace declaration");
return TRUE;
}
CXX_DEBUG_LEAVE_TEXT("Was expecting an opening bracket here");
// FIXME: Maybe we could attempt to recover here?
return TRUE;
}
break;
case CXXTokenTypeOpeningBracket:
// single name namespace
CXX_DEBUG_PRINT("Found opening bracket");
break;
case CXXTokenTypeSemicolon:
// tolerate syntax error
CXX_DEBUG_LEAVE_TEXT("Found semicolon just after namespace declaration");
return TRUE;
break;
default:
CXX_DEBUG_LEAVE_TEXT("Some kind of syntax error here");
return cxxParserSkipToSemicolonOrEOF();
break;
}
CXX_DEBUG_ASSERT(
cxxTokenTypeIs(g_cxx.pToken,CXXTokenTypeOpeningBracket),
"Should have an opening bracket here!"
);
CXX_DEBUG_PRINT("Found regular namespace start");
CXXToken * t = pFirstIdentifier;
while(t)
{
tagEntryInfo * tag = cxxTagBegin(CXXTagCPPKindNAMESPACE,t);
if(tag)
{
// This is highly questionable but well.. it's how old ctags did, so we do.
tag->isFileScope = !isInputHeaderFile();
vString * pszProperties = uProperties ? cxxTagSetProperties(uProperties) : NULL;
int iCorkQueueIndex = cxxTagCommit();
if(iScopeCount < MAX_NESTED_NAMESPACES)
aCorkQueueIndices[iScopeCount] = iCorkQueueIndex;
if(pszProperties)
vStringDelete(pszProperties);
}
CXXToken * pNext = (t == pLastIdentifier) ? NULL : t->pNext->pNext;
cxxTokenChainTake(g_cxx.pTokenChain,t);
cxxScopePush(
t,
CXXScopeTypeNamespace,
CXXScopeAccessUnknown
);
iScopeCount++;
t = pNext;
}
} else if(cxxTokenTypeIs(g_cxx.pToken,CXXTokenTypeOpeningBracket))
{
// anonymous namespace
CXX_DEBUG_PRINT("Found anonymous namespace start");
CXXToken * t = cxxTokenCreateAnonymousIdentifier(CXXTagCPPKindNAMESPACE);
tagEntryInfo * tag = cxxTagBegin(CXXTagCPPKindNAMESPACE,t);
if(tag)
{
tag->isFileScope = !isInputHeaderFile();
vString * pszProperties = uProperties ? cxxTagSetProperties(uProperties) : NULL;
aCorkQueueIndices[0] = cxxTagCommit();
if(pszProperties)
vStringDelete(pszProperties);
}
cxxScopePush(t,CXXScopeTypeNamespace,CXXScopeAccessUnknown);
iScopeCount++;
} else {
CXX_DEBUG_LEAVE_TEXT("Some kind of syntax error after namespace declaration");
return cxxParserSkipToSemicolonOrEOF();
}
CXX_DEBUG_ASSERT(
cxxTokenTypeIs(g_cxx.pToken,CXXTokenTypeOpeningBracket),
"Should have an opening bracket here!"
);
// Here we certainly got an opening bracket: namespace block
if(!cxxParserParseBlock(TRUE))
{
CXX_DEBUG_LEAVE_TEXT("Failed to parse namespace block");
return FALSE;
}
while(iScopeCount > 0)
{
cxxScopePop();
iScopeCount--;
if(aCorkQueueIndices[iScopeCount] > CORK_NIL)
cxxParserMarkEndLineForTagInCorkQueue(aCorkQueueIndices[iScopeCount]);
}
CXX_DEBUG_LEAVE_TEXT("Finished parsing namespace");
return TRUE;
}
void cxxTokenChainNormalizeTypeNameSpacingInRange(CXXToken * pFrom,CXXToken * pTo)
{
if(!pFrom || !pTo)
return;
// Goals:
// int
// unsigned short int
// int *
// unsigned short int **
// const Class &
// Class &&
// int (*)(type &,type *)
// unsigned short int[3];
// ClassA<ClassB<type *,type>> <-- fixme: not sure about the trailing >>
// Class<Something> (*)(type[])
CXXToken * t = pFrom;
for(;;)
{
if(cxxTokenTypeIsOneOf(
t,
CXXTokenTypeParenthesisChain | CXXTokenTypeSquareParenthesisChain
))
{
cxxTokenChainNormalizeTypeNameSpacing(t->pChain);
t->bFollowedBySpace = false;
} else if(cxxTokenTypeIsOneOf(t,
CXXTokenTypeIdentifier | CXXTokenTypeKeyword |
CXXTokenTypeGreaterThanSign |
CXXTokenTypeAnd | CXXTokenTypeMultipleAnds
))
{
t->bFollowedBySpace = t->pNext &&
cxxTokenTypeIsOneOf(
t->pNext,
CXXTokenTypeParenthesisChain | CXXTokenTypeIdentifier |
CXXTokenTypeKeyword | CXXTokenTypeStar |
CXXTokenTypeAnd | CXXTokenTypeMultipleAnds
);
} else if(cxxTokenTypeIs(t,CXXTokenTypeStar))
{
t->bFollowedBySpace = t->pNext &&
(!cxxTokenTypeIsOneOf(
t->pNext,
CXXTokenTypeStar | CXXTokenTypeComma |
CXXTokenTypeClosingParenthesis
));
} else {
t->bFollowedBySpace = false;
}
if(t == pTo)
break;
t = t->pNext;
}
// Finally the chain has no space at end
pTo->bFollowedBySpace = false;
}
//
// Parses the <parameters> part of the template prefix.
// Here we are pointing at the initial < (but the token chain has been emptied by cxxParserParseTemplatePrefix())
//
static boolean cxxParserParseTemplatePrefixAngleBrackets(void)
{
CXX_DEBUG_ENTER();
// Here we have the big prolem of <> characters which may be
// template argument delimiters, less than/greater than operators, shift left/right operators.
//
// A well written code will have parentheses around all the ambiguous cases. We handle that
// and we permit any kind of syntax inside a parenthesis.
//
// Without parentheses we still try to handle the << and >> shift operator cases:
// - << is always recognized as shift operator
// - >> is recognized as shift unless it's non-nested. This is what C++11 spec says
// and theoretically it should be also pseudo-compatible with C++03 which treats this
// case as a syntax error.
//
// The 'less-than' and 'greater-than' operators are hopeless in the general case: gcc
// is smart enough to figure them out by looking at the identifiers around but without
// proper state (include headers, macro expansion, full type database etc) we simply can't
// do the same. However, we try to recover if we figure out we (or the programmer?) screwed up.
int iTemplateLevel = 0;
for(;;)
{
// Within parentheses everything is permitted.
if(!cxxParserParseAndCondenseSubchainsUpToOneOf(
CXXTokenTypeGreaterThanSign | CXXTokenTypeSmallerThanSign | CXXTokenTypeOpeningBracket | CXXTokenTypeSemicolon | CXXTokenTypeEOF | CXXTokenTypeAssignment,
CXXTokenTypeOpeningParenthesis | CXXTokenTypeOpeningSquareParenthesis
))
{
CXX_DEBUG_LEAVE_TEXT("Failed to parse up to '<>{EOF'");
return FALSE;
}
evaluate_current_token:
switch(g_cxx.pToken->eType)
{
case CXXTokenTypeSmallerThanSign:
if(g_cxx.pToken->pPrev && cxxTokenTypeIsOneOf(g_cxx.pToken->pPrev,CXXTokenTypeIdentifier | CXXTokenTypeKeyword))
{
if(!cxxParserParseNextToken())
{
CXX_DEBUG_LEAVE_TEXT("Syntax error, but tolerate it at this level");
return TRUE;
}
CXX_DEBUG_PRINT("Got token '%s' of type 0x%02x",vStringValue(g_cxx.pToken->pszWord),g_cxx.pToken->eType);
if(cxxTokenTypeIs(g_cxx.pToken,CXXTokenTypeSmallerThanSign))
{
// assume it's an operator
CXX_DEBUG_PRINT("Treating < as shift-left operator");
} else {
CXX_DEBUG_PRINT("Increasing template level");
iTemplateLevel++;
if(cxxTokenTypeIsOneOf(g_cxx.pToken,CXXTokenTypeOpeningParenthesis | CXXTokenTypeOpeningSquareParenthesis))
{
CXX_DEBUG_PRINT("Condensing subchain");
// hmmm.. must condense as subchain
if(!cxxParserParseAndCondenseCurrentSubchain(CXXTokenTypeOpeningParenthesis | CXXTokenTypeOpeningSquareParenthesis,TRUE))
{
CXX_DEBUG_LEAVE_TEXT("Failed to condense current subchain");
return TRUE;
}
if(cxxTokenTypeIs(g_cxx.pToken,CXXTokenTypeEOF))
{
CXX_DEBUG_LEAVE_TEXT("Found EOF, syntax error but we tolerate it");
return TRUE;
}
} else {
// it's ok
CXX_DEBUG_PRINT("No need to condense subchain");
}
}
} else {
// assume it's an operator
CXX_DEBUG_PRINT("Treating < as less-than operator");
}
break;
case CXXTokenTypeGreaterThanSign:
if(iTemplateLevel == 0)
{
// Non-nested > : always a terminator
cxxTokenChainDestroyLast(g_cxx.pTokenChain);
CXX_DEBUG_LEAVE_TEXT("Found end of template");
return TRUE;
}
// Nested > : is is a shift operator?
if(!cxxParserParseNextToken())
{
CXX_DEBUG_LEAVE_TEXT("Syntax error, but tolerate it at this level");
return TRUE;
}
CXX_DEBUG_PRINT("Got token '%s' of type 0x%02x",vStringValue(g_cxx.pToken->pszWord),g_cxx.pToken->eType);
if(cxxTokenTypeIs(g_cxx.pToken,CXXTokenTypeGreaterThanSign))
{
// assume it's an operator
CXX_DEBUG_PRINT("Treating > as shift-right operator");
} else {
CXX_DEBUG_PRINT("Decreasing template level");
iTemplateLevel--;
if(cxxTokenTypeIsOneOf(g_cxx.pToken,CXXTokenTypeOpeningParenthesis | CXXTokenTypeOpeningSquareParenthesis))
{
CXX_DEBUG_PRINT("Condensing subchain");
// hmmm.. must condense as subchain
if(!cxxParserParseAndCondenseCurrentSubchain(CXXTokenTypeOpeningParenthesis | CXXTokenTypeOpeningSquareParenthesis,TRUE))
{
CXX_DEBUG_LEAVE_TEXT("Failed to condense current subchain");
return TRUE;
}
if(cxxTokenTypeIs(g_cxx.pToken,CXXTokenTypeEOF))
{
CXX_DEBUG_LEAVE_TEXT("Found EOF, syntax error but we tolerate it");
return TRUE;
}
} else {
// it's ok
CXX_DEBUG_PRINT("No need to condense subchain");
}
}
break;
case CXXTokenTypeAssignment:
CXX_DEBUG_PRINT("Found assignment, trying to skip up to a 'notable' point");
// try to skip to the next > or , without stopping at < characters.
if(!cxxParserParseUpToOneOf(
CXXTokenTypeGreaterThanSign | CXXTokenTypeComma | CXXTokenTypeOpeningBracket | CXXTokenTypeSemicolon | CXXTokenTypeEOF
))
{
CXX_DEBUG_LEAVE_TEXT("Failed to parse up to '}EOF'");
return FALSE;
}
goto evaluate_current_token; // backward jump!
break;
case CXXTokenTypeEOF:
CXX_DEBUG_LEAVE_TEXT("Syntax error, but tolerate it at this level");
return TRUE;
break;
case CXXTokenTypeSemicolon:
cxxParserNewStatement();
CXX_DEBUG_LEAVE_TEXT("Broken template arguments, attempting to continue");
return TRUE;
break;
case CXXTokenTypeOpeningBracket:
CXX_DEBUG_PRINT("Found opening bracket: either syntax error or we screwed up parsing the template parameters (some kind of ugly C++11 syntax?), but we try to recover...");
// skip the whole bracketed part.
if(!cxxParserParseUpToOneOf(CXXTokenTypeClosingBracket | CXXTokenTypeEOF))
{
CXX_DEBUG_LEAVE_TEXT("Failed to parse up to '}EOF'");
return FALSE;
}
cxxParserNewStatement();
CXX_DEBUG_LEAVE_TEXT("Broken template arguments recovery complete");
return TRUE;
break;
default:
CXX_DEBUG_ASSERT(FALSE,"Should not end up here");
CXX_DEBUG_LEAVE_TEXT("Found unexpected token type 0x%02x",g_cxx.pToken->eType);
return FALSE;
break;
}
}
// never reached
CXX_DEBUG_LEAVE();
return TRUE;
}
//
// Attempt to extract variable declarations from the chain.
// Returns true if at least one variable was extracted.
// Returns false if a variable declaration could not be identified.
//
// Recognized variable declarations are of the following kinds:
//
// type var;
// type var1,var2;
// type var[];
// type var(constructor args);
// type var{list initializer};
// type var = ...;
// type (*ident)();
// type var:bits;
// type var: range declaration <-- (FIXME: this is only inside for!)
// very complex type with modifiers() namespace::namespace::var = ...;
// type<with template> namespace::var[] = {
// ...
//
// Assumptions:
// - there is a terminator at the end: either ; or {
//
// Notes:
// - Be aware that if this function returns true then the pChain very likely has been modified
// (partially destroyed) as part of the type extraction algorithm.
// If the function returns false the chain has not been modified (and
// to extract something else from it).
//
// - This function is quite tricky.
//
bool cxxParserExtractVariableDeclarations(CXXTokenChain * pChain,unsigned int uFlags)
{
CXX_DEBUG_ENTER();
if(pChain->iCount < 1)
{
CXX_DEBUG_LEAVE_TEXT("Chain is empty");
return false;
}
#ifdef CXX_DO_DEBUGGING
vString * pJoinedChain = cxxTokenChainJoin(pChain,NULL,0);
CXX_DEBUG_PRINT(
"Looking for variable declarations in '%s'",
vStringValue(pJoinedChain)
);
vStringDelete(pJoinedChain);
#endif
//
// Strategy:
// - verify that the chain starts with an identifier or keyword (always present)
// - run to one of : ; [] () {} = ,
// - ensure that the previous token is an identifier (except for special cases)
// - go back to skip the eventual scope
// - ensure that there is a leading type
// - if we are at : [], () or {} then run to the next ; = or ,
// - once we have determined that a variable declaration is there
// modify the chain to contain only the type name
// - emit variable tag
// - if we are at , then check if there are more declarations
//
CXXToken * t = cxxTokenChainFirst(pChain);
enum CXXScopeType eScopeType = cxxScopeGetType();
CXX_DEBUG_ASSERT(t,"There should be an initial token here");
if(!cxxTokenTypeIsOneOf(t,CXXTokenTypeIdentifier | CXXTokenTypeKeyword))
{
CXX_DEBUG_LEAVE_TEXT("Statement does not start with identifier or keyword");
return false;
}
// Handle the special case of delete/new keywords at the beginning
if(
cxxTokenTypeIs(t,CXXTokenTypeKeyword) &&
(
(t->eKeyword == CXXKeywordDELETE) ||
(t->eKeyword == CXXKeywordNEW)
)
)
{
CXX_DEBUG_LEAVE_TEXT("Statement looks like a delete or new call");
return false;
}
bool bGotVariable = false;
// Loop over the whole statement.
while(t)
{
// Scan up to a notable token: ()[]{}=,;:{
while(t)
{
if(cxxTokenTypeIsOneOf(
t,
CXXTokenTypeSingleColon | CXXTokenTypeParenthesisChain |
CXXTokenTypeSquareParenthesisChain | CXXTokenTypeBracketChain |
CXXTokenTypeAssignment | CXXTokenTypeComma |
CXXTokenTypeSemicolon | CXXTokenTypeOpeningBracket
))
{
// Notable token reached.
break;
}
if(
cxxTokenTypeIsOneOf(
t,
CXXTokenTypeOperator | CXXTokenTypeMultipleAnds |
CXXTokenTypePointerOperator | CXXTokenTypeStringConstant |
CXXTokenTypeAngleBracketChain | CXXTokenTypeCharacterConstant |
CXXTokenTypeMultipleDots | CXXTokenTypeClosingBracket |
CXXTokenTypeClosingParenthesis | CXXTokenTypeClosingSquareParenthesis |
CXXTokenTypeGreaterThanSign
)
)
{
// Something that should not appear in a variable declaration
CXX_DEBUG_LEAVE_TEXT(
"Found token '%s' of type 0x%02x that should " \
"not appear in the initial part of a variable declaration",
vStringValue(t->pszWord),
t->eType
);
return bGotVariable;
}
if(t->eType == CXXTokenTypeSmallerThanSign)
{
// Must be part of template type name (so properly balanced).
t = cxxTokenChainSkipToEndOfTemplateAngleBracket(t);
if(!t)
{
CXX_DEBUG_LEAVE_TEXT("Failed to skip past angle bracket chain");
return bGotVariable;
}
}
t = t->pNext;
}
// Notable token reached?
if(!t)
{
CXX_DEBUG_LEAVE_TEXT("Nothing interesting here");
return bGotVariable;
}
CXX_DEBUG_PRINT(
"Found notable token '%s' of type 0x%02x(%s)",
vStringValue(t->pszWord),
t->eType,
cxxDebugTypeDecode(t->eType)
);
// Now before the notable token there MUST be an identifier
// (eventually hidden in a parenthesis chain) and also a typename.
if(!t->pPrev)
{
CXX_DEBUG_LEAVE_TEXT("Nothing interesting before notable token");
return bGotVariable;
}
CXXToken * pIdentifier = NULL;
CXXToken * pTokenBefore = NULL;
// If we have to continue scanning we'll remove the tokens from here
// so they don't end up being part of the type name.
// If this is set to NULL then it means that we cannot determine properly
// what to remove and we should stop scanning after the current variable.
CXXToken * pRemoveStart = t;
switch(t->eType)
{
case CXXTokenTypeParenthesisChain:
{
// At a parenthesis chain we need some additional checks.
if(
// check for function pointers or nasty arrays
// Possible cases:
// ret type (*variable)(params)
// ret type (* const (variable[4]))(params)
t->pNext &&
(
(
cxxTokenTypeIs(t->pNext,CXXTokenTypeParenthesisChain) &&
cxxParserTokenChainLooksLikeFunctionParameterList(
t->pNext->pChain,
NULL
)
) ||
cxxTokenTypeIs(t->pNext,CXXTokenTypeSquareParenthesisChain)
) &&
(pIdentifier = cxxTokenChainFirstPossiblyNestedTokenOfType(
t->pChain,
CXXTokenTypeIdentifier,
NULL
)) &&
// Discard function declarations with function return types
// like void (*A(B))(C);
(
(!pIdentifier->pNext) ||
(!cxxTokenTypeIs(pIdentifier->pNext,CXXTokenTypeParenthesisChain))
)
)
{
// A function pointer.
// There are two parentheses, skip the second too.
pTokenBefore = t->pPrev;
t = t->pNext->pNext;
pRemoveStart = t;
} else if(
(t->pChain->iCount == 3) &&
cxxTokenTypeIs(
cxxTokenChainAt(t->pChain,1),
CXXTokenTypeParenthesisChain
) &&
t->pPrev &&
cxxTokenTypeIs(t->pPrev,CXXTokenTypeIdentifier) &&
t->pPrev->pPrev &&
cxxTokenTypeIs(t->pPrev->pPrev,CXXTokenTypeIdentifier)
)
{
CXX_DEBUG_LEAVE_TEXT("Parenthesis seems to define an __ARGS style prototype");
return bGotVariable;
} else if(
cxxTokenTypeIs(t->pPrev,CXXTokenTypeIdentifier) &&
(
(eScopeType == CXXScopeTypeNamespace) ||
(eScopeType == CXXScopeTypeFunction)
) &&
cxxParserCurrentLanguageIsCPP() &&
cxxParserTokenChainLooksLikeConstructorParameterSet(t->pChain)
)
{
// ok, *might* be variable instantiation
pIdentifier = t->pPrev;
pTokenBefore = pIdentifier->pPrev;
} else {
CXX_DEBUG_LEAVE_TEXT("No recognizable parenthesis form for a variable");
return bGotVariable;
}
}
break;
case CXXTokenTypeBracketChain:
if(
cxxTokenTypeIs(t->pPrev,CXXTokenTypeIdentifier) &&
cxxParserCurrentLanguageIsCPP() &&
cxxParserTokenChainLooksLikeConstructorParameterSet(t->pChain)
)
{
// ok, *might* be new C++ style variable initialization
pIdentifier = t->pPrev;
pTokenBefore = pIdentifier->pPrev;
} else {
CXX_DEBUG_LEAVE_TEXT("Bracket chain that doesn't look like a C++ var init");
return bGotVariable;
}
break;
case CXXTokenTypeSingleColon:
// check for bitfield
if(
t->pNext &&
cxxTokenTypeIsOneOf(t->pNext,CXXTokenTypeNumber | CXXTokenTypeIdentifier)
)
{
// ok, looks like a bit field
if(
cxxTokenTypeIs(t->pNext,CXXTokenTypeNumber) &&
t->pNext->pNext &&
cxxTokenTypeIsOneOf(
t->pNext->pNext,
CXXTokenTypeComma | CXXTokenTypeSemicolon |
CXXTokenTypeAssignment
)
)
{
// keep bitfield width specification as part of type
pIdentifier = t->pPrev;
pTokenBefore = pIdentifier->pPrev;
t = t->pNext->pNext;
} else {
// Too complex: strip width specification (the best we can do)
pIdentifier = t->pPrev;
pTokenBefore = pIdentifier->pPrev;
}
} else {
CXX_DEBUG_LEAVE_TEXT("Single colon that doesn't look like a bit field");
return bGotVariable;
}
break;
case CXXTokenTypeSquareParenthesisChain:
// check for array
// Keep the array specifier as part of type
pIdentifier = t->pPrev;
pTokenBefore = pIdentifier->pPrev;
while(t->pNext && cxxTokenTypeIs(t->pNext,CXXTokenTypeSquareParenthesisChain))
t = t->pNext;
if(!t->pNext)
{
CXX_DEBUG_LEAVE_TEXT("No token after []");
return bGotVariable;
}
// skip identifies attached to the array as attributes
while(t->pNext && cxxTokenTypeIs(t->pNext, CXXTokenTypeIdentifier))
{
t = t->pNext;
// skip macro argument(s)
if (t->pNext && cxxTokenTypeIs(t->pNext, CXXTokenTypeParenthesisChain))
t = t->pNext;
}
if (!t->pNext)
{
CXX_DEBUG_LEAVE_TEXT("No token after attribute(s) attached to []");
return bGotVariable;
}
if(!cxxTokenTypeIsOneOf(
t->pNext,
CXXTokenTypeComma | CXXTokenTypeSemicolon |
CXXTokenTypeAssignment | CXXTokenTypeBracketChain
))
{
CXX_DEBUG_LEAVE_TEXT("No comma, semicolon, = or {} after [] (\"%s\", %s)",
vStringValue (t->pNext->pszWord),
cxxDebugTypeDecode (t->pNext->eType));
return bGotVariable;
}
t = t->pNext;
pRemoveStart = t;
break;
default:
// Must be identifier
if(t->pPrev->eType != CXXTokenTypeIdentifier)
{
CXX_DEBUG_LEAVE_TEXT("No identifier before the notable token");
return bGotVariable;
}
pIdentifier = t->pPrev;
pTokenBefore = pIdentifier->pPrev;
break;
}
CXX_DEBUG_ASSERT(pIdentifier,"We should have found an identifier here");
if(!pTokenBefore)
{
CXX_DEBUG_LEAVE_TEXT("Identifier not preceded by a type");
// Here we can handle yet another one of the gazillion of special cases.
//
// MACRO(whatever) variable;
//
if(
cxxTokenTypeIs(t,CXXTokenTypeParenthesisChain) &&
t->pNext &&
cxxTokenTypeIs(t->pNext,CXXTokenTypeIdentifier) &&
t->pNext->pNext &&
cxxTokenTypeIs(t->pNext->pNext,CXXTokenTypeSemicolon)
)
{
CXX_DEBUG_PRINT("Looks like the 'MACRO(whatever) variable;' special case");
pIdentifier = t->pNext;
pTokenBefore = t;
t = t->pNext->pNext;
} else {
return bGotVariable;
}
}
CXXToken * pScopeEnd = pTokenBefore->pNext;
CXXToken * pScopeStart = NULL;
// Skip back to the beginning of the scope, if any
while(pTokenBefore->eType == CXXTokenTypeMultipleColons)
{
if(!cxxParserCurrentLanguageIsCPP())
{
CXX_DEBUG_LEAVE_TEXT("Syntax error: found multiple colons in C language");
return false;
}
pTokenBefore = pTokenBefore->pPrev;
if(!pTokenBefore)
{
CXX_DEBUG_LEAVE_TEXT(
"Identifier preceded by multiple colons " \
"but not preceded by a type"
);
return bGotVariable;
}
if(cxxTokenTypeIs(pTokenBefore,CXXTokenTypeGreaterThanSign))
{
CXXToken * pAux = cxxTokenChainSkipBackToStartOfTemplateAngleBracket(pTokenBefore);
if((!pAux) || (!pAux->pPrev))
{
CXX_DEBUG_LEAVE_TEXT(
"Identifier preceded by multiple colons " \
"and by a >, but failed to skip back to starting <"
);
return bGotVariable;
}
pTokenBefore = pAux->pPrev;
}
if(!cxxTokenTypeIs(pTokenBefore,CXXTokenTypeIdentifier))
{
CXX_DEBUG_LEAVE_TEXT(
"Identifier preceded by multiple colons " \
"with probable syntax error"
);
return bGotVariable;
}
pScopeStart = pTokenBefore;
pTokenBefore = pTokenBefore->pPrev;
if(!pTokenBefore)
{
CXX_DEBUG_LEAVE_TEXT(
"Identifier preceded by multiple colons " \
"but not preceded by a type"
);
return bGotVariable;
}
}
if(!bGotVariable)
{
// now pTokenBefore should be part of a type (either the variable type or return
// type of a function in case of a function pointer)
if(!cxxTokenTypeIsOneOf(
pTokenBefore,
CXXTokenTypeIdentifier | CXXTokenTypeKeyword |
CXXTokenTypeStar | CXXTokenTypeAnd
))
{
if(cxxTokenTypeIs(pTokenBefore,CXXTokenTypeGreaterThanSign))
{
// the < > must be balanced
CXXToken * t2 = pTokenBefore->pPrev;
int iLevel = 1;
while(t2)
{
if(cxxTokenTypeIs(t2,CXXTokenTypeGreaterThanSign))
iLevel++;
else if(cxxTokenTypeIs(t2,CXXTokenTypeSmallerThanSign))
iLevel--;
t2 = t2->pPrev;
}
if(iLevel != 0)
{
CXX_DEBUG_LEAVE_TEXT(
"The > token is unbalanced and does not " \
"seem to be part of type name"
);
return bGotVariable;
}
} else if(
// Still 'MACRO(whatever) variable;' case
cxxTokenTypeIs(pTokenBefore,CXXTokenTypeParenthesisChain) &&
pTokenBefore->pPrev &&
cxxTokenTypeIs(pTokenBefore->pPrev,CXXTokenTypeIdentifier) &&
!pTokenBefore->pPrev->pPrev
)
{
CXX_DEBUG_PRINT("Type seems to be hidden in a macro");
} else {
CXX_DEBUG_LEAVE_TEXT(
"Token '%s' of type 0x%02x does not seem " \
"to be part of type name",
vStringValue(pTokenBefore->pszWord),
pTokenBefore->eType
);
return bGotVariable;
}
}
bGotVariable = true;
}
// Goodie. We have an identifier and almost certainly a type here.
// From now on we start destroying the chain: mark the return value as true
// so nobody else will try to extract stuff from it
int iScopesPushed = 0;
if(pScopeStart)
{
// Push the scopes and remove them from the chain so they are not in the way
while(pScopeStart != pScopeEnd)
{
// This is the scope id START. It might contain
// also other tokens like in ...::A<B>::...
CXXToken * pPartEnd = cxxTokenChainNextTokenOfType(
pScopeStart,
CXXTokenTypeMultipleColons
);
CXX_DEBUG_ASSERT(
pPartEnd,
"We should have found multiple colons here!"
);
CXX_DEBUG_ASSERT(
pPartEnd->pPrev,
"And there should be a previous token too"
);
CXXToken * pScopeId = cxxTokenChainExtractRange(pScopeStart,pPartEnd->pPrev,0);
cxxScopePush(
pScopeId,
CXXScopeTypeClass,
// WARNING: We don't know if it's really a class! (FIXME?)
CXXScopeAccessUnknown
);
CXXToken * pAux = pPartEnd->pNext;
cxxTokenChainDestroyRange(pChain,pScopeStart,pPartEnd);
pScopeStart = pAux;
iScopesPushed++;
}
}
bool bKnRStyleParameters =
(uFlags & CXXExtractVariableDeclarationsKnRStyleParameters);
tagEntryInfo * tag = cxxTagBegin(
bKnRStyleParameters ?
CXXTagKindPARAMETER :
((g_cxx.uKeywordState & CXXParserKeywordStateSeenExtern) ?
CXXTagKindEXTERNVAR : cxxScopeGetVariableKind()),
pIdentifier
);
if(tag)
{
CXX_DEBUG_ASSERT(t != pIdentifier,"This should not happen");
// remove the identifier
cxxTokenChainTakeRecursive(pChain,pIdentifier);
// Fix square parentheses: if they contain something that is not a numeric
// constant then empty them up
CXXToken * pPartOfType = t->pPrev;
CXX_DEBUG_ASSERT(pPartOfType,"There should be a part of type name here");
while(pPartOfType && cxxTokenTypeIs(pPartOfType,CXXTokenTypeSquareParenthesisChain))
{
CXXTokenChain * pAuxChain = pPartOfType->pChain;
if(pAuxChain->iCount > 2)
{
if(
(pAuxChain->iCount > 3) ||
(!cxxTokenTypeIs(cxxTokenChainAt(pAuxChain,1),CXXTokenTypeNumber))
)
{
cxxTokenChainDestroyRange(
pAuxChain,
cxxTokenChainFirst(pAuxChain)->pNext,
cxxTokenChainLast(pAuxChain)->pPrev
);
}
}
pPartOfType = pPartOfType->pPrev;
}
// anything that remains is part of type
CXXToken * pTypeToken = cxxTagCheckAndSetTypeField(cxxTokenChainFirst(pChain),t->pPrev);
tag->isFileScope = bKnRStyleParameters ?
true :
(
(
(eScopeType == CXXScopeTypeNamespace) &&
(g_cxx.uKeywordState & CXXParserKeywordStateSeenStatic) &&
(!isInputHeaderFile())
) ||
// locals are always hidden
(eScopeType == CXXScopeTypeFunction) ||
(
(eScopeType != CXXScopeTypeNamespace) &&
(eScopeType != CXXScopeTypeFunction) &&
(!isInputHeaderFile())
)
);
vString * pszProperties = NULL;
if(cxxTagFieldEnabled(CXXTagFieldProperties))
{
unsigned int uProperties = 0;
if(g_cxx.uKeywordState & CXXParserKeywordStateSeenStatic)
uProperties |= CXXTagPropertyStatic;
if(g_cxx.uKeywordState & CXXParserKeywordStateSeenExtern)
uProperties |= CXXTagPropertyExtern;
if(g_cxx.uKeywordState & CXXParserKeywordStateSeenMutable)
uProperties |= CXXTagPropertyMutable;
if(g_cxx.uKeywordState & CXXParserKeywordStateSeenAttributeDeprecated)
uProperties |= CXXTagPropertyDeprecated;
// Volatile is part of the type, so we don't mark it as a property
//if(g_cxx.uKeywordState & CXXParserKeywordStateSeenVolatile)
// uProperties |= CXXTagPropertyVolatile;
pszProperties = cxxTagSetProperties(uProperties);
}
cxxTagCommit();
if(pTypeToken)
cxxTokenDestroy(pTypeToken);
if(pszProperties)
vStringDelete(pszProperties);
cxxTokenDestroy(pIdentifier);
}
while(iScopesPushed > 0)
{
cxxScopePop();
iScopesPushed--;
}
if(!t)
{
CXX_DEBUG_LEAVE_TEXT("Nothing more");
return bGotVariable;
}
if(!cxxTokenTypeIsOneOf(
t,
CXXTokenTypeComma | CXXTokenTypeSemicolon | CXXTokenTypeOpeningBracket
))
{
t = cxxTokenChainNextTokenOfType(
t,
CXXTokenTypeComma | CXXTokenTypeSemicolon | CXXTokenTypeOpeningBracket
);
if(!t)
{
CXX_DEBUG_LEAVE_TEXT("Didn't find a comma, semicolon or {");
return bGotVariable;
}
}
if(cxxTokenTypeIsOneOf(t,CXXTokenTypeSemicolon | CXXTokenTypeOpeningBracket))
{
CXX_DEBUG_LEAVE_TEXT("Noting else");
return bGotVariable;
}
// Comma. Might have other declarations here.
CXX_DEBUG_PRINT("At a comma, might have other declarations here");
t = t->pNext;
CXX_DEBUG_ASSERT(t,"There should be something after the comma here!");
if(!pRemoveStart)
{
CXX_DEBUG_LEAVE_TEXT("Could not properly fix type name for next token: stopping here");
return bGotVariable;
}
cxxTokenChainDestroyRange(pChain,pRemoveStart,t->pPrev);
}
CXX_DEBUG_LEAVE_TEXT("Reached end");
return bGotVariable;
}
//
// This is called at block level, upon encountering a semicolon, an unbalanced
// closing bracket or EOF.The current token is something like:
// static const char * variable;
// int i = ....
// const QString & function(whatever) const;
// QString szText("ascii");
// QString(...)
//
// Notable facts:
// - several special statements never end up here: this includes class,
// struct, union, enum, namespace, typedef, case, try, catch and other
// similar stuff.
// - the terminator is always at the end. It's either a semicolon, a closing
// bracket or an EOF
// - the parentheses and brackets are always condensed in subchains
// (unless unbalanced).
//
// int __attribute__() function();
// | |
// ("whatever") (int var1,type var2)
//
// const char * strings[] = {}
// | |
// [10] { "string","string",.... }
//
// This function tries to extract variable declarations and function prototypes.
//
// Yes, it's complex: it's because C/C++ is complex.
//
void cxxParserAnalyzeOtherStatement(void)
{
CXX_DEBUG_ENTER();
#ifdef CXX_DO_DEBUGGING
vString * pChain = cxxTokenChainJoin(g_cxx.pTokenChain,NULL,0);
CXX_DEBUG_PRINT("Analyzing statement '%s'",vStringValue(pChain));
vStringDelete(pChain);
#endif
CXX_DEBUG_ASSERT(
g_cxx.pTokenChain->iCount > 0,
"There should be at least the terminator here!"
);
if(g_cxx.pTokenChain->iCount < 2)
{
CXX_DEBUG_LEAVE_TEXT("Empty statement");
return;
}
if(g_cxx.uKeywordState & CXXParserKeywordStateSeenReturn)
{
CXX_DEBUG_LEAVE_TEXT("Statement after a return is not interesting");
return;
}
// Everything we can make sense of starts with an identifier or keyword.
// This is usually a type name (eventually decorated by some attributes
// and modifiers) with the notable exception of constructor/destructor
// declarations (which are still identifiers tho).
CXXToken * t = cxxTokenChainFirst(g_cxx.pTokenChain);
if(!cxxTokenTypeIsOneOf(t,CXXTokenTypeIdentifier | CXXTokenTypeKeyword))
{
CXX_DEBUG_LEAVE_TEXT("Statement does not start with an identifier or keyword");
return;
}
enum CXXTagKind eScopeKind = cxxScopeGetKind();
CXXFunctionSignatureInfo oInfo;
// kinda looks like a function or variable instantiation... maybe
if(eScopeKind == CXXTagKindFUNCTION)
{
// prefer variable declarations.
// if none found then try function prototype
if(cxxParserExtractVariableDeclarations(g_cxx.pTokenChain,0))
{
CXX_DEBUG_LEAVE_TEXT("Found variable declarations");
return;
}
// FIXME: This *COULD* work but we should first rule out the possibility
// of simple function calls like func(a). The function signature search
// should be far stricter here.
//if(cxxParserLookForFunctionSignature(g_cxx.pTokenChain,&oInfo,NULL))
// cxxParserEmitFunctionTags(&oInfo,CXXTagKindPROTOTYPE,0);
CXX_DEBUG_LEAVE();
return;
}
// prefer function.
if(cxxParserLookForFunctionSignature(g_cxx.pTokenChain,&oInfo,NULL))
{
int iScopesPushed = cxxParserEmitFunctionTags(&oInfo,CXXTagKindPROTOTYPE,CXXEmitFunctionTagsPushScopes,NULL);
while(iScopesPushed > 0)
{
cxxScopePop();
iScopesPushed--;
}
CXX_DEBUG_LEAVE_TEXT("Found function prototypes");
return;
}
if(
g_cxx.uKeywordState &
(
CXXParserKeywordStateSeenInline | CXXParserKeywordStateSeenExplicit |
CXXParserKeywordStateSeenOperator | CXXParserKeywordStateSeenVirtual
)
)
{
// must be function!
CXX_DEBUG_LEAVE_TEXT(
"WARNING: Was expecting to find a function prototype " \
"but did not find one"
);
return;
}
cxxParserExtractVariableDeclarations(g_cxx.pTokenChain,0);
CXX_DEBUG_LEAVE_TEXT("Nothing else");
}
bool cxxParserParseBlockHandleOpeningBracket(void)
{
CXX_DEBUG_ENTER();
CXX_DEBUG_ASSERT(
g_cxx.pToken->eType == CXXTokenTypeOpeningBracket,
"This must be called when pointing at an opening bracket!"
);
enum CXXScopeType eScopeType = cxxScopeGetType();
bool bIsCPP = cxxParserCurrentLanguageIsCPP();
CXXToken * pAux;
if(
(
// something = {...}
(g_cxx.pToken->pPrev) &&
cxxTokenTypeIs(g_cxx.pToken->pPrev,CXXTokenTypeAssignment) &&
(
(eScopeType == CXXScopeTypeFunction) ||
(eScopeType == CXXScopeTypeNamespace)
)
) || (
bIsCPP &&
(g_cxx.pToken->pPrev) &&
(
(
// T { arg1, arg2, ... } (1)
// T object { arg1, arg2, ... } (2)
// new T { arg1, arg2, ... } (3)
// Class::Class() : member { arg1, arg2, ... } { (4)
cxxTokenTypeIs(g_cxx.pToken->pPrev,CXXTokenTypeIdentifier) &&
(
(!g_cxx.pToken->pPrev->pPrev) ||
(cxxTokenTypeIsOneOf(
g_cxx.pToken->pPrev->pPrev,
CXXTokenTypeIdentifier | CXXTokenTypeStar | CXXTokenTypeAnd |
CXXTokenTypeGreaterThanSign | CXXTokenTypeKeyword |
// FIXME: This check could be made stricter?
CXXTokenTypeSingleColon | CXXTokenTypeComma
))
) &&
// "override" is handled as identifier since it's a keyword only after function signatures
(strcmp(vStringValue(g_cxx.pToken->pPrev->pszWord),"override") != 0)
) || (
// type var[][][]..[] { ... }
// (but not '[] { ... }' which is a parameterless lambda)
cxxTokenTypeIs(g_cxx.pToken->pPrev,CXXTokenTypeSquareParenthesisChain) &&
(
pAux = cxxTokenChainPreviousTokenNotOfType(
g_cxx.pToken->pPrev,
CXXTokenTypeSquareParenthesisChain
)
) &&
cxxTokenTypeIs(pAux,CXXTokenTypeIdentifier)
)
)
) || (
// return { }
(!g_cxx.pToken->pPrev) &&
(g_cxx.uKeywordState & CXXParserKeywordStateSeenReturn)
)
)
{
// array or list-like initialisation
bool bRet = cxxParserParseAndCondenseCurrentSubchain(
CXXTokenTypeOpeningBracket | CXXTokenTypeOpeningParenthesis |
CXXTokenTypeOpeningSquareParenthesis,
false,
true
);
CXX_DEBUG_LEAVE_TEXT("Handled array or list-like initialisation or return");
return bRet;
}
int iScopes;
// FIXME: Why the invalid cork queue entry index is CORK_NIL?
int iCorkQueueIndex = CORK_NIL;
if(eScopeType != CXXScopeTypeFunction)
{
// very likely a function definition
iScopes = cxxParserExtractFunctionSignatureBeforeOpeningBracket(&iCorkQueueIndex);
// FIXME: Handle syntax (5) of list initialization:
// Class::Class() : member { arg1, arg2, ... } {...
} else {
// some kind of other block:
// - anonymous block
// - block after for(),while(),foreach(),if() and other similar stuff
// - lambda
// check for lambdas
CXXToken * pParenthesis;
if(
bIsCPP &&
(pParenthesis = cxxParserOpeningBracketIsLambda())
)
{
CXX_DEBUG_LEAVE_TEXT("Will handle lambda");
return cxxParserHandleLambda(pParenthesis);
}
iScopes = 0;
}
cxxParserNewStatement();
if(!cxxParserParseBlock(true))
{
CXX_DEBUG_LEAVE_TEXT("Failed to parse nested block");
return false;
}
if(iCorkQueueIndex > CORK_NIL)
cxxParserMarkEndLineForTagInCorkQueue(iCorkQueueIndex);
while(iScopes > 0)
{
cxxScopePop();
iScopes--;
}
CXX_DEBUG_LEAVE();
return true;
}
boolean cxxParserParseClassStructOrUnion(
enum CXXKeyword eKeyword,
enum CXXTagKind eTagKind
)
{
CXX_DEBUG_ENTER();
// make sure that there is only the class/struct/union keyword in the chain
while(g_cxx.pTokenChain->iCount > 1)
cxxTokenChainDestroyFirst(g_cxx.pTokenChain);
// this may be cleared below
boolean bParsingTypedef = (g_cxx.uKeywordState & CXXParserKeywordStateSeenTypedef);
/*
Spec is:
class-key attr class-head-name base-clause { member-specification }
class-key - one of class or struct. The keywords are identical
except for the default member access and the default base class access.
attr(C++11) - optional sequence of any number of attributes,
may include alignas specifier
class-head-name - the name of the class that's being defined.
Optionally qualified, optionally followed by keyword final.
The name may be omitted, in which case the class is unnamed (note
that unnamed class cannot be final)
base-clause - optional list of one or more parent classes and the
model of inheritance used for each (see derived class)
member-specification - list of access specifiers, member object and
member function declarations and definitions (see below)
*/
// Skip attr and class-head-name
// enable "final" keyword handling
g_cxx.bParsingClassStructOrUnionDeclaration = TRUE;
unsigned int uTerminatorTypes = CXXTokenTypeEOF | CXXTokenTypeSingleColon |
CXXTokenTypeSemicolon | CXXTokenTypeOpeningBracket |
CXXTokenTypeSmallerThanSign;
if(eTagKind != CXXTagKindCLASS)
uTerminatorTypes |= CXXTokenTypeParenthesisChain | CXXTokenTypeAssignment;
boolean bRet;
for(;;)
{
bRet = cxxParserParseUpToOneOf(uTerminatorTypes);
if(!bRet)
{
g_cxx.bParsingClassStructOrUnionDeclaration = FALSE;
CXX_DEBUG_LEAVE_TEXT("Could not parse class/struct/union name");
return FALSE;
}
if(!cxxTokenTypeIs(g_cxx.pToken,CXXTokenTypeSmallerThanSign))
break;
// Probably a template specialisation
// template<typename T> struct X<int>
// {
// }
// FIXME: Should we add the specialisation arguments somewhere?
// Maye as a separate field?
bRet = cxxParserParseAndCondenseCurrentSubchain(
CXXTokenTypeOpeningParenthesis | CXXTokenTypeOpeningBracket |
CXXTokenTypeOpeningSquareParenthesis |
CXXTokenTypeSmallerThanSign,
FALSE
);
if(!bRet)
{
g_cxx.bParsingClassStructOrUnionDeclaration = FALSE;
CXX_DEBUG_LEAVE_TEXT("Could not parse class/struct/union name");
return FALSE;
}
}
g_cxx.bParsingClassStructOrUnionDeclaration = FALSE;
if(cxxTokenTypeIs(g_cxx.pToken,CXXTokenTypeParenthesisChain))
{
// probably a function declaration/prototype
// something like struct x * func()....
// do not clear statement
CXX_DEBUG_LEAVE_TEXT("Probably a function declaration!");
return TRUE;
}
// FIXME: This block is duplicated in enum
if(cxxTokenTypeIs(g_cxx.pToken,CXXTokenTypeSemicolon))
{
if(g_cxx.pTokenChain->iCount > 3)
{
// [typedef] struct X Y; <-- typedef has been removed!
if(bParsingTypedef)
cxxParserExtractTypedef(g_cxx.pTokenChain,TRUE);
else
cxxParserExtractVariableDeclarations(g_cxx.pTokenChain,0);
}
cxxParserNewStatement();
CXX_DEBUG_LEAVE();
return TRUE;
}
if(cxxTokenTypeIs(g_cxx.pToken,CXXTokenTypeAssignment))
{
if(g_cxx.pTokenChain->iCount > 3)
{
// struct X Y = ...;
cxxParserExtractVariableDeclarations(g_cxx.pTokenChain,0);
}
// Skip the initialization (which almost certainly contains a block)
if(!cxxParserParseUpToOneOf(CXXTokenTypeEOF | CXXTokenTypeSemicolon))
{
CXX_DEBUG_LEAVE_TEXT("Failed to parse up to EOF/semicolon");
return FALSE;
}
cxxParserNewStatement();
CXX_DEBUG_LEAVE();
return TRUE;
}
if(cxxTokenTypeIs(g_cxx.pToken,CXXTokenTypeEOF))
{
// tolerate EOF, just ignore this
cxxParserNewStatement();
CXX_DEBUG_LEAVE_TEXT("EOF: ignoring");
return TRUE;
}
// semicolon or opening bracket
// check if we can extract a class name identifier
CXXToken * pClassName = cxxTokenChainLastTokenOfType(
g_cxx.pTokenChain,
CXXTokenTypeIdentifier
);
int iPushedScopes = 0;
if(pClassName)
{
// good.
// It may be qualified though.
CXXToken * pNamespaceBegin = pClassName;
CXXToken * pPrev = pClassName->pPrev;
while(pPrev)
{
if(!cxxTokenTypeIs(pPrev,CXXTokenTypeMultipleColons))
break;
pPrev = pPrev->pPrev;
if(!pPrev)
break;
if(!cxxTokenTypeIs(pPrev,CXXTokenTypeIdentifier))
break;
pNamespaceBegin = pPrev;
pPrev = pPrev->pPrev;
}
while(pNamespaceBegin != pClassName)
{
CXXToken * pNext = pNamespaceBegin->pNext;
cxxTokenChainTake(g_cxx.pTokenChain,pNamespaceBegin);
// FIXME: We don't really know if it's a class!
cxxScopePush(pNamespaceBegin,CXXTagKindCLASS,CXXScopeAccessUnknown);
iPushedScopes++;
pNamespaceBegin = pNext->pNext;
}
CXX_DEBUG_PRINT(
"Class/struct/union name is %s",
vStringValue(pClassName->pszWord)
);
cxxTokenChainTake(g_cxx.pTokenChain,pClassName);
} else {
pClassName = cxxTokenCreateAnonymousIdentifier(eTagKind);
CXX_DEBUG_PRINT(
"Class/struct/union name is %s (anonymous)",
vStringValue(pClassName->pszWord)
);
}
if(cxxTokenTypeIs(g_cxx.pToken,CXXTokenTypeSingleColon))
{
// check for base classes
cxxTokenChainClear(g_cxx.pTokenChain);
if(!cxxParserParseUpToOneOf(
CXXTokenTypeEOF | CXXTokenTypeSemicolon | CXXTokenTypeOpeningBracket
))
{
cxxTokenDestroy(pClassName);
CXX_DEBUG_LEAVE_TEXT("Failed to parse base class part");
return FALSE;
}
if(cxxTokenTypeIsOneOf(g_cxx.pToken,CXXTokenTypeSemicolon | CXXTokenTypeEOF))
{
cxxTokenDestroy(pClassName);
cxxParserNewStatement();
CXX_DEBUG_LEAVE_TEXT("Syntax error: ignoring");
return TRUE;
}
cxxTokenChainDestroyLast(g_cxx.pTokenChain); // remove the {
} else {
cxxTokenChainClear(g_cxx.pTokenChain);
}
tagEntryInfo * tag = cxxTagBegin(eTagKind,pClassName);
int iCorkQueueIndex = CORK_NIL;
if(tag)
{
if(g_cxx.pTokenChain->iCount > 0)
{
// Strip inheritance type information
// FIXME: This could be optional!
CXXToken * t = cxxTokenChainFirst(g_cxx.pTokenChain);
while(t)
{
if(
cxxTokenTypeIs(t,CXXTokenTypeKeyword) &&
(
(t->eKeyword == CXXKeywordPUBLIC) ||
(t->eKeyword == CXXKeywordPROTECTED) ||
(t->eKeyword == CXXKeywordPRIVATE) ||
(t->eKeyword == CXXKeywordVIRTUAL)
)
)
{
CXXToken * pNext = t->pNext;
cxxTokenChainTake(g_cxx.pTokenChain,t);
cxxTokenDestroy(t);
t = pNext;
} else {
t = t->pNext;
}
}
if(g_cxx.pTokenChain->iCount > 0)
{
cxxTokenChainCondense(
g_cxx.pTokenChain,
CXXTokenChainCondenseNoTrailingSpaces
);
tag->extensionFields.inheritance = vStringValue(
g_cxx.pTokenChain->pHead->pszWord
);
}
}
if(
g_cxx.pTemplateTokenChain && (g_cxx.pTemplateTokenChain->iCount > 0) &&
cxxTagCPPFieldEnabled(CXXTagCPPFieldTemplate)
)
{
cxxTokenChainNormalizeTypeNameSpacing(g_cxx.pTemplateTokenChain);
cxxTokenChainCondense(g_cxx.pTemplateTokenChain,0);
cxxTagSetCPPField(
CXXTagCPPFieldTemplate,
vStringValue(cxxTokenChainFirst(g_cxx.pTemplateTokenChain)->pszWord)
);
}
tag->isFileScope = !isInputHeaderFile();
iCorkQueueIndex = cxxTagCommit();
}
cxxScopePush(
pClassName,
eTagKind,
(eTagKind == CXXTagKindCLASS) ?
CXXScopeAccessPrivate : CXXScopeAccessPublic
);
vString * pScopeName = cxxScopeGetFullNameAsString();
if(!cxxParserParseBlock(TRUE))
{
CXX_DEBUG_LEAVE_TEXT("Failed to parse scope");
if(pScopeName)
vStringDelete(pScopeName);
return FALSE;
}
if(iCorkQueueIndex > CORK_NIL)
cxxParserMarkEndLineForTagInCorkQueue(iCorkQueueIndex);
iPushedScopes++;
while(iPushedScopes > 0)
{
cxxScopePop();
iPushedScopes--;
}
bRet = cxxParserParseEnumStructClassOrUnionFullDeclarationTrailer(
bParsingTypedef,
eKeyword,
eTagKind,
vStringValue(pScopeName)
);
if(pScopeName)
vStringDelete(pScopeName);
cxxParserNewStatement();
CXX_DEBUG_LEAVE();
return bRet;
};
boolean cxxParserParseEnum(void)
{
CXX_DEBUG_ENTER();
// may be cleared below
boolean bParsingTypedef = (g_cxx.uKeywordState & CXXParserKeywordStateSeenTypedef);
/*
Spec is:
enum-key attr(optional) identifier(optional) enum-base(optional)
{ enumerator-list(optional) } (1)
enum-key attr(optional) identifier enum-base(optional) ;
(2) (since C++11)
*/
// Skip attr and class-head-name
if(!cxxParserParseUpToOneOf(
CXXTokenTypeEOF | CXXTokenTypeSemicolon |
CXXTokenTypeParenthesisChain | CXXTokenTypeOpeningBracket
))
{
CXX_DEBUG_LEAVE_TEXT("Could not parse enum name");
return FALSE;
}
if(cxxTokenTypeIs(g_cxx.pToken,CXXTokenTypeParenthesisChain))
{
// probably a function declaration/prototype
// something like enum x func()....
// do not clear statement
CXX_DEBUG_LEAVE_TEXT("Probably a function declaration!");
return TRUE;
}
// FIXME: This block is duplicated in struct/union/class
if(cxxTokenTypeIs(g_cxx.pToken,CXXTokenTypeSemicolon))
{
if(g_cxx.pTokenChain->iCount > 3)
{
// [typedef] struct X Y; <-- typedef has been removed!
if(g_cxx.uKeywordState & CXXParserKeywordStateSeenTypedef)
cxxParserExtractTypedef(g_cxx.pTokenChain,TRUE);
else
cxxParserExtractVariableDeclarations(g_cxx.pTokenChain,0);
}
cxxParserNewStatement();
CXX_DEBUG_LEAVE();
return TRUE;
}
if(cxxTokenTypeIs(g_cxx.pToken,CXXTokenTypeEOF))
{
// tolerate EOF, treat as forward declaration
cxxParserNewStatement();
CXX_DEBUG_LEAVE_TEXT("EOF before enum block: treating as forward declaration");
return TRUE;
}
// semicolon or opening bracket
// check if we can extract a class name identifier
CXXToken * pEnumName = cxxTokenChainLastTokenOfType(
g_cxx.pTokenChain,
CXXTokenTypeIdentifier
);
int iPushedScopes = 0;
if(pEnumName)
{
// good.
// It may be qualified though.
CXXToken * pNamespaceBegin = pEnumName;
CXXToken * pPrev = pEnumName->pPrev;
while(pPrev)
{
if(!cxxTokenTypeIs(pPrev,CXXTokenTypeMultipleColons))
break;
pPrev = pPrev->pPrev;
if(!pPrev)
break;
if(!cxxTokenTypeIs(pPrev,CXXTokenTypeIdentifier))
break;
pNamespaceBegin = pPrev;
pPrev = pPrev->pPrev;
}
while(pNamespaceBegin != pEnumName)
{
CXXToken * pNext = pNamespaceBegin->pNext;
cxxTokenChainTake(g_cxx.pTokenChain,pNamespaceBegin);
// FIXME: We don't really know if it's a class!
cxxScopePush(pNamespaceBegin,CXXTagKindCLASS,CXXScopeAccessUnknown);
iPushedScopes++;
pNamespaceBegin = pNext->pNext;
}
CXX_DEBUG_PRINT("Enum name is %s",vStringValue(pEnumName->pszWord));
cxxTokenChainTake(g_cxx.pTokenChain,pEnumName);
} else {
pEnumName = cxxTokenCreateAnonymousIdentifier(CXXTagKindENUM);
CXX_DEBUG_PRINT(
"Enum name is %s (anonymous)",
vStringValue(pEnumName->pszWord)
);
}
tagEntryInfo * tag = cxxTagBegin(CXXTagKindENUM,pEnumName);
int iCorkQueueIndex = CORK_NIL;
if(tag)
{
// FIXME: this is debatable
tag->isFileScope = !isInputHeaderFile();
iCorkQueueIndex = cxxTagCommit();
}
cxxScopePush(pEnumName,CXXTagKindENUM,CXXScopeAccessPublic);
iPushedScopes++;
vString * pScopeName = cxxScopeGetFullNameAsString();
// Special kind of block
for(;;)
{
cxxTokenChainClear(g_cxx.pTokenChain);
if(!cxxParserParseUpToOneOf(
CXXTokenTypeComma | CXXTokenTypeClosingBracket | CXXTokenTypeEOF
))
{
CXX_DEBUG_LEAVE_TEXT("Failed to parse enum contents");
if(pScopeName)
vStringDelete(pScopeName);
return FALSE;
}
CXXToken * pFirst = cxxTokenChainFirst(g_cxx.pTokenChain);
// enumerator.
if(
(g_cxx.pTokenChain->iCount > 1) &&
cxxTokenTypeIs(pFirst,CXXTokenTypeIdentifier)
)
{
tag = cxxTagBegin(CXXTagKindENUMERATOR,pFirst);
if(tag)
{
tag->isFileScope = !isInputHeaderFile();
cxxTagCommit();
}
}
if(cxxTokenTypeIsOneOf(
g_cxx.pToken,
CXXTokenTypeEOF | CXXTokenTypeClosingBracket
))
break;
}
if(iCorkQueueIndex > CORK_NIL)
cxxParserMarkEndLineForTagInCorkQueue(iCorkQueueIndex);
while(iPushedScopes > 0)
{
cxxScopePop();
iPushedScopes--;
}
boolean bRet = cxxParserParseEnumStructClassOrUnionFullDeclarationTrailer(
bParsingTypedef,
CXXKeywordENUM,
CXXTagKindENUM,
vStringValue(pScopeName)
);
if(pScopeName)
vStringDelete(pScopeName);
cxxParserNewStatement();
CXX_DEBUG_LEAVE();
return bRet;
};
//
// This function parses input until one of the specified
// tokens appears. The algorithm will also build subchains of matching
// pairs ([...],(...),<...>,{...}): within the subchain analysis
// of uTokenTypes is completly disabled. Subchains do nest.
//
// Returns true if it stops before EOF or it stops at EOF and CXXTokenTypeEOF
// is present in uTokenTypes. Returns false in all the other stop conditions
// and when an unmatched subchain character pair is found (syntax error).
//
boolean cxxParserParseAndCondenseSubchainsUpToOneOf(
unsigned int uTokenTypes,
unsigned int uInitialSubchainMarkerTypes
)
{
CXX_DEBUG_ENTER_TEXT("Token types = 0x%x",uTokenTypes);
if(!cxxParserParseNextToken())
{
CXX_DEBUG_LEAVE_TEXT("Found EOF");
return (uTokenTypes & CXXTokenTypeEOF); // was already at EOF
}
// see the declaration of CXXTokenType enum.
// Shifting by 4 gives the corresponding closing token type
unsigned int uFinalSubchainMarkerTypes = uInitialSubchainMarkerTypes << 4;
for(;;)
{
//CXX_DEBUG_PRINT(
// "Current token is '%s' 0x%x",
// vStringValue(g_cxx.pToken->pszWord),
// g_cxx.pToken->eType
//);
if(cxxTokenTypeIsOneOf(g_cxx.pToken,uTokenTypes))
{
CXX_DEBUG_LEAVE_TEXT(
"Got terminator token '%s' 0x%x",
vStringValue(g_cxx.pToken->pszWord),
g_cxx.pToken->eType
);
return TRUE;
}
if(cxxTokenTypeIsOneOf(g_cxx.pToken,uInitialSubchainMarkerTypes))
{
// subchain
CXX_DEBUG_PRINT(
"Got subchain start token '%s' 0x%x",
vStringValue(g_cxx.pToken->pszWord),
g_cxx.pToken->eType
);
CXXToken * pParenthesis;
if(
cxxTokenTypeIs(g_cxx.pToken,CXXTokenTypeOpeningBracket) &&
cxxParserCurrentLanguageIsCPP() &&
(pParenthesis = cxxParserOpeningBracketIsLambda())
)
{
if(!cxxParserHandleLambda(pParenthesis))
{
CXX_DEBUG_LEAVE_TEXT("Failed to handle lambda");
return FALSE;
}
} else {
if(!cxxParserParseAndCondenseCurrentSubchain(
uInitialSubchainMarkerTypes,
(uTokenTypes & CXXTokenTypeEOF)
)
)
{
CXX_DEBUG_LEAVE_TEXT(
"Failed to parse subchain of type 0x%x",
g_cxx.pToken->eType
);
return FALSE;
}
}
if(cxxTokenTypeIsOneOf(g_cxx.pToken,uTokenTypes))
{
// was looking for a subchain
CXX_DEBUG_LEAVE_TEXT(
"Got terminator subchain token 0x%x",
g_cxx.pToken->eType
);
return TRUE;
}
if(!cxxParserParseNextToken())
{
CXX_DEBUG_LEAVE_TEXT("Found EOF(2)");
return (uTokenTypes & CXXTokenTypeEOF); // was already at EOF
}
continue; // jump up to avoid checking for mismatched pairs below
}
// Check for mismatched brackets/parenthis
// Note that if we were looking for one of [({ then we would have matched
// it at the top of the for
if(cxxTokenTypeIsOneOf(g_cxx.pToken,uFinalSubchainMarkerTypes))
{
CXX_DEBUG_LEAVE_TEXT(
"Got mismatched subchain terminator 0x%x",
g_cxx.pToken->eType
);
return FALSE; // unmatched: syntax error
}
if(!cxxParserParseNextToken())
{
CXX_DEBUG_LEAVE_TEXT("Found EOF(3)");
return (uTokenTypes & CXXTokenTypeEOF); // was already at EOF
}
}
// not reached
CXX_DEBUG_LEAVE_TEXT("Internal error");
return FALSE;
}
boolean cxxParserParseIfForWhileSwitch(void)
{
CXX_DEBUG_ENTER();
if(!cxxParserParseUpToOneOf(
CXXTokenTypeParenthesisChain | CXXTokenTypeSemicolon |
CXXTokenTypeOpeningBracket | CXXTokenTypeEOF
))
{
CXX_DEBUG_LEAVE_TEXT("Failed to parse if/for/while/switch up to parenthesis");
return FALSE;
}
if(cxxTokenTypeIsOneOf(g_cxx.pToken,CXXTokenTypeEOF | CXXTokenTypeSemicolon))
{
CXX_DEBUG_LEAVE_TEXT("Found EOF/semicolon while parsing if/for/while/switch");
return TRUE;
}
if(cxxTokenTypeIs(g_cxx.pToken,CXXTokenTypeParenthesisChain))
{
// Extract variables from the parenthesis chain
// We handle only simple cases.
CXXTokenChain * pChain = g_cxx.pToken->pChain;
CXX_DEBUG_ASSERT(
pChain->iCount >= 2,
"The parenthesis chain must have initial and final parenthesis"
);
// Simple check for cases like if(a & b), if(a * b).
// If there is &, && or * then we expect there to be also a =.
if(
// & && * not present
!cxxTokenChainFirstTokenOfType(
pChain,
CXXTokenTypeAnd | CXXTokenTypeMultipleAnds |
CXXTokenTypeStar
) ||
// or = present
cxxTokenChainFirstTokenOfType(
pChain,
CXXTokenTypeAssignment
)
)
{
// Kill the initial parenthesis
cxxTokenChainDestroyFirst(pChain);
// Fake the final semicolon
CXXToken * t = cxxTokenChainLast(pChain);
t->eType = CXXTokenTypeSemicolon;
vStringClear(t->pszWord);
vStringPut(t->pszWord,';');
// and extract variable declarations if possible
cxxParserExtractVariableDeclarations(pChain,0);
}
CXX_DEBUG_LEAVE_TEXT("Found if/for/while/switch parenthesis chain");
return TRUE;
}
// must be opening bracket: parse it here.
boolean bRet = cxxParserParseBlock(TRUE);
CXX_DEBUG_LEAVE();
return bRet;
}
bool cxxParserParseBlockHandleOpeningBracket(void)
{
CXX_DEBUG_ENTER();
CXX_DEBUG_ASSERT(
g_cxx.pToken->eType == CXXTokenTypeOpeningBracket,
"This must be called when pointing at an opening bracket!"
);
enum CXXScopeType eScopeType = cxxScopeGetType();
bool bIsCPP = cxxParserCurrentLanguageIsCPP();
CXXToken * pAux;
if(
(
// something = {...}
(g_cxx.pToken->pPrev) &&
cxxTokenTypeIs(g_cxx.pToken->pPrev,CXXTokenTypeAssignment) &&
(
(eScopeType == CXXScopeTypeFunction) ||
(eScopeType == CXXScopeTypeNamespace)
)
) || (
bIsCPP &&
(g_cxx.pToken->pPrev) &&
(
(
// T { arg1, arg2, ... } (1)
// T object { arg1, arg2, ... } (2)
// new T { arg1, arg2, ... } (3)
// Class::Class() : member { arg1, arg2, ... } { (4)
cxxTokenTypeIs(g_cxx.pToken->pPrev,CXXTokenTypeIdentifier) &&
(
// case 1
(!g_cxx.pToken->pPrev->pPrev) ||
// case 4
cxxTokenTypeIsOneOf(
g_cxx.pToken->pPrev->pPrev,
CXXTokenTypeSingleColon | CXXTokenTypeComma
) ||
// cases 1,2,3 but not 4
(
// more parts of typename or maybe the "new" keyword before the identifier
cxxTokenTypeIsOneOf(
g_cxx.pToken->pPrev->pPrev,
CXXTokenTypeIdentifier | CXXTokenTypeStar | CXXTokenTypeAnd |
CXXTokenTypeGreaterThanSign | CXXTokenTypeKeyword
) &&
// but no parenthesis (discard things like bool test() Q_DECL_NO_THROW { ... })
(!(pAux = cxxTokenChainPreviousTokenOfType(
g_cxx.pToken->pPrev->pPrev,
CXXTokenTypeParenthesisChain
))
)
)
) &&
// "override" is handled as identifier since it's a keyword only after function signatures
(strcmp(vStringValue(g_cxx.pToken->pPrev->pszWord),"override") != 0)
) || (
// type var[][][]..[] { ... }
// (but not '[] { ... }' which is a parameterless lambda)
cxxTokenTypeIs(g_cxx.pToken->pPrev,CXXTokenTypeSquareParenthesisChain) &&
(
pAux = cxxTokenChainPreviousTokenNotOfType(
g_cxx.pToken->pPrev,
CXXTokenTypeSquareParenthesisChain
)
) &&
cxxTokenTypeIs(pAux,CXXTokenTypeIdentifier)
)
)
) || (
// return { }
(!g_cxx.pToken->pPrev) &&
(g_cxx.uKeywordState & CXXParserKeywordStateSeenReturn)
)
)
{
// array or list-like initialisation
bool bRet = cxxParserParseAndCondenseCurrentSubchain(
CXXTokenTypeOpeningBracket | CXXTokenTypeOpeningParenthesis |
CXXTokenTypeOpeningSquareParenthesis,
false,
true
);
CXX_DEBUG_LEAVE_TEXT("Handled array or list-like initialisation or return");
return bRet;
}
// In C++ mode check for lambdas
CXXToken * pParenthesis;
if(
bIsCPP &&
(pParenthesis = cxxParserOpeningBracketIsLambda())
)
{
if(!cxxParserHandleLambda(pParenthesis))
{
CXX_DEBUG_LEAVE_TEXT("Lambda handling failed");
return false;
}
// Note that here we're leaving the token chain "alive" so further parsing can be performed.
CXX_DEBUG_LEAVE_TEXT("Lambda handling succeeded");
return true;
}
int iScopes;
int iCorkQueueIndex = CORK_NIL;
CXXFunctionSignatureInfo oInfo;
if(eScopeType != CXXScopeTypeFunction)
{
// very likely a function definition
// (but may be also a toplevel block, like "extern "C" { ... }")
iScopes = cxxParserExtractFunctionSignatureBeforeOpeningBracket(&oInfo,&iCorkQueueIndex);
// FIXME: Handle syntax (5) of list initialization:
// Class::Class() : member { arg1, arg2, ... } {...
} else {
// some kind of other block:
// - anonymous block
// - block after for(),while(),foreach(),if() and other similar stuff
// (note that {}-style initializers have been handled above and thus are excluded)
iScopes = 0;
}
cxxParserNewStatement();
if(!cxxParserParseBlock(true))
{
CXX_DEBUG_LEAVE_TEXT("Failed to parse nested block");
return false;
}
if(iScopes < 1)
{
CXX_DEBUG_LEAVE_TEXT("The block was not a function");
return true;
}
unsigned long uEndPosition = getInputLineNumber();
// If the function contained a "try" keyword before the opening bracket
// then it's likely to be a function-try-block and should be followed by a catch
// block that is in the same scope.
if(oInfo.uFlags & CXXFunctionSignatureInfoFunctionTryBlock)
{
// look for the catch blocks.
CXX_DEBUG_PRINT("The function is a function-try-block: looking for catch blocks");
for(;;)
{
CXX_DEBUG_PRINT("Looking ahead for a catch block...");
if(!cxxParserParseNextToken())
break; // EOF
if(!cxxTokenIsKeyword(g_cxx.pToken,CXXKeywordCATCH))
{
// No more catches. Unget and exit.
CXX_DEBUG_PRINT("No more catch blocks");
cxxParserUngetCurrentToken();
break;
}
// assume it's a catch block.
CXX_DEBUG_PRINT("Found catch block");
if(!cxxParserParseIfForWhileSwitchCatchParenthesis())
{
CXX_DEBUG_LEAVE_TEXT("Failed to parse the catch parenthesis");
return false;
}
// the standard requires a bracket here (catch block is always a compound statement).
cxxParserNewStatement();
if(!cxxParserParseNextToken())
{
CXX_DEBUG_LEAVE_TEXT("Found EOF while looking for catch() block: playing nice");
break; // EOF (would be a syntax error!)
}
if(!cxxTokenTypeIs(g_cxx.pToken,CXXTokenTypeOpeningBracket))
{
// Aargh...
CXX_DEBUG_LEAVE_TEXT("Found something unexpected while looking for catch() block: playing nice");
cxxParserUngetCurrentToken();
break; // (would be a syntax error!)
}
if(!cxxParserParseBlock(true))
return false;
uEndPosition = getInputLineNumber();
}
}
if(iCorkQueueIndex > CORK_NIL)
cxxParserSetEndLineForTagInCorkQueue(iCorkQueueIndex,uEndPosition);
while(iScopes > 0)
{
cxxScopePop();
iScopes--;
}
CXX_DEBUG_LEAVE();
return true;
}
