You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
tdevelop/lib/cppparser/parser.cpp

4330 lines
99 KiB

/* This file is part of TDevelop
Copyright (C) 2002,2003 Roberto Raggi <roberto@kdevelop.org>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
// c++ support
#include "driver.h"
#include "lexer.h"
#include "parser.h"
#include "errors.h"
// qt
#include <tqstring.h>
#include <tqstringlist.h>
#include <tqasciidict.h>
#include <kdebug.h>
#include <tdelocale.h>
using namespace std;
#define ADVANCE(tk, descr) \
{ \
const Token& token = lex->lookAhead( 0 ); \
if( token != tk ){ \
reportError( i18n("'%1' expected found '%2'").arg(descr).arg(token.text()) ); \
return false; \
} \
nextToken(); \
}
#define ADVANCE_NR(tk, descr) \
{ \
const Token& token = lex->lookAhead( 0 ); \
if( token != tk ){ \
reportError( i18n("'%1' expected found '%2'").arg(descr).arg(token.text()) ); \
} \
else \
nextToken(); \
}
#define CHECK(tk, descr) \
{ \
const Token& token = lex->lookAhead( 0 ); \
if( token != tk ){ \
return false; \
} \
nextToken(); \
}
#define MATCH(tk, descr) \
{ \
const Token& token = lex->lookAhead( 0 ); \
if( token != tk ){ \
reportError( Errors::SyntaxError ); \
return false; \
} \
}
#define UPDATE_POS(node, start, end) \
{ \
int line, col; \
const Token &a = lex->tokenAt(start); \
const Token &b = lex->tokenAt( end!=start ? end-1 : end ); \
a.getStartPosition( &line, &col ); \
(node)->setStartPosition( line, col ); \
b.getEndPosition( &line, &col ); \
(node)->setEndPosition( line, col ); \
if( (node)->nodeType() == NodeType_Generic ) { \
if ((start) == (end) || (end) == (start)+1) \
(node)->setSlice(lex->source(), a.position(), a.length()); \
else \
(node)->setText( toString((start),(end)) ); \
} \
}
#define AST_FROM_TOKEN(node, tk) \
AST::Node node = CreateNode<AST>(); \
UPDATE_POS( node, (tk), (tk)+1 );
//@todo remove me
enum
{
OBJC_CLASS,
OBJC_PROTOCOL,
OBJC_ALIAS
};
struct ParserPrivateData
{
ParserPrivateData()
{}
};
Parser::Parser( Driver* driver, Lexer* lexer )
: m_driver( driver ),
lex( lexer ), m_problems(0)
{
d = new ParserPrivateData();
m_maxProblems = 5;
objcp = false;
}
Parser::~Parser()
{
delete d;
d = 0;
}
bool Parser::reportError( const Error& err )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::reportError()" << endl;
if( m_problems < m_maxProblems ){
++m_problems;
int line=0, col=0;
const Token& token = lex->lookAhead( 0 );
lex->getTokenPosition( token, &line, &col );
TQString s = lex->lookAhead(0).text();
s = s.left( 30 ).stripWhiteSpace();
if( s.isEmpty() )
s = i18n( "<eof>" );
m_driver->addProblem( m_driver->currentFileName(), Problem(err.text.arg(s), line, col) );
}
return true;
}
bool Parser::reportError( const TQString& msg )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::reportError()" << endl;
if( m_problems < m_maxProblems ){
++m_problems;
int line=0, col=0;
const Token& token = lex->lookAhead( 0 );
lex->getTokenPosition( token, &line, &col );
m_driver->addProblem( m_driver->currentFileName(), Problem(msg, line, col) );
}
return true;
}
void Parser::syntaxError()
{
(void) reportError( Errors::SyntaxError );
}
bool Parser::skipUntil( int token )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::skipUntil()" << endl;
while( !lex->lookAhead(0).isNull() ){
if( lex->lookAhead(0) == token )
return true;
nextToken();
}
return false;
}
bool Parser::skipUntilDeclaration()
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::skipUntilDeclaration()" << endl;
clearComment();
while( !lex->lookAhead(0).isNull() ){
switch( lex->lookAhead(0) ){
case ';':
case '~':
case Token_scope:
case Token_identifier:
case Token_operator:
case Token_char:
case Token_wchar_t:
case Token_bool:
case Token_short:
case Token_int:
case Token_long:
case Token_signed:
case Token_unsigned:
case Token_float:
case Token_double:
case Token_void:
case Token_extern:
case Token_namespace:
case Token_using:
case Token_typedef:
case Token_asm:
case Token_template:
case Token_export:
case Token_const: // cv
case Token_volatile: // cv
case Token_public:
case Token_protected:
case Token_private:
case Token_signals: // TQt
case Token_slots: // TQt
return true;
default:
nextToken();
}
}
return false;
}
bool Parser::skipUntilStatement()
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::skipUntilStatement() -- token = " << lex->lookAhead(0).text() << endl;
while( !lex->lookAhead(0).isNull() ){
switch( lex->lookAhead(0) ){
case ';':
case '{':
case '}':
case Token_const:
case Token_volatile:
case Token_identifier:
case Token_case:
case Token_default:
case Token_if:
case Token_switch:
case Token_while:
case Token_do:
case Token_for:
case Token_break:
case Token_continue:
case Token_return:
case Token_goto:
case Token_try:
case Token_catch:
case Token_throw:
case Token_char:
case Token_wchar_t:
case Token_bool:
case Token_short:
case Token_int:
case Token_long:
case Token_signed:
case Token_unsigned:
case Token_float:
case Token_double:
case Token_void:
case Token_class:
case Token_struct:
case Token_union:
case Token_enum:
case Token_scope:
case Token_template:
case Token_using:
return true;
default:
nextToken();
}
}
return false;
}
bool Parser::skip( int l, int r )
{
int count = 0;
while( !lex->lookAhead(0).isNull() ){
int tk = lex->lookAhead( 0 );
if( tk == l )
++count;
else if( tk == r )
--count;
else if( l != '{' && (tk == '{' || tk == '}' || tk == ';') )
return false;
if( count == 0 )
return true;
nextToken();
}
return false;
}
bool Parser::skipCommaExpression( AST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::skipCommaExpression()" << endl;
int start = lex->index();
AST::Node expr;
if( !skipExpression(expr) )
return false;
while( lex->lookAhead(0) == ',' ){
nextToken();
if( !skipExpression(expr) ){
reportError( i18n("expression expected") );
return false;
}
}
AST::Node ast = CreateNode<AST>();
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::skipExpression( AST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::skipExpression()" << endl;
int start = lex->index();
while( !lex->lookAhead(0).isNull() ){
int tk = lex->lookAhead( 0 );
switch( tk ){
case '(':
skip( '(', ')' );
nextToken();
break;
case '[':
skip( '[', ']' );
nextToken();
break;
#if 0
case Token_identifier:
nextToken();
if( lex->lookAhead( 0 ) == Token_identifier )
return true;
break;
#endif
case ';':
case ',':
case ']':
case ')':
case '{':
case '}':
case Token_case:
case Token_default:
case Token_if:
case Token_while:
case Token_do:
case Token_for:
case Token_break:
case Token_continue:
case Token_return:
case Token_goto:
{
AST::Node ast = CreateNode<AST>();
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
}
return true;
default:
nextToken();
}
}
return false;
}
bool Parser::parseName( NameAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseName()" << endl;
GroupAST::Node winDeclSpec;
parseWinDeclSpec( winDeclSpec );
int start = lex->index();
NameAST::Node ast = CreateNode<NameAST>();
if( lex->lookAhead(0) == Token_scope ){
ast->setGlobal( true );
nextToken();
}
int idx = lex->index();
while( true ){
ClassOrNamespaceNameAST::Node n;
if( !parseUnqualifiedName(n) ) {
return false;
}
if( lex->lookAhead(0) == Token_scope ){
nextToken();
ast->addClassOrNamespaceName( n );
if( lex->lookAhead(0) == Token_template )
nextToken(); /// skip optional template #### @todo CHECK
} else {
ast->setUnqualifiedName( n );
break;
}
}
if( idx == lex->index() )
return false;
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseTranslationUnit( TranslationUnitAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseTranslationUnit()" << endl;
int start = lex->index();
m_problems = 0;
TranslationUnitAST::Node tun = CreateNode<TranslationUnitAST>();
node = std::move(tun);
if( lex->lookAhead(0) == Token_comment ) {
node->setComment( lex->lookAhead(0).text() );
nextToken();
}
while( !lex->lookAhead(0).isNull() ){
DeclarationAST::Node def;
int startDecl = lex->index();
if( !parseDeclaration(def) ){
// error recovery
if( startDecl == lex->index() )
nextToken(); // skip at least one token
skipUntilDeclaration();
}
node->addDeclaration( def );
}
UPDATE_POS( node, start, lex->index() );
// force (0,0) as start position
node->setStartPosition( 0, 0 );
return m_problems == 0;
}
bool Parser::parseDeclaration( DeclarationAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseDeclaration()" << endl;
int start = lex->index();
switch( lex->lookAhead(0) ){
case ';':
nextToken();
return true;
case Token_extern:
return parseLinkageSpecification( node );
case Token_namespace:
return parseNamespace( node );
case Token_using:
return parseUsing( node );
case Token_typedef:
return parseTypedef( node );
case Token_asm:
return parseAsmDefinition( node );
case Token_template:
case Token_export:
return parseTemplateDeclaration( node );
default:
{
// lex->setIndex( start );
if( objcp && parseObjcDef(node) )
return true;
lex->setIndex( start );
GroupAST::Node storageSpec;
parseStorageClassSpecifier( storageSpec );
GroupAST::Node cv;
parseCvQualify( cv );
TypeSpecifierAST::Node spec;
AST::Node declarator;
if( parseEnumSpecifier(spec) || parseClassSpecifier(spec) ) {
int line, c;
spec->getEndPosition( &line, &c );
spec->setCvQualify( cv );
GroupAST::Node cv2;
parseCvQualify( cv2 );
spec->setCv2Qualify( cv2 );
InitDeclaratorListAST::Node declarators;
parseInitDeclaratorList(declarators);
SimpleDeclarationAST::Node ast = CreateNode<SimpleDeclarationAST>();
ADVANCE( ';', ";" );
preparseLineComments( line );
ast->setComment( m_commentStore.getCommentInRange( line ) );
ast->setStorageSpecifier( storageSpec );
ast->setTypeSpec( spec );
ast->setInitDeclaratorList( declarators );
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
lex->setIndex( start );
return parseDeclarationInternal( node );
}
} // end switch
}
bool Parser::parseLinkageSpecification( DeclarationAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseLinkageSpecification()" << endl;
int start = lex->index();
if( lex->lookAhead(0) != Token_extern ){
return false;
}
nextToken();
LinkageSpecificationAST::Node ast = CreateNode<LinkageSpecificationAST>();
int startExternType = lex->index();
if( lex->lookAhead(0) == Token_string_literal ){
nextToken();
AST::Node externType = CreateNode<AST>();
UPDATE_POS( externType, startExternType, lex->index() );
ast->setExternType( externType );
}
if( lex->lookAhead(0) == '{' ){
LinkageBodyAST::Node linkageBody;
parseLinkageBody( linkageBody );
ast->setLinkageBody( linkageBody );
} else {
DeclarationAST::Node decl;
if( !parseDeclaration(decl) ){
reportError( i18n("Declaration syntax error") );
}
ast->setDeclaration( decl );
}
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseLinkageBody( LinkageBodyAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseLinkageBody()" << endl;
int start = lex->index();
if( lex->lookAhead(0) != '{' ){
return false;
}
nextToken();
LinkageBodyAST::Node lba = CreateNode<LinkageBodyAST>();
node = std::move(lba);
while( !lex->lookAhead(0).isNull() ){
int tk = lex->lookAhead( 0 );
if( tk == '}' )
break;
DeclarationAST::Node def;
int startDecl = lex->index();
if( parseDeclaration(def) ){
node->addDeclaration( def );
} else {
// error recovery
if( startDecl == lex->index() )
nextToken(); // skip at least one token
skipUntilDeclaration();
}
}
clearComment();
if( lex->lookAhead(0) != '}' ){
reportError( i18n("} expected") );
} else
nextToken();
UPDATE_POS( node, start, lex->index() );
return true;
}
bool Parser::parseNamespace( DeclarationAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseNamespace()" << endl;
int start = lex->index();
if( lex->lookAhead(0) != Token_namespace ){
return false;
}
nextToken();
int startNamespaceName = lex->index();
if( lex->lookAhead(0) == Token_identifier ){
nextToken();
}
AST::Node namespaceName = CreateNode<AST>();
UPDATE_POS( namespaceName, startNamespaceName, lex->index() );
if ( lex->lookAhead(0) == '=' ) {
// namespace alias
nextToken();
NameAST::Node name;
if( parseName(name) ){
ADVANCE( ';', ";" );
NamespaceAliasAST::Node ast = CreateNode<NamespaceAliasAST>();
ast->setNamespaceName( namespaceName );
ast->setAliasName( name );
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
} else {
reportError( i18n("namespace expected") );
return false;
}
} else if( lex->lookAhead(0) != '{' ){
reportError( i18n("{ expected") );
return false;
}
NamespaceAST::Node ast = CreateNode<NamespaceAST>();
ast->setNamespaceName( namespaceName );
LinkageBodyAST::Node linkageBody;
parseLinkageBody( linkageBody );
ast->setLinkageBody( linkageBody );
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseUsing( DeclarationAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseUsing()" << endl;
int start = lex->index();
if( lex->lookAhead(0) != Token_using ){
return false;
}
nextToken();
if( lex->lookAhead(0) == Token_namespace ){
if( !parseUsingDirective(node) ){
return false;
}
UPDATE_POS( node, start, lex->index() );
return true;
}
UsingAST::Node ast = CreateNode<UsingAST>();
int startTypeName = lex->index();
if( lex->lookAhead(0) == Token_typename ){
nextToken();
AST::Node tn = CreateNode<AST>();
UPDATE_POS( tn, startTypeName, lex->index() );
ast->setTypeName( tn );
}
NameAST::Node name;
if( !parseName(name) )
return false;
ast->setName( name );
ADVANCE( ';', ";" );
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseUsingDirective( DeclarationAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseUsingDirective()" << endl;
int start = lex->index();
if( lex->lookAhead(0) != Token_namespace ){
return false;
}
nextToken();
NameAST::Node name;
if( !parseName(name) ){
reportError( i18n("Namespace name expected") );
return false;
}
ADVANCE( ';', ";" );
UsingDirectiveAST::Node ast = CreateNode<UsingDirectiveAST>();
ast->setName( name );
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseOperatorFunctionId( AST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseOperatorFunctionId()" << endl;
int start = lex->index();
if( lex->lookAhead(0) != Token_operator ){
return false;
}
nextToken();
AST::Node op;
if( parseOperator(op) ){
AST::Node asn = CreateNode<AST>();
node = std::move(asn);
UPDATE_POS( node, start, lex->index() );
return true;
} else {
// parse cast operator
GroupAST::Node cv;
parseCvQualify(cv);
TypeSpecifierAST::Node spec;
if( !parseSimpleTypeSpecifier(spec) ){
syntaxError();
return false;
}
spec->setCvQualify( cv );
GroupAST::Node cv2;
parseCvQualify(cv2);
spec->setCv2Qualify( cv2 );
AST::Node ptrOp;
while( parsePtrOperator(ptrOp) )
;
AST::Node asn = CreateNode<AST>();
node = std::move(asn);
UPDATE_POS( node, start, lex->index() );
return true;
}
}
bool Parser::parseTemplateArgumentList( TemplateArgumentListAST::Node& node, bool reportError )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseTemplateArgumentList()" << endl;
int start = lex->index();
TemplateArgumentListAST::Node ast = CreateNode<TemplateArgumentListAST>();
AST::Node templArg;
if( !parseTemplateArgument(templArg) )
return false;
ast->addArgument( templArg );
while( lex->lookAhead(0) == ',' ){
nextToken();
if( !parseTemplateArgument(templArg) ){
if( reportError ){
syntaxError();
break;
} else
return false;
}
ast->addArgument( templArg );
}
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseTypedef( DeclarationAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseTypedef()" << endl;
int start = lex->index();
if( lex->lookAhead(0) != Token_typedef ){
return false;
}
nextToken();
TypeSpecifierAST::Node spec;
if( !parseTypeSpecifierOrClassSpec(spec) ){
reportError( i18n("Need a type specifier to declare") );
return false;
}
InitDeclaratorListAST::Node declarators;
if( !parseInitDeclaratorList(declarators) ){
//reportError( i18n("Need an identifier to declare") );
//return false;
}
TypedefAST::Node ast = CreateNode<TypedefAST>();
if( comment() ) {
ast->setComment( comment() );
clearComment();
preparseLineComments( currentLine() );
if( comment() ) {
ast->addComment( comment() );
clearComment();
}
}
ADVANCE( ';', ";" );
ast->setTypeSpec( spec );
ast->setInitDeclaratorList( declarators );
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseAsmDefinition( DeclarationAST::Node& /*node*/ )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseAsmDefinition()" << endl;
ADVANCE( Token_asm, "asm" );
GroupAST::Node cv;
parseCvQualify( cv );
skip( '(', ')' );
ADVANCE( ')', ")" );
ADVANCE( ';', ';' );
return true;
}
bool Parser::parseTemplateDeclaration( DeclarationAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseTemplateDeclaration()" << endl;
int start = lex->index();
AST::Node exp;
int startExport = lex->index();
if( lex->lookAhead(0) == Token_export ){
nextToken();
AST::Node n = CreateNode<AST>();
UPDATE_POS( n, startExport, lex->index() );
exp = std::move(n);
}
if( lex->lookAhead(0) != Token_template ){
return false;
}
nextToken();
TemplateParameterListAST::Node params;
if( lex->lookAhead(0) == '<' ){
nextToken();
parseTemplateParameterList( params );
ADVANCE( '>', ">" );
}
DeclarationAST::Node def;
if( !parseDeclaration(def) ){
reportError( i18n("expected a declaration") );
}
TemplateDeclarationAST::Node ast = CreateNode<TemplateDeclarationAST>();
ast->setExported( exp );
ast->setTemplateParameterList( params );
ast->setDeclaration( def );
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseOperator( AST::Node& /*node*/ )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseOperator()" << endl;
TQString text = lex->lookAhead(0).text();
switch( lex->lookAhead(0) ){
case Token_new:
case Token_delete:
nextToken();
if( lex->lookAhead(0) == '[' && lex->lookAhead(1) == ']' ){
nextToken();
nextToken();
text += "[]";
}
return true;
case '+':
case '-':
case '*':
case '/':
case '%':
case '^':
case '&':
case '|':
case '~':
case '!':
case '=':
case '<':
case '>':
case ',':
case Token_assign:
case Token_shift:
case Token_eq:
case Token_not_eq:
case Token_leq:
case Token_geq:
case Token_and:
case Token_or:
case Token_incr:
case Token_decr:
case Token_ptrmem:
case Token_arrow:
nextToken();
return true;
default:
if( lex->lookAhead(0) == '(' && lex->lookAhead(1) == ')' ){
nextToken();
nextToken();
return true;
} else if( lex->lookAhead(0) == '[' && lex->lookAhead(1) == ']' ){
nextToken();
nextToken();
return true;
}
}
return false;
}
bool Parser::parseCvQualify( GroupAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseCvQualify()" << endl;
int start = lex->index();
GroupAST::Node ast = CreateNode<GroupAST>();
int n = 0;
while( !lex->lookAhead(0).isNull() ){
int tk = lex->lookAhead( 0 );
if( tk == Token_const || tk == Token_volatile ){
++n;
int startWord = lex->index();
nextToken();
AST::Node word = CreateNode<AST>();
UPDATE_POS( word, startWord, lex->index() );
ast->addNode( word );
} else
break;
}
if( n == 0 )
return false;
////kdDebug(9007)<< "-----------------> token = " << lex->lookAhead(0).text() << endl;
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseSimpleTypeSpecifier( TypeSpecifierAST::Node& node )
{
int start = lex->index();
bool isIntegral = false;
bool done = false;
while( !done ){
switch( lex->lookAhead(0) ){
case Token_char:
case Token_wchar_t:
case Token_bool:
case Token_short:
case Token_int:
case Token_long:
case Token_signed:
case Token_unsigned:
case Token_float:
case Token_double:
case Token_void:
isIntegral = true;
nextToken();
break;
default:
done = true;
}
}
TypeSpecifierAST::Node ast = CreateNode<TypeSpecifierAST>();
if( isIntegral ){
ClassOrNamespaceNameAST::Node cl = CreateNode<ClassOrNamespaceNameAST>();
AST::Node n = CreateNode<AST>();
UPDATE_POS( n, start, lex->index() );
cl->setName( n );
UPDATE_POS( cl, start, lex->index() );
NameAST::Node name = CreateNode<NameAST>();
name->setUnqualifiedName( cl );
UPDATE_POS( name, start, lex->index() );
ast->setName( name );
} else {
NameAST::Node name;
if( !parseName(name) ){
lex->setIndex( start );
return false;
}
ast->setName( name );
}
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parsePtrOperator( AST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parsePtrOperator()" << endl;
int start = lex->index();
if( lex->lookAhead(0) == '&' ){
nextToken();
} else if( lex->lookAhead(0) == '*' ){
nextToken();
} else {
int index = lex->index();
AST::Node memPtr;
if( !parsePtrToMember(memPtr) ){
lex->setIndex( index );
return false;
}
}
GroupAST::Node cv;
parseCvQualify( cv );
AST::Node ast = CreateNode<AST>();
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseTemplateArgument( AST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseTemplateArgument()" << endl;
int start = lex->index();
if( parseTypeId(node) ){
if( lex->lookAhead(0) == ',' || lex->lookAhead(0) == '>' )
return true;
}
lex->setIndex( start );
if( !parseLogicalOrExpression(node, true) ){
return false;
}
return true;
}
bool Parser::parseTypeSpecifier( TypeSpecifierAST::Node& spec )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseTypeSpecifier()" << endl;
GroupAST::Node cv;
parseCvQualify( cv );
if( parseElaboratedTypeSpecifier(spec) || parseSimpleTypeSpecifier(spec) ){
spec->setCvQualify( cv );
GroupAST::Node cv2;
parseCvQualify( cv2 );
spec->setCv2Qualify( cv2 );
return true;
}
return false;
}
bool Parser::parseDeclarator( DeclaratorAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseDeclarator()" << endl;
int start = lex->index();
DeclaratorAST::Node ast = CreateNode<DeclaratorAST>();
DeclaratorAST::Node decl;
NameAST::Node declId;
AST::Node ptrOp;
while( parsePtrOperator(ptrOp) ){
ast->addPtrOp( ptrOp );
}
if( lex->lookAhead(0) == '(' ){
nextToken();
if( !parseDeclarator(decl) ){
return false;
}
ast->setSubDeclarator( decl );
if( lex->lookAhead(0) != ')'){
return false;
}
nextToken();
} else {
if( lex->lookAhead(0) == ':' ){
// unnamed bitfield
} else if( parseDeclaratorId(declId) ){
ast->setDeclaratorId( declId );
} else {
lex->setIndex( start );
return false;
}
if( lex->lookAhead(0) == ':' ){
nextToken();
AST::Node expr;
if( !parseConstantExpression(expr) ){
reportError( i18n("Constant expression expected") );
}
goto update_pos;
}
}
{
bool isVector = true;
while( lex->lookAhead(0) == '[' ){
int startArray = lex->index();
nextToken();
AST::Node expr;
parseCommaExpression( expr );
ADVANCE( ']', "]" );
AST::Node array = CreateNode<AST>();
UPDATE_POS( array, startArray, lex->index() );
ast->addArrayDimension( array );
isVector = true;
}
bool skipParen = false;
if( lex->lookAhead(0) == Token_identifier && lex->lookAhead(1) == '(' && lex->lookAhead(2) == '(' ){
nextToken();
nextToken();
skipParen = true;
}
if( ast->subDeclarator() && (!isVector || lex->lookAhead(0) != '(') ){
lex->setIndex( start );
return false;
}
int index = lex->index();
if( lex->lookAhead(0) == '(' ){
nextToken();
ParameterDeclarationClauseAST::Node params;
if( !parseParameterDeclarationClause(params) ){
////kdDebug(9007)<< "----------------------> not a parameter declaration, maybe an initializer!?" << endl;
lex->setIndex( index );
goto update_pos;
}
ast->setParameterDeclarationClause( params );
if( lex->lookAhead(0) != ')' ){
lex->setIndex( index );
goto update_pos;
}
nextToken(); // skip ')'
int startConstant = lex->index();
if( lex->lookAhead(0) == Token_const ){
nextToken();
AST::Node constant = CreateNode<AST>();
UPDATE_POS( constant, startConstant, lex->index() );
ast->setConstant( constant );
}
GroupAST::Node except;
if( parseExceptionSpecification(except) ){
ast->setExceptionSpecification( except );
}
}
if( skipParen ){
if( lex->lookAhead(0) != ')' ){
reportError( i18n("')' expected") );
} else
nextToken();
}
}
update_pos:
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseAbstractDeclarator( DeclaratorAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseDeclarator()" << endl;
int start = lex->index();
DeclaratorAST::Node ast = CreateNode<DeclaratorAST>();
DeclaratorAST::Node decl;
NameAST::Node declId;
AST::Node ptrOp;
while( parsePtrOperator(ptrOp) ){
ast->addPtrOp( ptrOp );
}
if( lex->lookAhead(0) == '(' ){
nextToken();
if( !parseAbstractDeclarator(decl) ){
return false;
}
ast->setSubDeclarator( decl );
if( lex->lookAhead(0) != ')'){
return false;
}
nextToken();
}
{
while( lex->lookAhead(0) == '[' ){
int startArray = lex->index();
nextToken();
AST::Node expr;
skipCommaExpression( expr );
ADVANCE( ']', "]" );
AST::Node array = CreateNode<AST>();
UPDATE_POS( array, startArray, lex->index() );
ast->addArrayDimension( array );
}
bool skipParen = false;
if( lex->lookAhead(0) == Token_identifier && lex->lookAhead(1) == '(' && lex->lookAhead(2) == '(' ){
nextToken();
nextToken();
skipParen = true;
}
int index = lex->index();
if( lex->lookAhead(0) == '(' ){
nextToken();
ParameterDeclarationClauseAST::Node params;
if( !parseParameterDeclarationClause(params) ){
lex->setIndex( index );
goto UPDATE_POS;
}
ast->setParameterDeclarationClause( params );
if( lex->lookAhead(0) != ')' ){
lex->setIndex( index );
goto UPDATE_POS;
} else
nextToken();
int startConstant = lex->index();
if( lex->lookAhead(0) == Token_const ){
nextToken();
AST::Node constant = CreateNode<AST>();
UPDATE_POS( constant, startConstant, lex->index() );
ast->setConstant( constant );
}
GroupAST::Node except;
if( parseExceptionSpecification(except) ){
ast->setExceptionSpecification( except );
}
}
if( skipParen ){
if( lex->lookAhead(0) != ')' ){
reportError( i18n("')' expected") );
} else
nextToken();
}
}
UPDATE_POS:
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseEnumSpecifier( TypeSpecifierAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseEnumSpecifier()" << endl;
int start = lex->index();
if( lex->lookAhead(0) != Token_enum ){
return false;
}
nextToken();
Comment c = comment();
clearComment();
NameAST::Node name;
parseName( name );
if( lex->lookAhead(0) != '{' ){
lex->setIndex( start );
return false;
}
nextToken();
EnumSpecifierAST::Node ast = CreateNode<EnumSpecifierAST>();
ast->setName( name );
ast->setComment( c );
EnumeratorAST::Node enumerator;
if( parseEnumerator(enumerator) ){
ast->addEnumerator( enumerator );
while( lex->lookAhead(0) == ',' ){
nextToken();
if( !parseEnumerator(enumerator) ){
//reportError( i18n("Enumerator expected") );
break;
}
ast->addEnumerator( enumerator );
}
}
clearComment( );
if( lex->lookAhead(0) != '}' )
reportError( i18n("} missing") );
else
nextToken();
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseTemplateParameterList( TemplateParameterListAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseTemplateParameterList()" << endl;
int start = lex->index();
TemplateParameterListAST::Node ast = CreateNode<TemplateParameterListAST>();
TemplateParameterAST::Node param;
if( !parseTemplateParameter(param) ){
return false;
}
ast->addTemplateParameter( param );
while( lex->lookAhead(0) == ',' ){
nextToken();
if( !parseTemplateParameter(param) ){
syntaxError();
break;
} else {
ast->addTemplateParameter( param );
}
}
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseTemplateParameter( TemplateParameterAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseTemplateParameter()" << endl;
int start = lex->index();
TemplateParameterAST::Node ast = CreateNode<TemplateParameterAST>();
TypeParameterAST::Node typeParameter;
ParameterDeclarationAST::Node param;
int tk = lex->lookAhead( 0 );
if( (tk == Token_class || tk == Token_typename || tk == Token_template) && parseTypeParameter(typeParameter) ){
ast->setTypeParameter( typeParameter );
goto ok;
}
if( !parseParameterDeclaration(param) )
return false;
ast->setTypeValueParameter( param );
ok:
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseTypeParameter( TypeParameterAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseTypeParameter()" << endl;
int start = lex->index();
TypeParameterAST::Node ast = CreateNode<TypeParameterAST>();
AST_FROM_TOKEN( kind, lex->index() );
ast->setKind( kind );
switch( lex->lookAhead(0) ){
case Token_class:
case Token_typename:
{
nextToken(); // skip class
// parse optional name
NameAST::Node name;
if( parseName(name) ){
ast->setName( name );
if( lex->lookAhead(0) == '=' ){
nextToken();
AST::Node typeId;
if( !parseTypeId(typeId) ){
syntaxError();
return false;
}
ast->setTypeId( typeId );
}
}
}
break;
case Token_template:
{
nextToken(); // skip template
ADVANCE( '<', '<' );
TemplateParameterListAST::Node params;
if( !parseTemplateParameterList(params) ){
return false;
}
ast->setTemplateParameterList( params );
ADVANCE( '>', ">" );
if( lex->lookAhead(0) == Token_class )
nextToken();
// parse optional name
NameAST::Node name;
if( parseName(name) ){
ast->setName( name );
if( lex->lookAhead(0) == '=' ){
nextToken();
AST::Node typeId;
if( !parseTypeId(typeId) ){
syntaxError();
return false;
}
ast->setTypeId( typeId );
}
}
if( lex->lookAhead(0) == '=' ){
nextToken();
NameAST::Node templ_name;
parseName( templ_name );
}
}
break;
default:
return false;
} // end switch
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseStorageClassSpecifier( GroupAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseStorageClassSpecifier()" << endl;
int start = lex->index();
GroupAST::Node ast = CreateNode<GroupAST>();
while( !lex->lookAhead(0).isNull() ){
int tk = lex->lookAhead( 0 );
if( tk == Token_friend || tk == Token_auto || tk == Token_register || tk == Token_static ||
tk == Token_extern || tk == Token_mutable ){
int startNode = lex->index();
nextToken();
AST::Node n = CreateNode<AST>();
UPDATE_POS( n, startNode, lex->index() );
ast->addNode( n );
} else
break;
}
if( ast->nodeList().count() == 0 )
return false;
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseFunctionSpecifier( GroupAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseFunctionSpecifier()" << endl;
int start = lex->index();
GroupAST::Node ast = CreateNode<GroupAST>();
while( !lex->lookAhead(0).isNull() ){
int tk = lex->lookAhead( 0 );
if( tk == Token_inline || tk == Token_virtual || tk == Token_explicit ){
int startNode = lex->index();
nextToken();
AST::Node n = CreateNode<AST>();
UPDATE_POS( n, startNode, lex->index() );
ast->addNode( n );
} else {
break;
}
}
if( ast->nodeList().count() == 0 )
return false;
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseTypeId( AST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseTypeId()" << endl;
/// @todo implement the AST for typeId
int start = lex->index();
AST::Node ast = CreateNode<AST>();
TypeSpecifierAST::Node spec;
if( !parseTypeSpecifier(spec) ){
return false;
}
DeclaratorAST::Node decl;
parseAbstractDeclarator( decl );
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseInitDeclaratorList( InitDeclaratorListAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseInitDeclaratorList()" << endl;
int start = lex->index();
InitDeclaratorListAST::Node ast = CreateNode<InitDeclaratorListAST>();
InitDeclaratorAST::Node decl;
if( !parseInitDeclarator(decl) ){
return false;
}
ast->addInitDeclarator( decl );
while( lex->lookAhead(0) == ',' ){
nextToken();
if( !parseInitDeclarator(decl) ){
syntaxError();
break;
}
ast->addInitDeclarator( decl );
}
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseInitDeclaratorList() -- end" << endl;
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseParameterDeclarationClause( ParameterDeclarationClauseAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseParameterDeclarationClause()" << endl;
int start = lex->index();
ParameterDeclarationClauseAST::Node ast = CreateNode<ParameterDeclarationClauseAST>();
ParameterDeclarationListAST::Node params;
if( !parseParameterDeclarationList(params) ){
if ( lex->lookAhead(0) == ')' )
goto good;
if( lex->lookAhead(0) == Token_ellipsis && lex->lookAhead(1) == ')' ){
AST_FROM_TOKEN( ellipsis, lex->index() );
ast->setEllipsis( ellipsis );
nextToken();
goto good;
}
return false;
}
if( lex->lookAhead(0) == Token_ellipsis ){
AST_FROM_TOKEN( ellipsis, lex->index() );
ast->setEllipsis( ellipsis );
nextToken();
}
good:
ast->setParameterDeclarationList( params );
/// @todo add ellipsis
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
void Parser::nextToken( bool skipComm ) {
lex->nextToken();
if( skipComm ) {
if( lex->lookAhead(0) == Token_comment ) {
processComment();
nextToken();
}
}
}
Comment Parser::comment() {
return m_commentStore.latestComment();
}
void Parser::preparseLineComments( int l ) {
for( int a = 0; a < 40; a++ ) {
if( lex->lookAhead(a).isNull() ) break;
int line, col;
lex->lookAhead( a ).getStartPosition( &line, &col );
if( line < l ) {
continue;
} else if( line == l ) {
if( lex->lookAhead( a ) == Token_comment ) {
processComment( a );
}
} else {
break;
}
}
}
void Parser::processComment( int offset ) {
int line, col;
lex->lookAhead( offset ).getStartPosition( &line, &col );
m_commentStore.addComment( Comment( lex->lookAhead(offset).text(), line ) );
}
template<class Type>
void Parser::eventuallyTakeComment( int startLn, int endLn, Type& ast ) {
if( comment().line() >= startLn && comment().line() <= endLn ) {
if( &(*ast) ) {
if( comment() ) {
ast->setComment( comment() );
}
}
clearComment();
}
}
template<class Type>
void Parser::eventuallyTakeComment( Type& ast ) {
if( &(*ast) && comment() ) {
ast->setComment( comment() );
}
clearComment();
}
void Parser::clearComment( ) {
m_commentStore.clear();
}
int Parser::currentLine() {
int ln, col;
lex->lookAhead( 0 ).getStartPosition( &ln, &col );
return ln;
}
bool Parser::parseParameterDeclarationList( ParameterDeclarationListAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseParameterDeclarationList()" << endl;
int start = lex->index();
ParameterDeclarationListAST::Node ast = CreateNode<ParameterDeclarationListAST>();
ParameterDeclarationAST::Node param;
if( !parseParameterDeclaration(param) ){
lex->setIndex( start );
return false;
}
ast->addParameter( param );
while( lex->lookAhead(0) == ',' ){
nextToken();
if( lex->lookAhead(0) == Token_ellipsis )
break;
if( !parseParameterDeclaration(param) ){
lex->setIndex( start );
return false;
}
ast->addParameter( param );
}
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseParameterDeclaration( ParameterDeclarationAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseParameterDeclaration()" << endl;
int start = lex->index();
// parse decl spec
TypeSpecifierAST::Node spec;
if( !parseTypeSpecifier(spec) ){
lex->setIndex( start );
return false;
}
int index = lex->index();
DeclaratorAST::Node decl;
if( !parseDeclarator(decl) ){
lex->setIndex( index );
// try with abstract declarator
if( !parseAbstractDeclarator(decl) )
return false;
}
AST::Node expr;
if( lex->lookAhead(0) == '=' ){
nextToken();
if( !parseLogicalOrExpression(expr,true) ){
//reportError( i18n("Expression expected") );
}
}
ParameterDeclarationAST::Node ast = CreateNode<ParameterDeclarationAST>();
ast->setTypeSpec( spec );
ast->setDeclarator( decl );
ast->setExpression( expr );
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseClassSpecifier( TypeSpecifierAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseClassSpecifier()" << endl;
int start = lex->index();
AST::Node classKey;
int classKeyStart = lex->index();
int kind = lex->lookAhead( 0 );
if( kind == Token_class || kind == Token_struct || kind == Token_union ){
AST::Node asn = CreateNode<AST>();
classKey = std::move(asn);
nextToken();
UPDATE_POS( classKey, classKeyStart, lex->index() );
} else {
return false;
}
GroupAST::Node winDeclSpec;
parseWinDeclSpec( winDeclSpec );
while( lex->lookAhead(0) == Token_identifier && lex->lookAhead(1) == Token_identifier )
nextToken();
NameAST::Node name;
parseName( name );
BaseClauseAST::Node bases;
if( lex->lookAhead(0) == ':' ){
if( !parseBaseClause(bases) ){
skipUntil( '{' );
}
}
if( lex->lookAhead(0) != '{' ){
lex->setIndex( start );
return false;
}
ClassSpecifierAST::Node ast = CreateNode<ClassSpecifierAST>();
eventuallyTakeComment( ast );
ADVANCE( '{', '{' );
ast->setWinDeclSpec( winDeclSpec );
ast->setClassKey( classKey );
ast->setName( name );
ast->setBaseClause( bases );
while( !lex->lookAhead(0).isNull() ){
if( lex->lookAhead(0) == '}' )
break;
DeclarationAST::Node memSpec;
int startDecl = lex->index();
if( !parseMemberSpecification(memSpec) ){
if( startDecl == lex->index() )
nextToken(); // skip at least one token
skipUntilDeclaration();
} else
ast->addDeclaration( memSpec );
}
clearComment();
if( lex->lookAhead(0) != '}' ){
reportError( i18n("} missing") );
} else
nextToken();
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseAccessSpecifier( AST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseAccessSpecifier()" << endl;
int start = lex->index();
switch( lex->lookAhead(0) ){
case Token_public:
case Token_protected:
case Token_private: {
AST::Node asn = CreateNode<AST>();
node = std::move(asn);
nextToken();
UPDATE_POS( node, start, lex->index() );
return true;
}
}
return false;
}
bool Parser::parseMemberSpecification( DeclarationAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseMemberSpecification()" << endl;
int start = lex->index();
AST::Node access;
if( lex->lookAhead(0) == ';' ){
nextToken();
return true;
} else if( lex->lookAhead(0) == Token_TQ_OBJECT || lex->lookAhead(0) == Token_ || lex->lookAhead(0) == Token_K_DCOP ){
nextToken();
return true;
} else if( lex->lookAhead(0) == Token_signals || lex->lookAhead(0) == Token_k_dcop || lex->lookAhead(0) == Token_k_dcop_signals ){
AccessDeclarationAST::Node ast = CreateNode<AccessDeclarationAST>();
nextToken();
AST::Node n = CreateNode<AST>();
UPDATE_POS( n, start, lex->index() );
ast->addAccess( n );
ADVANCE( ':', ":" );
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
} else if( parseTypedef(node) ){
return true;
} else if( parseUsing(node) ){
return true;
} else if( parseTemplateDeclaration(node) ){
return true;
} else if( parseAccessSpecifier(access) ){
AccessDeclarationAST::Node ast = CreateNode<AccessDeclarationAST>();
ast->addAccess( access );
int startSlot = lex->index();
if( lex->lookAhead(0) == Token_slots ){
nextToken();
AST::Node sl = CreateNode<AST>();
UPDATE_POS( sl, startSlot, lex->index() );
ast->addAccess( sl );
}
ADVANCE( ':', ":" );
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
lex->setIndex( start );
GroupAST::Node storageSpec;
parseStorageClassSpecifier( storageSpec );
GroupAST::Node cv;
parseCvQualify( cv );
TypeSpecifierAST::Node spec;
if( parseEnumSpecifier(spec) || parseClassSpecifier(spec) ){
spec->setCvQualify( cv );
GroupAST::Node cv2;
parseCvQualify( cv2 );
spec->setCv2Qualify( cv2 );
InitDeclaratorListAST::Node declarators;
parseInitDeclaratorList( declarators );
ADVANCE( ';', ";" );
SimpleDeclarationAST::Node ast = CreateNode<SimpleDeclarationAST>();
ast->setTypeSpec( spec );
ast->setInitDeclaratorList( declarators );
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
lex->setIndex( start );
return parseDeclarationInternal( node );
}
bool Parser::parseCtorInitializer( AST::Node& /*node*/ )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseCtorInitializer()" << endl;
if( lex->lookAhead(0) != ':' ){
return false;
}
nextToken();
AST::Node inits;
if( !parseMemInitializerList(inits) ){
reportError( i18n("Member initializers expected") );
}
return true;
}
bool Parser::parseElaboratedTypeSpecifier( TypeSpecifierAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseElaboratedTypeSpecifier()" << endl;
int start = lex->index();
int tk = lex->lookAhead( 0 );
if( tk == Token_class ||
tk == Token_struct ||
tk == Token_union ||
tk == Token_enum ||
tk == Token_typename )
{
AST::Node kind = CreateNode<AST>();
nextToken();
UPDATE_POS( kind, start, lex->index() );
NameAST::Node name;
if( parseName(name) ){
ElaboratedTypeSpecifierAST::Node ast = CreateNode<ElaboratedTypeSpecifierAST>();
ast->setKind( kind );
ast->setName( name );
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
}
lex->setIndex( start );
return false;
}
bool Parser::parseDeclaratorId( NameAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseDeclaratorId()" << endl;
return parseName( node );
}
bool Parser::parseExceptionSpecification( GroupAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseExceptionSpecification()" << endl;
if( lex->lookAhead(0) != Token_throw ){
return false;
}
nextToken();
ADVANCE( '(', "(" );
if( lex->lookAhead(0) == Token_ellipsis ){
// extension found in MSVC++ 7.x headers
int start = lex->index();
GroupAST::Node ast = CreateNode<GroupAST>();
AST_FROM_TOKEN( ellipsis, lex->index() );
ast->addNode( ellipsis );
nextToken();
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
} else if( lex->lookAhead(0) == ')' ) {
node = CreateNode<GroupAST>();
} else {
parseTypeIdList( node );
}
ADVANCE( ')', ")" );
return true;
}
bool Parser::parseEnumerator( EnumeratorAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseEnumerator()" << endl;
int start = lex->index();
if( lex->lookAhead(0) != Token_identifier ){
return false;
}
nextToken();
EnumeratorAST::Node ena = CreateNode<EnumeratorAST>();
node = std::move(ena);
AST::Node id = CreateNode<AST>();
UPDATE_POS( id, start, lex->index() );
node->setId( id );
int line = currentLine();
if( lex->lookAhead(0) == '=' ){
nextToken();
AST::Node expr;
line = currentLine();
if( !parseConstantExpression(expr) ){
reportError( i18n("Constant expression expected") );
}
node->setExpr( expr );
}
UPDATE_POS( node, start, lex->index() );
preparseLineComments( line );
node->setComment( m_commentStore.getCommentInRange( line ) );
return true;
}
bool Parser::parseInitDeclarator( InitDeclaratorAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseInitDeclarator()" << endl;
int start = lex->index();
DeclaratorAST::Node decl;
AST::Node init;
if( !parseDeclarator(decl) ){
return false;
}
parseInitializer( init );
InitDeclaratorAST::Node ast = CreateNode<InitDeclaratorAST>();
ast->setDeclarator( decl );
ast->setInitializer( init );
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseBaseClause( BaseClauseAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseBaseClause()" << endl;
int start = lex->index();
if( lex->lookAhead(0) != ':' ){
return false;
}
nextToken();
BaseClauseAST::Node bca = CreateNode<BaseClauseAST>();
BaseSpecifierAST::Node baseSpec;
if( parseBaseSpecifier(baseSpec) ){
bca->addBaseSpecifier( baseSpec );
while( lex->lookAhead(0) == ',' ){
nextToken();
if( !parseBaseSpecifier(baseSpec) ){
reportError( i18n("Base class specifier expected") );
return false;
}
bca->addBaseSpecifier( baseSpec );
}
} else
return false;
UPDATE_POS( bca, start, lex->index() );
node = std::move(bca);
return true;
}
bool Parser::parseInitializer( AST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseInitializer()" << endl;
if( lex->lookAhead(0) == '=' ){
nextToken();
AST::Node init;
if( !parseInitializerClause(node) ){
reportError( i18n("Initializer clause expected") );
return false;
}
} else if( lex->lookAhead(0) == '(' ){
nextToken();
AST::Node expr;
skipCommaExpression( expr );
ADVANCE( ')', ")" );
}
return false;
}
bool Parser::parseMemInitializerList( AST::Node& /*node*/ )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseMemInitializerList()" << endl;
AST::Node init;
if( !parseMemInitializer(init) ){
return false;
}
while( lex->lookAhead(0) == ',' ){
nextToken();
if( parseMemInitializer(init) ){
} else {
break;
}
}
return true;
}
bool Parser::parseMemInitializer( AST::Node& /*node*/ )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseMemInitializer()" << endl;
NameAST::Node initId;
if( !parseMemInitializerId(initId) ){
reportError( i18n("Identifier expected") );
return false;
}
ADVANCE( '(', '(' );
AST::Node expr;
skipCommaExpression( expr );
ADVANCE( ')', ')' );
return true;
}
bool Parser::parseTypeIdList( GroupAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseTypeIdList()" << endl;
int start = lex->index();
AST::Node typeId;
if( !parseTypeId(typeId) ){
return false;
}
GroupAST::Node ast = CreateNode<GroupAST>();
ast->addNode( typeId );
while( lex->lookAhead(0) == ',' ){
nextToken();
if( parseTypeId(typeId) ){
ast->addNode( typeId );
} else {
reportError( i18n("Type id expected") );
break;
}
}
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseBaseSpecifier( BaseSpecifierAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseBaseSpecifier()" << endl;
int start = lex->index();
BaseSpecifierAST::Node ast = CreateNode<BaseSpecifierAST>();
AST::Node access;
if( lex->lookAhead(0) == Token_virtual ){
AST_FROM_TOKEN( virt, lex->index() );
ast->setIsVirtual( virt );
nextToken();
parseAccessSpecifier( access );
} else {
parseAccessSpecifier( access );
if( lex->lookAhead(0) == Token_virtual ){
AST_FROM_TOKEN( virt, lex->index() );
ast->setIsVirtual( virt );
nextToken();
}
}
NameAST::Node name;
if( !parseName(name) ){
reportError( i18n("Class name expected") );
}
ast->setAccess( access );
ast->setName( name );
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseInitializerClause( AST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseInitializerClause()" << endl;
if( lex->lookAhead(0) == '{' ){
if( !skip('{','}') ){
reportError( i18n("} missing") );
} else {
clearComment();
nextToken();
}
} else {
if( !parseAssignmentExpression(node) ){
//reportError( i18n("Expression expected") );
}
}
return true;
}
bool Parser::parseMemInitializerId( NameAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseMemInitializerId()" << endl;
return parseName( node );
}
bool Parser::parsePtrToMember( AST::Node& /*node*/ )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parsePtrToMember()" << endl;
if( lex->lookAhead(0) == Token_scope ){
nextToken();
}
while( lex->lookAhead(0) == Token_identifier ){
nextToken();
if( lex->lookAhead(0) == Token_scope && lex->lookAhead(1) == '*' ){
nextToken(); // skip ::
nextToken(); // skip *
return true;
} else
break;
}
return false;
}
bool Parser::parseUnqualifiedName( ClassOrNamespaceNameAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseUnqualifiedName()" << endl;
int start = lex->index();
bool isDestructor = false;
ClassOrNamespaceNameAST::Node ast = CreateNode<ClassOrNamespaceNameAST>();
if( lex->lookAhead(0) == Token_identifier ){
int startName = lex->index();
AST::Node n = CreateNode<AST>();
nextToken();
UPDATE_POS( n, startName, lex->index() );
ast->setName( n );
} else if( lex->lookAhead(0) == '~' && lex->lookAhead(1) == Token_identifier ){
int startName = lex->index();
AST::Node n = CreateNode<AST>();
nextToken(); // skip ~
nextToken(); // skip classname
UPDATE_POS( n, startName, lex->index() );
ast->setName( n );
isDestructor = true;
} else if( lex->lookAhead(0) == Token_operator ){
AST::Node n;
if( !parseOperatorFunctionId(n) )
return false;
ast->setName( n );
} else {
return false;
}
if( !isDestructor ){
int index = lex->index();
if( lex->lookAhead(0) == '<' ){
nextToken();
// optional template arguments
TemplateArgumentListAST::Node args;
parseTemplateArgumentList( args );
if( lex->lookAhead(0) != '>' ){
lex->setIndex( index );
} else {
nextToken();
ast->setTemplateArgumentList( args );
}
}
}
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseStringLiteral( AST::Node& /*node*/ )
{
while( !lex->lookAhead(0).isNull() ) {
if( lex->lookAhead(0) == Token_identifier &&
lex->lookAhead(0).text() == "L" && lex->lookAhead(1) == Token_string_literal ) {
nextToken();
nextToken();
} else if( lex->lookAhead(0) == Token_string_literal ) {
nextToken();
} else
return false;
}
return true;
}
bool Parser::skipExpressionStatement( StatementAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::skipExpressionStatement()" << endl;
int start = lex->index();
AST::Node expr;
skipCommaExpression( expr );
ADVANCE( ';', ";" );
ExpressionStatementAST::Node ast = CreateNode<ExpressionStatementAST>();
ast->setExpression( expr );
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseStatement( StatementAST::Node& node ) // thanks to fiore@8080.it ;)
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseStatement()" << endl;
switch( lex->lookAhead(0) ){
case Token_while:
return parseWhileStatement( node );
case Token_do:
return parseDoStatement( node );
case Token_for:
return parseForStatement( node );
case Token_foreach:
return parseForEachStatement( node );
case Token_if:
return parseIfStatement( node );
case Token_switch:
return parseSwitchStatement( node );
case Token_try:
return parseTryBlockStatement( node );
case Token_case:
case Token_default:
return parseLabeledStatement( node );
case Token_break:
case Token_continue:
nextToken();
ADVANCE( ';', ";" );
return true;
case Token_goto:
nextToken();
ADVANCE( Token_identifier, "identifier" );
ADVANCE( ';', ";" );
return true;
case Token_return:
{
nextToken();
AST::Node expr;
skipCommaExpression( expr );
ADVANCE( ';', ";" );
}
return true;
case '{':
return parseCompoundStatement( node );
case Token_identifier:
if( parseLabeledStatement(node) )
return true;
break;
}
////kdDebug(9007)<< "------------> try with declaration statement" << endl;
if ( parseDeclarationStatement(node) )
return true;
return skipExpressionStatement( node );
}
bool Parser::parseCondition( ConditionAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseCondition()" << endl;
int start = lex->index();
ConditionAST::Node ast = CreateNode<ConditionAST>();
TypeSpecifierAST::Node spec;
if( parseTypeSpecifier(spec) ){
DeclaratorAST::Node decl;
if( parseDeclarator(decl) ) {
if( lex->lookAhead(0) == '=' ) {
nextToken();
AST::Node expr;
if( skipExpression(expr) ){
ast->setTypeSpec( spec );
ast->setDeclarator( decl );
ast->setExpression( expr );
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
} else {
ast->setTypeSpec( spec );
ast->setDeclarator( decl );
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
}
}
lex->setIndex( start );
AST::Node expr;
if( !skipCommaExpression(expr) )
return false;
ast->setExpression( expr );
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseWhileStatement( StatementAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseWhileStatement()" << endl;
int start = lex->index();
ADVANCE( Token_while, "while" );
ADVANCE( '(' , "(" );
ConditionAST::Node cond;
if( !parseCondition(cond) ){
reportError( i18n("condition expected") );
return false;
}
ADVANCE( ')', ")" );
StatementAST::Node body;
if( !parseStatement(body) ){
reportError( i18n("statement expected") );
}
WhileStatementAST::Node ast = CreateNode<WhileStatementAST>();
ast->setCondition( cond );
ast->setStatement( body );
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseDoStatement( StatementAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseDoStatement()" << endl;
int start = lex->index();
ADVANCE( Token_do, "do" );
StatementAST::Node body;
if( !parseStatement(body) ){
reportError( i18n("statement expected") );
//return false;
}
ADVANCE_NR( Token_while, "while" );
ADVANCE_NR( '(' , "(" );
AST::Node expr;
if( !skipCommaExpression(expr) ){
reportError( i18n("expression expected") );
//return false;
}
ADVANCE_NR( ')', ")" );
ADVANCE_NR( ';', ";" );
DoStatementAST::Node ast = CreateNode<DoStatementAST>();
ast->setStatement( body );
//ast->setCondition( condition );
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseForStatement( StatementAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseForStatement()" << endl;
int start = lex->index();
ADVANCE( Token_for, "for" );
ADVANCE( '(', "(" );
StatementAST::Node init;
if( !parseForInitStatement(init) ){
reportError( i18n("for initialization expected") );
return false;
}
ConditionAST::Node cond;
parseCondition( cond );
ADVANCE( ';', ";" );
AST::Node expr;
skipCommaExpression( expr );
ADVANCE( ')', ")" );
StatementAST::Node body;
parseStatement(body);
ForStatementAST::Node ast = CreateNode<ForStatementAST>();
ast->setInitStatement( init );
ast->setCondition( cond );
// ast->setExpression( expression );
ast->setStatement( body );
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
///@todo add the right parsing for the foreach statement
bool Parser::parseForEachStatement( StatementAST::Node& node )
{
int start = lex->index();
ADVANCE( Token_foreach, "foreach" );
ADVANCE( '(', "(" );
AST::Node expr;
// replace with the right parsing
skipCommaExpression( expr );
ADVANCE( ')', ")" );
StatementAST::Node body;
parseStatement(body);
ForEachStatementAST::Node ast = CreateNode<ForEachStatementAST>();
// add here the parser results
ast->setStatement( body );
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseForInitStatement( StatementAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseForInitStatement()" << endl;
if ( parseDeclarationStatement(node) )
return true;
return skipExpressionStatement( node );
}
bool Parser::parseCompoundStatement( StatementAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseCompoundStatement()" << endl;
int start = lex->index();
if( lex->lookAhead(0) != '{' ){
return false;
}
nextToken();
StatementListAST::Node ast = CreateNode<StatementListAST>();
while( !lex->lookAhead(0).isNull() ){
if( lex->lookAhead(0) == '}' )
break;
StatementAST::Node stmt;
int startStmt = lex->index();
if( !parseStatement(stmt) ){
if( startStmt == lex->index() )
nextToken();
skipUntilStatement();
} else {
ast->addStatement( stmt );
}
}
clearComment();
if( lex->lookAhead(0) != '}' ){
reportError( i18n("} expected") );
} else {
nextToken();
}
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseIfStatement( StatementAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseIfStatement()" << endl;
int start = lex->index();
ADVANCE( Token_if, "if" );
ADVANCE( '(' , "(" );
IfStatementAST::Node ast = CreateNode<IfStatementAST>();
ConditionAST::Node cond;
if( !parseCondition(cond) ){
reportError( i18n("condition expected") );
return false;
}
ADVANCE( ')', ")" );
StatementAST::Node stmt;
if( !parseStatement(stmt) ){
reportError( i18n("statement expected") );
}
ast->setCondition( cond );
ast->setStatement( stmt );
if( lex->lookAhead(0) == Token_else ){
nextToken();
StatementAST::Node elseStmt;
if( !parseStatement(elseStmt) ) {
reportError( i18n("statement expected") );
}
ast->setElseStatement( elseStmt );
}
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseSwitchStatement( StatementAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseSwitchStatement()" << endl;
int start = lex->index();
ADVANCE( Token_switch, "switch" );
ADVANCE( '(' , "(" );
ConditionAST::Node cond;
if( !parseCondition(cond) ){
reportError( i18n("condition expected") );
return false;
}
ADVANCE( ')', ")" );
StatementAST::Node stmt;
if( !parseCompoundStatement(stmt) ){
syntaxError();
return false;
}
SwitchStatementAST::Node ast = CreateNode<SwitchStatementAST>();
ast->setCondition( cond );
ast->setStatement( stmt );
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseLabeledStatement( StatementAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseLabeledStatement()" << endl;
switch( lex->lookAhead(0) ){
case Token_identifier:
case Token_default:
if( lex->lookAhead(1) == ':' ){
nextToken();
nextToken();
StatementAST::Node stmt;
if( parseStatement(stmt) ){
node = std::move(stmt);
return true;
}
}
break;
case Token_case:
{
nextToken();
AST::Node expr;
if( !parseConstantExpression(expr) ){
reportError( i18n("expression expected") );
} else if( lex->lookAhead(0) == Token_ellipsis ){
nextToken();
AST::Node expr2;
if( !parseConstantExpression(expr2) ){
reportError( i18n("expression expected") );
}
}
ADVANCE( ':', ":" );
StatementAST::Node stmt;
if( parseStatement(stmt) ){
node = std::move(stmt);
return true;
}
}
break;
}
return false;
}
bool Parser::parseBlockDeclaration( DeclarationAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseBlockDeclaration()" << endl;
switch( lex->lookAhead(0) ) {
case Token_typedef:
return parseTypedef( node );
case Token_using:
return parseUsing( node );
case Token_asm:
return parseAsmDefinition( node );
case Token_namespace:
return parseNamespaceAliasDefinition( node );
}
int start = lex->index();
GroupAST::Node storageSpec;
parseStorageClassSpecifier( storageSpec );
GroupAST::Node cv;
parseCvQualify( cv );
TypeSpecifierAST::Node spec;
if ( !parseTypeSpecifierOrClassSpec(spec) ) { // replace with simpleTypeSpecifier?!?!
lex->setIndex( start );
return false;
}
spec->setCvQualify( cv );
GroupAST::Node cv2;
parseCvQualify( cv2 );
spec->setCv2Qualify( cv2 );
InitDeclaratorListAST::Node declarators;
parseInitDeclaratorList( declarators );
if( lex->lookAhead(0) != ';' ){
lex->setIndex( start );
return false;
}
nextToken();
SimpleDeclarationAST::Node ast = CreateNode<SimpleDeclarationAST>();
ast->setTypeSpec( spec );
ast->setInitDeclaratorList( declarators );
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseNamespaceAliasDefinition( DeclarationAST::Node& /*node*/ )
{
if ( lex->lookAhead(0) != Token_namespace ) {
return false;
}
nextToken();
ADVANCE( Token_identifier, "identifier" );
ADVANCE( '=', "=" );
NameAST::Node name;
if( !parseName(name) ){
reportError( i18n("Namespace name expected") );
}
ADVANCE( ';', ";" );
return true;
}
bool Parser::parseDeclarationStatement( StatementAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseDeclarationStatement()" << endl;
int start = lex->index();
DeclarationAST::Node decl;
if ( !parseBlockDeclaration(decl) ){
return false;
}
DeclarationStatementAST::Node ast = CreateNode<DeclarationStatementAST>();
ast->setDeclaration( decl );
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
////kdDebug(9007)<< "---------------------> found a block declaration" << endl;
return true;
}
bool Parser::parseDeclarationInternal( DeclarationAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseDeclarationInternal()" << endl;
int start = lex->index();
// that is for the case '__declspec(dllexport) int ...' or
// '__declspec(dllexport) inline int ...', etc.
GroupAST::Node winDeclSpec;
parseWinDeclSpec( winDeclSpec );
GroupAST::Node funSpec;
bool hasFunSpec = parseFunctionSpecifier( funSpec );
GroupAST::Node storageSpec;
bool hasStorageSpec = parseStorageClassSpecifier( storageSpec );
if( hasStorageSpec && !hasFunSpec )
hasFunSpec = parseFunctionSpecifier( funSpec );
// that is for the case 'friend __declspec(dllexport) ....'
GroupAST::Node winDeclSpec2;
parseWinDeclSpec( winDeclSpec2 );
GroupAST::Node cv;
parseCvQualify( cv );
int index = lex->index();
NameAST::Node name;
if( parseName(name) && lex->lookAhead(0) == '(' ){
// no type specifier, maybe a constructor or a cast operator??
lex->setIndex( index );
InitDeclaratorAST::Node declarator;
if( parseInitDeclarator(declarator) ){
int endSignature = lex->index();
switch( lex->lookAhead(0) ){
case ';':
{
nextToken();
InitDeclaratorListAST::Node declarators = CreateNode<InitDeclaratorListAST>();
// update declarators position
int startLine, startColumn, endLine, endColumn;
if( declarator.get() ){
declarator->getStartPosition( &startLine, &startColumn );
declarator->getEndPosition( &endLine, &endColumn );
declarators->setStartPosition( startLine, startColumn );
declarators->setEndPosition( endLine, endColumn );
}
declarators->addInitDeclarator( declarator );
SimpleDeclarationAST::Node ast = CreateNode<SimpleDeclarationAST>();
ast->setInitDeclaratorList( declarators );
ast->setText( toString(start, endSignature) );
node = std::move(ast);
UPDATE_POS( node, start, lex->index() );
return true;
}
break;
case ':':
{
AST::Node ctorInit;
StatementListAST::Node funBody;
if( parseCtorInitializer(ctorInit) && parseFunctionBody(funBody) ){
FunctionDefinitionAST::Node ast = CreateNode<FunctionDefinitionAST>();
ast->setStorageSpecifier( storageSpec );
ast->setFunctionSpecifier( funSpec );
ast->setInitDeclarator( declarator );
ast->setFunctionBody( funBody );
ast->setText( toString(start, endSignature) );
node = std::move(ast);
UPDATE_POS( node, start, lex->index() );
return true;
}
}
break;
case '{':
{
StatementListAST::Node funBody;
if( parseFunctionBody(funBody) ){
FunctionDefinitionAST::Node ast = CreateNode<FunctionDefinitionAST>();
ast->setStorageSpecifier( storageSpec );
ast->setFunctionSpecifier( funSpec );
ast->setInitDeclarator( declarator );
ast->setText( toString(start, endSignature) );
ast->setFunctionBody( funBody );
node = std::move(ast);
UPDATE_POS( node, start, lex->index() );
return true;
}
}
break;
case '(':
case '[':
// ops!! it seems a declarator
goto start_decl;
break;
}
}
syntaxError();
return false;
}
start_decl:
lex->setIndex( index );
if( lex->lookAhead(0) == Token_const && lex->lookAhead(1) == Token_identifier && lex->lookAhead(2) == '=' ){
// constant definition
nextToken();
InitDeclaratorListAST::Node declarators;
if( parseInitDeclaratorList(declarators) ){
ADVANCE( ';', ";" );
DeclarationAST::Node ast = CreateNode<DeclarationAST>();
node = std::move(ast);
UPDATE_POS( node, start, lex->index() );
return true;
}
syntaxError();
return false;
}
Comment mcomment = comment();
clearComment();
TypeSpecifierAST::Node spec;
if( parseTypeSpecifier(spec) ){
if ( !hasFunSpec )
parseFunctionSpecifier( funSpec ); // e.g. "void inline"
spec->setCvQualify( cv );
InitDeclaratorListAST::Node declarators;
InitDeclaratorAST::Node decl;
int startDeclarator = lex->index();
bool maybeFunctionDefinition = false;
if( lex->lookAhead(0) != ';' ){
if( parseInitDeclarator(decl) && lex->lookAhead(0) == '{' ){
// function definition
maybeFunctionDefinition = true;
} else {
lex->setIndex( startDeclarator );
if( !parseInitDeclaratorList(declarators) ){
syntaxError();
return false;
}
}
}
int endSignature = lex->index();
switch( lex->lookAhead(0) ){
case ';':
{
nextToken();
SimpleDeclarationAST::Node ast = CreateNode<SimpleDeclarationAST>();
int line, col;
ast->setComment( mcomment );
if( &(*decl) ) {
decl->getEndPosition( &line, &col );
preparseLineComments( line );
Comment c = m_commentStore.getCommentInRange( line );
if( c ) {
ast->addComment( c );
}
}
ast->setStorageSpecifier( storageSpec );
ast->setFunctionSpecifier( funSpec );
ast->setText( toString(start, endSignature) );
ast->setTypeSpec( spec );
ast->setWinDeclSpec( winDeclSpec );
ast->setInitDeclaratorList( declarators );
node = std::move(ast);
UPDATE_POS( node, start, lex->index() );
}
return true;
case '{':
{
if( !maybeFunctionDefinition ){
syntaxError();
return false;
}
StatementListAST::Node funBody;
if ( parseFunctionBody(funBody) ) {
FunctionDefinitionAST::Node ast = CreateNode<FunctionDefinitionAST>();
ast->setComment( mcomment );
ast->setWinDeclSpec( winDeclSpec );
ast->setStorageSpecifier( storageSpec );
ast->setFunctionSpecifier( funSpec );
ast->setText( toString(start, endSignature) );
ast->setTypeSpec( spec );
ast->setFunctionBody( funBody );
ast->setInitDeclarator( decl );
node = std::move(ast);
UPDATE_POS( node, start, lex->index() );
return true;
}
}
break;
}
}
syntaxError();
return false;
}
bool Parser::parseFunctionBody( StatementListAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseFunctionBody()" << endl;
int start = lex->index();
if( lex->lookAhead(0) != '{' ){
return false;
}
nextToken();
StatementListAST::Node ast = CreateNode<StatementListAST>();
while( !lex->lookAhead(0).isNull() ){
if( lex->lookAhead(0) == '}' )
break;
StatementAST::Node stmt;
int startStmt = lex->index();
if( !parseStatement(stmt) ){
if( startStmt == lex->index() )
nextToken();
skipUntilStatement();
} else
ast->addStatement( stmt );
}
clearComment();
if( lex->lookAhead(0) != '}' ){
reportError( i18n("} expected") );
} else
nextToken();
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
TQString Parser::toString( int start, int end, const TQString& sep ) const
{
TQStringList l;
for( int i=start; i<end; ++i ){
const Token& t = lex->tokenAt(i);
if( t != Token_comment )
l << t.text();
}
return l.join( sep ).stripWhiteSpace();
}
bool Parser::parseTypeSpecifierOrClassSpec( TypeSpecifierAST::Node& node )
{
if( parseClassSpecifier(node) )
return true;
else if( parseEnumSpecifier(node) )
return true;
else if( parseTypeSpecifier(node) )
return true;
return false;
}
bool Parser::parseTryBlockStatement( StatementAST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseTryBlockStatement()" << endl;
int start = lex->index();
if( lex->lookAhead(0) != Token_try ){
return false;
}
nextToken();
StatementAST::Node stmt;
if( !parseCompoundStatement(stmt) ){
syntaxError();
}
if( lex->lookAhead(0) != Token_catch ){
reportError( i18n("catch expected") );
}
CatchStatementListAST::Node list = CreateNode<CatchStatementListAST>();
while( lex->lookAhead(0) == Token_catch ){
nextToken();
ADVANCE( '(', "(" );
ConditionAST::Node cond;
if( !parseCondition(cond) ){
reportError( i18n("condition expected") );
return false;
}
ADVANCE( ')', ")" );
StatementAST::Node body;
if( !parseCompoundStatement(body) ){
syntaxError();
}
CatchStatementAST::Node cstmt = CreateNode<CatchStatementAST>();
cstmt->setCondition( cond );
cstmt->setStatement( body );
int l=0, c=0;
if( cond.get() )
cond->getStartPosition( &l, &c );
else if( body.get() )
body->getStartPosition( &l, &c );
cstmt->setStartPosition( l, c );
if( body.get() )
body->getEndPosition( &l, &c );
cstmt->setEndPosition( l, c );
list->addStatement( cstmt );
}
TryBlockStatementAST::Node ast = CreateNode<TryBlockStatementAST>();
ast->setStatement( stmt );
ast->setCatchStatementList( list );
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parsePrimaryExpression( AST::Node& /*node*/ )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parsePrimarExpression()" << endl;
switch( lex->lookAhead(0) ){
case Token_string_literal:
{
AST::Node lit;
parseStringLiteral( lit );
}
return true;
case Token_number_literal:
case Token_char_literal:
case Token_true:
case Token_false:
nextToken();
return true;
case Token_this:
nextToken();
return true;
case Token_dynamic_cast:
case Token_static_cast:
case Token_reinterpret_cast:
case Token_const_cast:
{
nextToken();
CHECK( '<', "<" );
AST::Node typeId;
parseTypeId( typeId );
CHECK( '>', ">" );
CHECK( '(', "(" );
AST::Node expr;
parseCommaExpression( expr );
CHECK( ')', ")" );
}
return true;
case Token_typeid:
{
nextToken();
CHECK( '(', "(" );
AST::Node expr;
parseCommaExpression( expr );
CHECK( ')', ")" );
}
return true;
case '(':
{
nextToken();
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "token = " << lex->lookAhead(0).text() << endl;
AST::Node expr;
if( !parseExpression(expr) ){
return false;
}
CHECK( ')', ")" );
}
return true;
default:
{
int start = lex->index();
TypeSpecifierAST::Node typeSpec;
if( parseSimpleTypeSpecifier(typeSpec) && lex->lookAhead(0) == '(' ){
nextToken();
AST::Node expr;
parseCommaExpression( expr );
CHECK( ')', ")" );
return true;
}
lex->setIndex( start );
NameAST::Node name;
if( parseName(name) )
return true;
}
}
return false;
}
bool Parser::parsePostfixExpression( AST::Node& /*node*/ )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parsePostfixExpression()" << endl;
AST::Node expr;
if( !parsePrimaryExpression(expr) )
return false;
while( true ){
switch(lex->lookAhead(0))
{
case '[':
{
nextToken();
AST::Node e;
parseCommaExpression( e );
CHECK( ']', "]" );
}
break;
case '(':
{
nextToken();
AST::Node funArgs;
parseCommaExpression( funArgs );
CHECK( ')', ")" );
}
break;
case Token_incr:
case Token_decr:
nextToken();
break;
case '.':
case Token_arrow:
{
nextToken();
if( lex->lookAhead(0) == Token_template )
nextToken();
NameAST::Node name;
if( !parseName(name) ){
return false;
}
}
break;
case Token_typename:
{
nextToken();
NameAST::Node name;
if( !parseName(name) ){
return false;
}
CHECK( '(', "(" );
AST::Node expr;
parseCommaExpression(expr);
CHECK( ')', ")" );
}
return true;
default:
return true;
} // end switch
} // end while
return true;
}
bool Parser::parseUnaryExpression( AST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseUnaryExpression()" << endl;
switch( lex->lookAhead(0) ){
case Token_incr:
case Token_decr:
case '*':
case '&':
case '+':
case '-':
case '!':
case '~':
{
nextToken();
AST::Node expr;
return parseCastExpression( expr );
}
case Token_sizeof:
{
nextToken();
int index = lex->index();
if( lex->lookAhead(0) == '(' ){
nextToken();
AST::Node typeId;
if( parseTypeId(typeId) && lex->lookAhead(0) == ')' ){
nextToken();
return true;
}
lex->setIndex( index );
}
AST::Node expr;
return parseUnaryExpression( expr );
}
case Token_new:
return parseNewExpression( node );
case Token_delete:
return parseDeleteExpression( node );
}
return parsePostfixExpression( node );
}
bool Parser::parseNewExpression( AST::Node& /*node*/ )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseNewExpression()" << endl;
if( lex->lookAhead(0) == Token_scope && lex->lookAhead(1) == Token_new )
nextToken();
CHECK( Token_new, "new");
if( lex->lookAhead(0) == '(' ){
nextToken();
AST::Node expr;
parseCommaExpression( expr );
CHECK( ')', ")" );
}
if( lex->lookAhead(0) == '(' ){
nextToken();
AST::Node typeId;
parseTypeId( typeId );
CHECK( ')', ")" );
} else {
AST::Node typeId;
parseNewTypeId( typeId );
}
AST::Node init;
parseNewInitializer( init );
return true;
}
bool Parser::parseNewTypeId( AST::Node& /*node*/ )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseNewTypeId()" << endl;
TypeSpecifierAST::Node typeSpec;
if( parseTypeSpecifier(typeSpec) ){
AST::Node declarator;
parseNewDeclarator( declarator );
return true;
}
return false;
}
bool Parser::parseNewDeclarator( AST::Node& /*node*/ )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseNewDeclarator()" << endl;
AST::Node ptrOp;
if( parsePtrOperator(ptrOp) ){
AST::Node declarator;
parseNewDeclarator( declarator );
return true;
}
if( lex->lookAhead(0) == '[' ){
while( lex->lookAhead(0) == '[' ){
nextToken();
AST::Node expr;
parseExpression( expr );
ADVANCE( ']', "]" );
}
return true;
}
return false;
}
bool Parser::parseNewInitializer( AST::Node& /*node*/ )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseNewInitializer()" << endl;
if( lex->lookAhead(0) != '(' )
return false;
nextToken();
AST::Node expr;
parseCommaExpression( expr );
CHECK( ')', ")" );
return true;
}
bool Parser::parseDeleteExpression( AST::Node& /*node*/ )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseDeleteExpression()" << endl;
if( lex->lookAhead(0) == Token_scope && lex->lookAhead(1) == Token_delete )
nextToken();
CHECK( Token_delete, "delete" );
if( lex->lookAhead(0) == '[' ){
nextToken();
CHECK( ']', "]" );
}
AST::Node expr;
return parseCastExpression( expr );
}
bool Parser::parseCastExpression( AST::Node& /*node*/ )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseCastExpression()" << endl;
int index = lex->index();
if( lex->lookAhead(0) == '(' ){
nextToken();
AST::Node typeId;
if ( parseTypeId(typeId) ) {
if ( lex->lookAhead(0) == ')' ) {
nextToken();
AST::Node expr;
if( parseCastExpression(expr) )
return true;
}
}
}
lex->setIndex( index );
AST::Node expr;
return parseUnaryExpression( expr );
}
bool Parser::parsePmExpression( AST::Node& /*node*/ )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser:parsePmExpression()" << endl;
AST::Node expr;
if( !parseCastExpression(expr) )
return false;
while( lex->lookAhead(0) == Token_ptrmem ){
nextToken();
if( !parseCastExpression(expr) )
return false;
}
return true;
}
bool Parser::parseMultiplicativeExpression( AST::Node& /*node*/ )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseMultiplicativeExpression()" << endl;
AST::Node expr;
if( !parsePmExpression(expr) )
return false;
while( lex->lookAhead(0) == '*' || lex->lookAhead(0) == '/' || lex->lookAhead(0) == '%' ){
nextToken();
if( !parsePmExpression(expr) )
return false;
}
return true;
}
bool Parser::parseAdditiveExpression( AST::Node& /*node*/ )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseAdditiveExpression()" << endl;
AST::Node expr;
if( !parseMultiplicativeExpression(expr) )
return false;
while( lex->lookAhead(0) == '+' || lex->lookAhead(0) == '-' ){
nextToken();
if( !parseMultiplicativeExpression(expr) )
return false;
}
return true;
}
bool Parser::parseShiftExpression( AST::Node& /*node*/ )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseShiftExpression()" << endl;
AST::Node expr;
if( !parseAdditiveExpression(expr) )
return false;
while( lex->lookAhead(0) == Token_shift ){
nextToken();
if( !parseAdditiveExpression(expr) )
return false;
}
return true;
}
bool Parser::parseRelationalExpression( AST::Node& /*node*/, bool templArgs )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseRelationalExpression()" << endl;
AST::Node expr;
if( !parseShiftExpression(expr) )
return false;
while( lex->lookAhead(0) == '<' || (lex->lookAhead(0) == '>' && !templArgs) ||
lex->lookAhead(0) == Token_leq || lex->lookAhead(0) == Token_geq ){
nextToken();
if( !parseShiftExpression(expr) )
return false;
}
return true;
}
bool Parser::parseEqualityExpression( AST::Node& /*node*/, bool templArgs )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseEqualityExpression()" << endl;
AST::Node expr;
if( !parseRelationalExpression(expr, templArgs) )
return false;
while( lex->lookAhead(0) == Token_eq || lex->lookAhead(0) == Token_not_eq ){
nextToken();
if( !parseRelationalExpression(expr, templArgs) )
return false;
}
return true;
}
bool Parser::parseAndExpression( AST::Node& /*node*/, bool templArgs )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseAndExpression()" << endl;
AST::Node expr;
if( !parseEqualityExpression(expr, templArgs) )
return false;
while( lex->lookAhead(0) == '&' ){
nextToken();
if( !parseEqualityExpression(expr, templArgs) )
return false;
}
return true;
}
bool Parser::parseExclusiveOrExpression( AST::Node& /*node*/, bool templArgs )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseExclusiveOrExpression()" << endl;
AST::Node expr;
if( !parseAndExpression(expr, templArgs) )
return false;
while( lex->lookAhead(0) == '^' ){
nextToken();
if( !parseAndExpression(expr, templArgs) )
return false;
}
return true;
}
bool Parser::parseInclusiveOrExpression( AST::Node& /*node*/, bool templArgs )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseInclusiveOrExpression()" << endl;
AST::Node expr;
if( !parseExclusiveOrExpression(expr, templArgs) )
return false;
while( lex->lookAhead(0) == '|' ){
nextToken();
if( !parseExclusiveOrExpression(expr, templArgs) )
return false;
}
return true;
}
bool Parser::parseLogicalAndExpression( AST::Node& /*node*/, bool templArgs )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseLogicalAndExpression()" << endl;
AST::Node expr;
if( !parseInclusiveOrExpression(expr, templArgs) )
return false;
while( lex->lookAhead(0) == Token_and ){
nextToken();
if( !parseInclusiveOrExpression(expr, templArgs) )
return false;
}
return true;
}
bool Parser::parseLogicalOrExpression( AST::Node& node, bool templArgs )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseLogicalOrExpression()" << endl;
int start = lex->index();
AST::Node expr;
if( !parseLogicalAndExpression(expr, templArgs) )
return false;
while( lex->lookAhead(0) == Token_or ){
nextToken();
if( !parseLogicalAndExpression(expr, templArgs) )
return false;
}
AST::Node ast = CreateNode<AST>();
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseConditionalExpression( AST::Node& /*node*/ )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseConditionalExpression()" << endl;
AST::Node expr;
if( !parseLogicalOrExpression(expr) )
return false;
if( lex->lookAhead(0) == '?' ){
nextToken();
if( !parseExpression(expr) )
return false;
CHECK( ':', ":" );
if( !parseAssignmentExpression(expr) )
return false;
}
return true;
}
bool Parser::parseAssignmentExpression( AST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseAssignmentExpression()" << endl;
int start = lex->index();
AST::Node expr;
if( lex->lookAhead(0) == Token_throw && !parseThrowExpression(expr) )
return false;
else if( !parseConditionalExpression(expr) )
return false;
while( lex->lookAhead(0) == Token_assign || lex->lookAhead(0) == '=' ){
nextToken();
if( !parseConditionalExpression(expr) )
return false;
}
AST::Node ast = CreateNode<AST>();
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseConstantExpression( AST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseConstantExpression()" << endl;
int start = lex->index();
if( parseConditionalExpression(node) ){
AST::Node ast = CreateNode<AST>();
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
return false;
}
bool Parser::parseExpression( AST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseExpression()" << endl;
int start = lex->index();
if( !parseCommaExpression(node) )
return false;
AST::Node ast = CreateNode<AST>();
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseCommaExpression( AST::Node& node )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseCommaExpression()" << endl;
int start = lex->index();
AST::Node expr;
if( !parseAssignmentExpression(expr) )
return false;
while( lex->lookAhead(0) == ',' ){
nextToken();
if( !parseAssignmentExpression(expr) )
return false;
}
AST::Node ast = CreateNode<AST>();
UPDATE_POS( ast, start, lex->index() );
node = std::move(ast);
return true;
}
bool Parser::parseThrowExpression( AST::Node& /*node*/ )
{
////kdDebug(9007)<< "--- tok = " << lex->lookAhead(0).text() << " -- " << "Parser::parseThrowExpression()" << endl;
if( lex->lookAhead(0) != Token_throw )
return false;
CHECK( Token_throw, "throw" );
AST::Node expr;
if( !parseAssignmentExpression(expr) )
return false;
return true;
}
bool Parser::parseIvarDeclList( AST::Node & node )
{
Q_UNUSED( node );
return false;
}
bool Parser::parseIvarDecls( AST::Node & node )
{
Q_UNUSED( node );
return false;
}
bool Parser::parseIvarDecl( AST::Node & node )
{
Q_UNUSED( node );
return false;
}
bool Parser::parseIvars( AST::Node & node )
{
Q_UNUSED( node );
return false;
}
bool Parser::parseIvarDeclarator( AST::Node & node )
{
Q_UNUSED( node );
return false;
}
bool Parser::parseMethodDecl( AST::Node & node )
{
Q_UNUSED( node );
return false;
}
bool Parser::parseUnarySelector( AST::Node & node )
{
Q_UNUSED( node );
return false;
}
bool Parser::parseKeywordSelector( AST::Node & node )
{
Q_UNUSED( node );
return false;
}
bool Parser::parseSelector( AST::Node & node )
{
Q_UNUSED( node );
return false;
}
bool Parser::parseKeywordDecl( AST::Node & node )
{
Q_UNUSED( node );
return false;
}
bool Parser::parseReceiver( AST::Node & node )
{
Q_UNUSED( node );
return false;
}
bool Parser::parseObjcMessageExpr( AST::Node & node )
{
Q_UNUSED( node );
return false;
}
bool Parser::parseMessageArgs( AST::Node & node )
{
Q_UNUSED( node );
return false;
}
bool Parser::parseKeywordExpr( AST::Node & node )
{
Q_UNUSED( node );
return false;
}
bool Parser::parseKeywordArgList( AST::Node & node )
{
Q_UNUSED( node );
return false;
}
bool Parser::parseKeywordArg( AST::Node & node )
{
Q_UNUSED( node );
return false;
}
bool Parser::parseReservedWord( AST::Node & node )
{
Q_UNUSED( node );
return false;
}
bool Parser::parseMyParms( AST::Node & node )
{
Q_UNUSED( node );
return false;
}
bool Parser::parseMyParm( AST::Node & node )
{
Q_UNUSED( node );
return false;
}
bool Parser::parseOptParmList( AST::Node & node )
{
Q_UNUSED( node );
return false;
}
bool Parser::parseObjcSelectorExpr( AST::Node & node )
{
Q_UNUSED( node );
return false;
}
bool Parser::parseSelectorArg( AST::Node & node )
{
Q_UNUSED( node );
return false;
}
bool Parser::parseKeywordNameList( AST::Node & node )
{
Q_UNUSED( node );
return false;
}
bool Parser::parseKeywordName( AST::Node & node )
{
Q_UNUSED( node );
return false;
}
bool Parser::parseObjcEncodeExpr( AST::Node & node )
{
Q_UNUSED( node );
return false;
}
bool Parser::parseObjcString( AST::Node & node )
{
Q_UNUSED( node );
return false;
}
bool Parser::parseProtocolRefs( AST::Node & node )
{
Q_UNUSED( node );
return false;
}
bool Parser::parseIdentifierList( GroupAST::Node & node )
{
int start = lex->index();
if( lex->lookAhead(0) != Token_identifier )
return false;
GroupAST::Node ast = CreateNode<GroupAST>();
AST_FROM_TOKEN( tk, lex->index() );
ast->addNode( tk );
nextToken();
while( lex->lookAhead(0) == ',' ){
nextToken();
if( lex->lookAhead(0) == Token_identifier ){
AST_FROM_TOKEN( tk, lex->index() );
ast->addNode( tk );
// nextToken();
}
ADVANCE( Token_identifier, "identifier" );
}
node = std::move(ast);
UPDATE_POS( node, start, lex->index() );
return true;
}
bool Parser::parseIdentifierColon( AST::Node & node )
{
Q_UNUSED( node );
if( lex->lookAhead(0) == Token_identifier && lex->lookAhead(1) == ':' ){
nextToken();
nextToken();
return true;
} // ### else if PTYPENAME -> return true ;
return false;
}
bool Parser::parseObjcProtocolExpr( AST::Node & node )
{
Q_UNUSED( node );
return false;
}
bool Parser::parseObjcOpenBracketExpr( AST::Node & node )
{
Q_UNUSED( node );
return false;
}
bool Parser::parseObjcCloseBracket( AST::Node & node )
{
Q_UNUSED( node );
return false;
}
bool Parser::parseObjcDef( DeclarationAST::Node & node )
{
Q_UNUSED( node );
return false;
}
bool Parser::parseObjcClassDef( DeclarationAST::Node & node )
{
Q_UNUSED( node );
return false;
}
bool Parser::parseObjcClassDecl( DeclarationAST::Node & node )
{
Q_UNUSED( node );
ADVANCE( OBJC_CLASS, "@class" );
GroupAST::Node idList;
if ( !parseIdentifierList( idList ) )
return false;
ADVANCE( ';', ";" );
return true;
}
bool Parser::parseObjcProtocolDecl( DeclarationAST::Node & node )
{
Q_UNUSED( node );
ADVANCE( OBJC_PROTOCOL, "@protocol" );
GroupAST::Node idList;
if ( !parseIdentifierList( idList ) )
return false;
ADVANCE( ';', ";" );
return true;
}
bool Parser::parseObjcAliasDecl( DeclarationAST::Node & node )
{
Q_UNUSED( node );
ADVANCE( OBJC_ALIAS, "@alias" );
GroupAST::Node idList;
if ( !parseIdentifierList( idList ) )
return false;
ADVANCE( ';', ";" );
return true;
}
bool Parser::parseObjcProtocolDef( DeclarationAST::Node & node )
{
Q_UNUSED( node );
return false;
}
bool Parser::parseObjcMethodDef( DeclarationAST::Node & node )
{
Q_UNUSED( node );
return false;
}
bool Parser::parseWinDeclSpec( GroupAST::Node & node )
{
if( lex->lookAhead(0) == Token_identifier && lex->lookAhead(0).text() == "__declspec" && lex->lookAhead(1) == '(' && lex->lookAhead(2) != ')'){
int start = lex->index();
nextToken();
nextToken(); // skip '('
if ( !parseIdentifierList( node ) )
return false;
ADVANCE( ')', ")" );
UPDATE_POS( node, start, lex->index() );
return true;
}
return false;
}