rescanReason cxxCppParserMain(const unsigned int passCount)
{
CXX_DEBUG_ENTER();
g_cxx.eLanguage = g_cxx.eCPPLanguage;
rescanReason r = cxxParserMain(passCount);
CXX_DEBUG_LEAVE();
return r;
}
static bool qtMocParseProperty(void)
{
char *pszPropType;
CXX_DEBUG_ENTER();
if(!cxxParserParseNextToken())
{
CXX_DEBUG_LEAVE_TEXT("EOF in cxxParserParseNextToken");
return false;
}
if (!cxxTokenTypeIs(g_cxx.pToken, CXXTokenTypeOpeningParenthesis))
{
CXX_DEBUG_LEAVE_TEXT("Found no Opening Parenthesis after Q_PROPERTY");
return false;
}
if (!cxxParserParseNextToken())
{
CXX_DEBUG_LEAVE_TEXT("EOF in cxxParserParseNextToken");
return false;
}
if (!(cxxTokenTypeIs(g_cxx.pToken, CXXTokenTypeIdentifier)
|| (cxxTokenTypeIs(g_cxx.pToken, CXXTokenTypeKeyword)
&& cxxKeywordMayBePartOfTypeName (g_cxx.pToken->eKeyword))))
{
CXX_DEBUG_LEAVE_TEXT("Found no identifier after Q_PROPERTY(");
cxxParserSkipToClosingParenthesisOrEOF ();
return false;
}
pszPropType = vStringStrdup (g_cxx.pToken->pszWord);
if(!cxxParserParseNextToken())
{
CXX_DEBUG_LEAVE_TEXT("EOF in cxxParserParseNextToken");
eFree (pszPropType);
return false;
}
if (!cxxTokenTypeIs(g_cxx.pToken, CXXTokenTypeIdentifier))
{
CXX_DEBUG_LEAVE_TEXT("Found no identifier after Q_PROPERTY(%s", pszPropType);
cxxParserSkipToClosingParenthesisOrEOF ();
eFree (pszPropType);
return false;
}
qtMocMakeTagForProperty (g_cxx.pToken, pszPropType);
eFree (pszPropType);
cxxParserSkipToClosingParenthesisOrEOF ();
CXX_DEBUG_LEAVE();
return true;
}
static void cxxParserParseNextTokenApplyReplacement(
const cppMacroInfo * pInfo,
CXXToken * pParameterChainToken
)
{
CXX_DEBUG_ENTER();
CXX_DEBUG_ASSERT(pInfo,"Info must be not null");
CXX_DEBUG_ASSERT(pInfo->replacements,"There should be a replacement");
if(!pInfo->hasParameterList)
{
CXX_DEBUG_ASSERT(!pParameterChainToken,"This shouldn't have been extracted");
}
CXXTokenChain * pParameters = NULL;
const char ** aParameters = NULL;
int iParameterCount = 0;
if(pInfo->hasParameterList && pParameterChainToken && (pParameterChainToken->pChain->iCount >= 3))
{
// kill parenthesis
cxxTokenChainDestroyFirst(pParameterChainToken->pChain);
cxxTokenChainDestroyLast(pParameterChainToken->pChain);
pParameters = cxxTokenChainSplitOnComma(
pParameterChainToken->pChain
);
aParameters = (const char **)eMalloc(sizeof(const char *) * pParameters->iCount);
CXXToken * pParam = cxxTokenChainFirst(pParameters);
while(pParam)
{
aParameters[iParameterCount] = vStringValue(pParam->pszWord);
iParameterCount++;
pParam = pParam->pNext;
}
CXX_DEBUG_ASSERT(iParameterCount == pParameters->iCount,"Bad number of parameters found");
}
vString * pReplacement = cppBuildMacroReplacement(pInfo,aParameters,iParameterCount);
if(pParameters)
{
cxxTokenChainDestroy(pParameters);
eFree(aParameters);
}
CXX_DEBUG_PRINT("Applying complex replacement '%s'",vStringValue(pReplacement));
cppUngetString(vStringValue(pReplacement),vStringLength(pReplacement));
vStringDelete(pReplacement);
CXX_DEBUG_LEAVE();
}
// This is called when we encounter a "public", "protected" or "private" keyword
// that is NOT in the class declaration header line.
boolean cxxParserParseAccessSpecifier(void)
{
CXX_DEBUG_ENTER();
enum CXXTagKind eScopeKind = cxxScopeGetKind();
if(
(eScopeKind != CXXTagKindCLASS) &&
(eScopeKind != CXXTagKindSTRUCT) &&
(eScopeKind != CXXTagKindUNION)
)
{
// this is a syntax error: we're in the wrong scope.
CXX_DEBUG_LEAVE_TEXT(
"Access specified in wrong context (%d): "
"bailing out to avoid reporting broken structure",
eScopeKind
);
return FALSE;
}
switch(g_cxx.pToken->eKeyword)
{
case CXXKeywordPUBLIC:
cxxScopeSetAccess(CXXScopeAccessPublic);
break;
case CXXKeywordPRIVATE:
cxxScopeSetAccess(CXXScopeAccessPrivate);
break;
case CXXKeywordPROTECTED:
cxxScopeSetAccess(CXXScopeAccessProtected);
break;
default:
CXX_DEBUG_ASSERT(FALSE,"Bad keyword in cxxParserParseAccessSpecifier!");
break;
}
// skip to the next :, without leaving scope.
if(!cxxParserParseUpToOneOf(
CXXTokenTypeSingleColon | CXXTokenTypeSemicolon |
CXXTokenTypeClosingBracket | CXXTokenTypeEOF
))
{
CXX_DEBUG_LEAVE_TEXT("Failed to parse up to the next ;");
return FALSE;
}
cxxTokenChainClear(g_cxx.pTokenChain);
CXX_DEBUG_LEAVE();
return TRUE;
}
// An macro token was encountered and it expects a parameter list.
// The routine has to check if there is a following parenthesis
// and eventually skip it but it MUST NOT parse the next token
// if it is not a parenthesis. This is because the macro token
// may have a replacement and is that one that has to be returned
// back to the caller from cxxParserParseNextToken().
static bool cxxParserParseNextTokenSkipMacroParenthesis(CXXToken ** ppChain)
{
CXX_DEBUG_ENTER();
CXX_DEBUG_ASSERT(ppChain,"ppChain should not be null here");
cxxParserSkipToNonWhiteSpace();
if(g_cxx.iChar != '(')
{
*ppChain = NULL;
return true; // no parenthesis
}
if(!cxxParserParseNextToken())
{
CXX_DEBUG_LEAVE_TEXT("No next token after ignored identifier");
return false;
}
if(!cxxTokenTypeIs(g_cxx.pToken,CXXTokenTypeOpeningParenthesis))
{
CXX_DEBUG_ASSERT(false,"Should have found an open parenthesis token here!");
CXX_DEBUG_LEAVE_TEXT("Internal error");
return false;
}
if(!cxxParserParseAndCondenseCurrentSubchain(
CXXTokenTypeOpeningParenthesis |
CXXTokenTypeOpeningSquareParenthesis |
CXXTokenTypeOpeningBracket,
false
))
{
CXX_DEBUG_LEAVE_TEXT("Failed to parse and condense subchains");
return false;
}
CXX_DEBUG_ASSERT(
cxxTokenTypeIs(g_cxx.pToken,CXXTokenTypeParenthesisChain),
"Should have a parenthesis chain as last token!"
);
// Now just kill the chain.
*ppChain = cxxTokenChainTakeLast(g_cxx.pTokenChain);
CXX_DEBUG_LEAVE();
return true;
}
//
// 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;
}
static boolean cxxTagCheckTypeField(
CXXToken * pTypeStart,
CXXToken * pTypeEnd
)
{
CXX_DEBUG_ENTER();
if(!pTypeStart || !pTypeEnd)
{
CXX_DEBUG_LEAVE_TEXT("One of the pointers is NULL");
return FALSE;
}
int iTotalCount = 0;
int iParenthesisCount = 0;
int iIdentifierOrKeywordCount = 0;
int iConsecutiveIdentifiers = 0;
while(pTypeStart)
{
iTotalCount++;
if(iTotalCount > 30)
{
CXX_DEBUG_LEAVE_TEXT("The chain is really too long to be a type name");
return FALSE;
}
if(cxxTokenTypeIs(pTypeStart,CXXTokenTypeIdentifier))
{
iConsecutiveIdentifiers++;
iIdentifierOrKeywordCount++;
if(iConsecutiveIdentifiers > 4)
{
// Probably many macros inside. Too many.
CXX_DEBUG_LEAVE_TEXT("Too many consecutive identifiers for a type name");
return FALSE;
}
} else {
iConsecutiveIdentifiers = 0;
if(cxxTokenTypeIs(pTypeStart,CXXTokenTypeParenthesisChain))
{
iParenthesisCount++;
if(iParenthesisCount > 3)
{
CXX_DEBUG_LEAVE_TEXT("Too many non-nested parentheses for a type name");
return FALSE;
}
if(
(iTotalCount > 1) &&
cxxTokenTypeIs(pTypeStart->pPrev,CXXTokenTypeIdentifier) &&
pTypeStart != pTypeEnd &&
pTypeStart->pNext &&
cxxTokenTypeIs(pTypeStart->pNext,CXXTokenTypeIdentifier)
)
{
// identifier () identifier
// Looks suspicious, might be macros gathered by mistake
CXX_DEBUG_LEAVE_TEXT("Identifier-parenthesis-identifier pattern: looks suspicious");
return FALSE;
}
} else if(cxxTokenTypeIs(pTypeStart,CXXTokenTypeKeyword))
{
iIdentifierOrKeywordCount++;
}
}
if(pTypeStart == pTypeEnd)
break;
pTypeStart = pTypeStart->pNext;
}
if(iIdentifierOrKeywordCount < 1)
{
CXX_DEBUG_LEAVE_TEXT("Type does not seem to contains identifiers or keywords, can't be a type name");
return FALSE;
}
if(!pTypeStart)
{
CXX_DEBUG_LEAVE_TEXT("Type tokens do not belong to the same chain!");
return FALSE;
}
CXX_DEBUG_LEAVE();
return TRUE;
}
// The __attribute__((...)) sequence complicates parsing quite a lot.
// For this reason we attempt to "hide" it from the rest of the parser
// at tokenizer level.
static bool cxxParserParseNextTokenCondenseAttribute(void)
{
CXX_DEBUG_ENTER();
CXX_DEBUG_ASSERT(
cxxTokenIsKeyword(g_cxx.pToken,CXXKeyword__ATTRIBUTE__),
"This function should be called only after we have parsed __attribute__"
);
// Kill it
cxxTokenDestroy(cxxTokenChainTakeLast(g_cxx.pTokenChain));
// And go ahead.
if(!cxxParserParseNextToken())
{
CXX_DEBUG_LEAVE_TEXT("No next token after __attribute__");
return false;
}
if(!cxxTokenTypeIs(g_cxx.pToken,CXXTokenTypeOpeningParenthesis))
{
CXX_DEBUG_LEAVE_TEXT("Something that is not an opening parenthesis");
return true;
}
if(!cxxParserParseAndCondenseCurrentSubchain(
CXXTokenTypeOpeningParenthesis |
CXXTokenTypeOpeningSquareParenthesis |
CXXTokenTypeOpeningBracket,
false
))
{
CXX_DEBUG_LEAVE_TEXT("Failed to parse and condense subchains");
return false;
}
CXX_DEBUG_ASSERT(
cxxTokenTypeIs(g_cxx.pToken,CXXTokenTypeParenthesisChain),
"Should have a parenthesis chain as last token!"
);
// Try to make sense of certain kinds of __attribute__.
// the proper syntax is __attribute__(()), so look at the inner chain
CXXToken * pInner = cxxTokenChainFirst(g_cxx.pToken->pChain);
if(pInner)
{
if(pInner->pNext && cxxTokenTypeIs(pInner->pNext,CXXTokenTypeParenthesisChain))
pInner = cxxTokenChainFirst(pInner->pNext->pChain);
while(pInner)
{
if(cxxTokenTypeIs(pInner,CXXTokenTypeIdentifier))
{
CXX_DEBUG_PRINT("Analyzing attribyte %s",vStringValue(pInner->pszWord));
if(
(strcmp(vStringValue(pInner->pszWord),"always_inline") == 0) ||
(strcmp(vStringValue(pInner->pszWord),"__always_inline__") == 0)
)
{
CXX_DEBUG_PRINT("Found attribute 'always_inline'");
// assume "inline" has been seen.
g_cxx.uKeywordState |= CXXParserKeywordStateSeenInline;
} else if(
(strcmp(vStringValue(pInner->pszWord),"deprecated") == 0) ||
(strcmp(vStringValue(pInner->pszWord),"__deprecated__") == 0)
)
{
CXX_DEBUG_PRINT("Found attribute 'deprecated'");
// assume "inline" has been seen.
g_cxx.uKeywordState |= CXXParserKeywordStateSeenAttributeDeprecated;
}
}
// If needed, we could attach certain attributes to previous
// identifiers. But note that __attribute__ may apply to a
// following identifier too.
pInner = pInner->pNext;
}
}
// Now just kill the chain.
cxxTokenDestroy(cxxTokenChainTakeLast(g_cxx.pTokenChain));
// And finally extract yet another token.
CXX_DEBUG_LEAVE();
return cxxParserParseNextToken();
}
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;
}
//
// 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;
}
// In case of a lambda without parentheses this is the capture list token.
boolean cxxParserHandleLambda(CXXToken * pParenthesis)
{
CXX_DEBUG_ENTER();
CXXToken * pIdentifier = cxxTokenCreateAnonymousIdentifier(CXXTagKindFUNCTION);
CXXTokenChain * pSave = g_cxx.pTokenChain;
CXXTokenChain * pNew = cxxTokenChainCreate();
g_cxx.pTokenChain = pNew;
tagEntryInfo * tag = cxxTagBegin(CXXTagKindFUNCTION,pIdentifier);
CXXToken * pAfterParenthesis = pParenthesis ? pParenthesis->pNext : NULL;
CXXToken * pCaptureList = NULL;
if(pParenthesis)
{
if(cxxTokenTypeIs(pParenthesis,CXXTokenTypeSquareParenthesisChain))
{
// form (4) of lambda (see cxxParserOpeningBracketIsLambda()).
pCaptureList = pParenthesis;
} else if(
pParenthesis->pPrev &&
cxxTokenTypeIs(pParenthesis->pPrev,CXXTokenTypeSquareParenthesisChain)
)
{
// other forms of lambda (see cxxParserOpeningBracketIsLambda()).
pCaptureList = pParenthesis->pPrev;
}
}
if(
pAfterParenthesis &&
cxxTokenTypeIs(pAfterParenthesis,CXXTokenTypeKeyword) &&
(pAfterParenthesis->eKeyword == CXXKeywordCONST)
)
pAfterParenthesis = pAfterParenthesis->pNext;
CXXToken * pTypeStart = NULL;
CXXToken * pTypeEnd;
if(
pAfterParenthesis &&
cxxTokenTypeIs(pAfterParenthesis,CXXTokenTypePointerOperator) &&
pAfterParenthesis->pNext &&
!cxxTokenTypeIs(pAfterParenthesis->pNext,CXXTokenTypeOpeningBracket)
)
{
pTypeStart = pAfterParenthesis->pNext;
pTypeEnd = pTypeStart;
while(
pTypeEnd->pNext &&
(!cxxTokenTypeIs(pTypeEnd->pNext,CXXTokenTypeOpeningBracket))
)
pTypeEnd = pTypeEnd->pNext;
while(
(pTypeStart != pTypeEnd) &&
cxxTokenTypeIs(pTypeStart,CXXTokenTypeKeyword) &&
cxxKeywordExcludeFromTypeNames(pTypeStart->eKeyword)
)
pTypeStart = pTypeStart->pNext;
}
int iCorkQueueIndex = CORK_NIL;
if(tag)
{
tag->isFileScope = TRUE;
CXXToken * pTypeName;
if(pTypeStart)
pTypeName = cxxTagSetTypeField(pTypeStart,pTypeEnd);
else
pTypeName = NULL;
if(pCaptureList && cxxTagCPPFieldEnabled(CXXTagCPPFieldLambdaCaptureList))
{
CXX_DEBUG_ASSERT(pCaptureList->pChain,"The capture list must be a chain");
cxxTokenChainCondense(pCaptureList->pChain,0);
CXX_DEBUG_ASSERT(
cxxTokenChainFirst(pCaptureList->pChain),
"Condensation should have created a single token in the chain"
);
cxxTagSetCPPField(
CXXTagCPPFieldLambdaCaptureList,
vStringValue(cxxTokenChainFirst(pCaptureList->pChain)->pszWord)
);
}
// FIXME: Properties?
vString * pszSignature = NULL;
if(cxxTokenTypeIs(pParenthesis,CXXTokenTypeParenthesisChain))
pszSignature = cxxTokenChainJoin(pParenthesis->pChain,NULL,0);
if(pszSignature)
tag->extensionFields.signature = vStringValue(pszSignature);
iCorkQueueIndex = cxxTagCommit();
if(pTypeName)
cxxTokenDestroy(pTypeName);
if(pszSignature)
vStringDelete(pszSignature);
}
cxxScopePush(
pIdentifier,
CXXTagKindFUNCTION,
CXXScopeAccessUnknown
);
if(
pParenthesis &&
cxxTokenTypeIs(pParenthesis,CXXTokenTypeParenthesisChain) &&
cxxTagKindEnabled(CXXTagKindPARAMETER)
)
{
CXXFunctionParameterInfo oParamInfo;
if(cxxParserTokenChainLooksLikeFunctionParameterList(
pParenthesis->pChain,&oParamInfo
))
cxxParserEmitFunctionParameterTags(&oParamInfo);
}
boolean bRet = cxxParserParseBlock(TRUE);
if(iCorkQueueIndex > CORK_NIL)
cxxParserMarkEndLineForTagInCorkQueue(iCorkQueueIndex);
cxxScopePop();
pNew = g_cxx.pTokenChain; // May have been destroyed and re-created
g_cxx.pTokenChain = pSave;
g_cxx.pToken = pSave->pTail;
// change the type of token so following parsing code is not confused too much
g_cxx.pToken->eType = CXXTokenTypeAngleBracketChain;
g_cxx.pToken->pChain = pNew;
cxxTokenChainClear(pNew);
CXXToken * t = cxxTokenCreate();
t->eType = CXXTokenTypeOpeningBracket;
vStringCatS(t->pszWord,"{");
cxxTokenChainAppend(pNew,t);
t = cxxTokenCreate();
t->eType = CXXTokenTypeClosingBracket;
vStringCatS(t->pszWord,"}");
cxxTokenChainAppend(pNew,t);
CXX_DEBUG_LEAVE();
return bRet;
}
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;
}
//
// The __attribute__((...)) sequence complicates parsing quite a lot.
// For this reason we attempt to "hide" it from the rest of the parser
// at tokenizer level.
//
// Returns false if it finds an EOF. This is an important invariant required by
// cxxParserParseNextToken(), the only caller.
//
static bool cxxParserParseNextTokenCondenseAttribute(void)
{
// Since cxxParserParseNextToken() returns false only when it has found
// an EOF, this function must do the same.
// This means that any broken input must be discarded here.
CXX_DEBUG_ENTER();
CXX_DEBUG_ASSERT(
cxxTokenIsKeyword(g_cxx.pToken,CXXKeyword__ATTRIBUTE__),
"This function should be called only after we have parsed __attribute__"
);
// Kill it
cxxTokenChainDestroyLast(g_cxx.pTokenChain);
// And go ahead.
if(!cxxParserParseNextToken())
{
CXX_DEBUG_LEAVE_TEXT("No next token after __attribute__");
return false;
}
if(!cxxTokenTypeIs(g_cxx.pToken,CXXTokenTypeOpeningParenthesis))
{
CXX_DEBUG_LEAVE_TEXT("Something that is not an opening parenthesis");
return true;
}
// Do NOT accept EOF as a valid terminator as it implies broken input.
if(!cxxParserParseAndCondenseCurrentSubchain(
CXXTokenTypeOpeningParenthesis |
CXXTokenTypeOpeningSquareParenthesis |
CXXTokenTypeOpeningBracket,
false,
false
))
{
// Pasing and/or condensation of the subchain failed. This implies broken
// input (mismatched parenthesis/bracket, early EOF).
CXX_DEBUG_LEAVE_TEXT("Failed to parse subchains. The input is broken...");
// However our invariant (see comment at the beginning of the function)
// forbids us to return false if we didn't find an EOF. So we attempt
// to resume parsing anyway. If there is an EOF, cxxParserParseNextToken()
// will report it.
// Kill the token chain
cxxTokenChainDestroyLast(g_cxx.pTokenChain);
return cxxParserParseNextToken();
}
CXX_DEBUG_ASSERT(
cxxTokenTypeIs(g_cxx.pToken,CXXTokenTypeParenthesisChain),
"Should have a parenthesis chain as last token!"
);
// Try to make sense of certain kinds of __attribute__.
// the proper syntax is __attribute__(()), so look at the inner chain
CXXToken * pInner = cxxTokenChainFirst(g_cxx.pToken->pChain);
if(pInner)
{
if(pInner->pNext && cxxTokenTypeIs(pInner->pNext,CXXTokenTypeParenthesisChain))
pInner = cxxTokenChainFirst(pInner->pNext->pChain);
while(pInner)
{
if(cxxTokenTypeIs(pInner,CXXTokenTypeIdentifier))
{
CXX_DEBUG_PRINT("Analyzing attribyte %s",vStringValue(pInner->pszWord));
if(
(strcmp(vStringValue(pInner->pszWord),"always_inline") == 0) ||
(strcmp(vStringValue(pInner->pszWord),"__always_inline__") == 0)
)
{
CXX_DEBUG_PRINT("Found attribute 'always_inline'");
// assume "inline" has been seen.
g_cxx.uKeywordState |= CXXParserKeywordStateSeenInline;
} else if(
(strcmp(vStringValue(pInner->pszWord),"deprecated") == 0) ||
(strcmp(vStringValue(pInner->pszWord),"__deprecated__") == 0)
)
{
CXX_DEBUG_PRINT("Found attribute 'deprecated'");
// assume "inline" has been seen.
g_cxx.uKeywordState |= CXXParserKeywordStateSeenAttributeDeprecated;
}
}
// If needed, we could attach certain attributes to previous
// identifiers. But note that __attribute__ may apply to a
// following identifier too.
pInner = pInner->pNext;
}
}
// Now just kill the chain.
cxxTokenChainDestroyLast(g_cxx.pTokenChain);
// And finally extract yet another token.
CXX_DEBUG_LEAVE();
return cxxParserParseNextToken();
}
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;
}
static boolean cxxParserParseBlockHandleOpeningBracket(void)
{
CXX_DEBUG_ENTER();
CXX_DEBUG_ASSERT(g_cxx.pToken->eType == CXXTokenTypeOpeningBracket,"This must be called when pointing at an opening bracket!");
enum CXXTagKind eScopeKind = cxxScopeGetKind();
if(
(g_cxx.pToken->pPrev) &&
cxxTokenTypeIs(g_cxx.pToken->pPrev,CXXTokenTypeAssignment) &&
(
(eScopeKind == CXXTagKindFUNCTION) ||
(eScopeKind == CXXTagKindNAMESPACE)
)
)
{
// array or C++11-list-like initialisation
boolean bRet = cxxParserParseAndCondenseCurrentSubchain(
CXXTokenTypeOpeningBracket | CXXTokenTypeOpeningParenthesis | CXXTokenTypeOpeningSquareParenthesis,
FALSE
);
CXX_DEBUG_LEAVE_TEXT("Handled array or C++11-list-like initialisation");
return bRet;
}
int iScopes;
if(eScopeKind != CXXTagKindFUNCTION)
{
// very likely a function definition
iScopes = cxxParserExtractFunctionSignatureBeforeOpeningBracket();
} 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(
cxxParserCurrentLanguageIsCPP() &&
(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;
}
while(iScopes > 0)
{
cxxScopePop();
iScopes--;
}
CXX_DEBUG_LEAVE();
return TRUE;
}
//
// 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");
}
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 is called after a full enum/struct/class/union declaration
// that ends with a closing bracket.
//
static boolean cxxParserParseEnumStructClassOrUnionFullDeclarationTrailer(
boolean bParsingTypedef,
enum CXXKeyword eTagKeyword,
enum CXXTagKind eTagKind,
const char * szTypeName
)
{
CXX_DEBUG_ENTER();
cxxTokenChainClear(g_cxx.pTokenChain);
CXX_DEBUG_PRINT(
"Parse enum/struct/class/union trailer, typename is '%s'",
szTypeName
);
MIOPos oFilePosition = getInputFilePosition();
int iFileLine = getInputLineNumber();
if(!cxxParserParseUpToOneOf(CXXTokenTypeEOF | CXXTokenTypeSemicolon))
{
CXX_DEBUG_LEAVE_TEXT("Failed to parse up to EOF/semicolon");
return FALSE;
}
if(cxxTokenTypeIs(g_cxx.pToken,CXXTokenTypeEOF))
{
// It's a syntax error, but we can be tolerant here.
CXX_DEBUG_LEAVE_TEXT("Got EOF after enum/class/struct/union block");
return TRUE;
}
if(g_cxx.pTokenChain->iCount < 2)
{
CXX_DEBUG_LEAVE_TEXT("Nothing interesting after enum/class/struct block");
return TRUE;
}
// fake the initial two tokens
CXXToken * pIdentifier = cxxTokenCreate();
pIdentifier->oFilePosition = oFilePosition;
pIdentifier->iLineNumber = iFileLine;
pIdentifier->eType = CXXTokenTypeIdentifier;
pIdentifier->bFollowedBySpace = TRUE;
vStringCatS(pIdentifier->pszWord,szTypeName);
cxxTokenChainPrepend(g_cxx.pTokenChain,pIdentifier);
CXXToken * pKeyword = cxxTokenCreate();
pKeyword->oFilePosition = oFilePosition;
pKeyword->iLineNumber = iFileLine;
pKeyword->eType = CXXTokenTypeKeyword;
pKeyword->eKeyword = eTagKeyword;
pKeyword->bFollowedBySpace = TRUE;
vStringCatS(pKeyword->pszWord,cxxTagGetKindOptions()[eTagKind].name);
cxxTokenChainPrepend(g_cxx.pTokenChain,pKeyword);
if(bParsingTypedef)
cxxParserExtractTypedef(g_cxx.pTokenChain,TRUE);
else
cxxParserExtractVariableDeclarations(g_cxx.pTokenChain,0);
CXX_DEBUG_LEAVE();
return TRUE;
}
