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;
}
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;
};
// 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 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;
};