~ubuntu-branches/ubuntu/trusty/umbrello/trusty-updates
» Revision
17
: umbrello/codeimport/kdevcppparser/parser.cpp
« back to all changes in this revision
Viewing changes to umbrello/codeimport/kdevcppparser/parser.cpp
- browse files at revision 17
- compare with another revision
- download diff
- download tarball
- view history from revision 17
- Committer: Package Import Robot
- Author(s): Jonathan Riddell
- Date: 2014-03-19 12:12:50 UTC
- mfrom: (1.1.14)
- Revision ID: package-import@ubuntu.com-20140319121250-a7nvktn0cp3k9iny
Tags: 4:4.12.90-0ubuntu1
New upstream beta release
- files added:
- .gitignore
- lib
- lib/cppparser
- lib/interfaces
- files removed:
- umbrello/cmds/cmd_moveWidget.cpp
- files modified:
- CMakeLists.txt
- maintainer/xmi-attribute-changelog *
added
removed
umbrello/codeimport/kdevcppparser/parser.cpp
1
/* This file is part of KDevelop
2
Copyright (C) 2002, 2003 Roberto Raggi <roberto@kdevelop.org>
3
4
This library is free software; you can redistribute it and/or
5
modify it under the terms of the GNU Library General Public
6
License as published by the Free Software Foundation; either
7
version 2 of the License, or (at your option) any later version.
8
9
This library is distributed in the hope that it will be useful,
10
but WITHOUT ANY WARRANTY; without even the implied warranty of
11
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12
Library General Public License for more details.
13
14
You should have received a copy of the GNU Library General Public License
15
along with this library; see the file COPYING.LIB. If not, write to
16
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17
Boston, MA 02110-1301, USA.
18
*/
19
20
// c++ support
21
#include "parser.h"
22
#include "driver.h"
23
#include "lexer.h"
24
#include "errors.h"
25
#include "debug_utils.h"
26
27
// kde support
28
#include <klocale.h>
29
30
// qt support
31
#include <QString>
32
#include <QStringList>
33
34
bool Parser::advance(int tk, char const* descr)
35
{
36
const Token& token = (*m_tokenIt);
37
if (token != tk) {
38
reportError(i18n("'%1' expected found '%2'", QString(descr),
39
token.text()));
40
return false;
41
}
42
++m_tokenIt;
43
return true;
44
}
45
46
bool Parser::check(int tk)
47
{
48
const Token& token = (*m_tokenIt);
49
if (token != tk) {
50
return false;
51
}
52
++m_tokenIt;
53
return true;
54
}
55
56
//@todo remove me
57
enum {
58
OBJC_CLASS,
59
OBJC_PROTOCOL,
60
OBJC_ALIAS
61
};
62
63
struct ParserPrivateData {
64
ParserPrivateData() {}
65
};
66
67
Parser::Parser(Driver* driver, Lexer* lexer)
68
: m_driver(driver),
69
lex(lexer)
70
{
71
d = new ParserPrivateData();
72
m_maxProblems = 5;
73
objcp = false;
74
}
75
76
Parser::~Parser()
77
{
78
delete d;
79
d = 0;
80
}
81
82
bool Parser::reportError(const Error& err)
83
{
84
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::reportError()";
85
if (m_problems < m_maxProblems) {
86
++m_problems;
87
const Token& token = (*m_tokenIt);
88
Position position = lex->getTokenPosition(token);
89
90
QString s = (*m_tokenIt).text();
91
s = s.left(30).trimmed();
92
if (s.isEmpty())
93
s = i18n("<eof>");
94
95
m_driver->addProblem(m_driver->currentFileName(), Problem(err.text.subs(s).toString(), position));
96
}
97
98
return true;
99
}
100
101
bool Parser::reportError(const QString& msg)
102
{
103
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::reportError()";
104
if (m_problems < m_maxProblems) {
105
++m_problems;
106
const Token& token = (*m_tokenIt);
107
Position position = lex->getTokenPosition(token);
108
109
m_driver->addProblem(m_driver->currentFileName(), Problem(msg, position));
110
}
111
112
return true;
113
}
114
115
void Parser::syntaxError()
116
{
117
(void) reportError(Errors::SyntaxError);
118
}
119
120
bool Parser::skipUntil(int token)
121
{
122
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::skipUntil()";
123
while (!(*m_tokenIt).isNull()) {
124
if ((*m_tokenIt) == token)
125
return true;
126
127
++m_tokenIt;
128
}
129
130
return false;
131
}
132
133
bool Parser::skipUntilDeclaration()
134
{
135
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::skipUntilDeclaration()";
136
137
while (!(*m_tokenIt).isNull()) {
138
139
switch ((*m_tokenIt)) {
140
case ';':
141
case '~':
142
case Token_scope:
143
case Token_identifier:
144
case Token_operator:
145
case Token_char:
146
case Token_wchar_t:
147
case Token_bool:
148
case Token_short:
149
case Token_int:
150
case Token_long:
151
case Token_signed:
152
case Token_unsigned:
153
case Token_float:
154
case Token_double:
155
case Token_void:
156
case Token_extern:
157
case Token_namespace:
158
case Token_using:
159
case Token_typedef:
160
case Token_asm:
161
case Token_template:
162
case Token_export:
163
164
case Token_const: // cv
165
case Token_volatile: // cv
166
167
case Token_public:
168
case Token_protected:
169
case Token_private:
170
case Token_signals: // Qt
171
case Token_slots: // Qt
172
return true;
173
174
case '}':
175
return false;
176
177
default:
178
++m_tokenIt;
179
}
180
}
181
182
return false;
183
}
184
185
bool Parser::skipUntilStatement()
186
{
187
//uDebug()<< "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::skipUntilStatement() -- token = " << (*m_tokenIt).text();
188
189
while (!(*m_tokenIt).isNull()) {
190
switch ((*m_tokenIt)) {
191
case ';':
192
case '{':
193
case '}':
194
case Token_const:
195
case Token_volatile:
196
case Token_identifier:
197
case Token_case:
198
case Token_default:
199
case Token_if:
200
case Token_switch:
201
case Token_while:
202
case Token_do:
203
case Token_for:
204
case Token_break:
205
case Token_continue:
206
case Token_return:
207
case Token_goto:
208
case Token_try:
209
case Token_catch:
210
case Token_throw:
211
case Token_char:
212
case Token_wchar_t:
213
case Token_bool:
214
case Token_short:
215
case Token_int:
216
case Token_long:
217
case Token_signed:
218
case Token_unsigned:
219
case Token_float:
220
case Token_double:
221
case Token_void:
222
case Token_class:
223
case Token_struct:
224
case Token_union:
225
case Token_enum:
226
case Token_scope:
227
case Token_template:
228
case Token_using:
229
return true;
230
231
default:
232
++m_tokenIt;
233
}
234
}
235
236
return false;
237
}
238
239
bool Parser::skip(int l, int r)
240
{
241
int count = 0;
242
while (!(*m_tokenIt).isNull()) {
243
int tk = (*m_tokenIt);
244
245
if (tk == l)
246
++count;
247
else if (tk == r)
248
--count;
249
else if (l != '{' && (tk == '{' || tk == '}' || tk == ';'))
250
return false;
251
252
if (count == 0)
253
return true;
254
255
++m_tokenIt;
256
}
257
258
return false;
259
}
260
261
bool Parser::skipCommaExpression(AST::Node& node)
262
{
263
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::skipCommaExpression()";
264
265
TokenIterator start = m_tokenIt;
266
267
AST::Node expr;
268
if (!skipExpression(expr))
269
return false;
270
271
QString comment;
272
while ((*m_tokenIt) == ',') {
273
comment.clear();
274
advanceAndCheckTrailingComment(comment);
275
276
if (!skipExpression(expr)) {
277
reportError(i18n("expression expected"));
278
return false;
279
}
280
}
281
282
AST::Node ast = CreateNode<AST>();
283
update_pos(ast, start, m_tokenIt);
284
node = ast;
285
286
return true;
287
}
288
289
bool Parser::skipExpression(AST::Node& node)
290
{
291
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::skipExpression()";
292
293
TokenIterator start = m_tokenIt;
294
295
while (!(*m_tokenIt).isNull()) {
296
int tk = (*m_tokenIt);
297
298
switch (tk) {
299
case '(':
300
skip('(', ')');
301
++m_tokenIt;
302
break;
303
304
case '[':
305
skip('[', ']');
306
++m_tokenIt;
307
break;
308
309
#if 0
310
case Token_identifier:
311
++m_tokenIt;
312
if ((*m_tokenIt) == Token_identifier)
313
return true;
314
break;
315
#endif
316
317
case ';':
318
case ',':
319
case ']':
320
case ')':
321
case '{':
322
case '}':
323
case Token_case:
324
case Token_default:
325
case Token_if:
326
case Token_while:
327
case Token_do:
328
case Token_for:
329
case Token_break:
330
case Token_continue:
331
case Token_return:
332
case Token_goto: {
333
AST::Node ast = CreateNode<AST>();
334
update_pos(ast, start, m_tokenIt);
335
node = ast;
336
}
337
return true;
338
339
default:
340
++m_tokenIt;
341
}
342
}
343
344
return false;
345
}
346
347
bool Parser::parseName(NameAST::Node& node)
348
{
349
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseName()";
350
351
GroupAST::Node winDeclSpec;
352
parseWinDeclSpec(winDeclSpec);
353
354
TokenIterator start = m_tokenIt;
355
356
NameAST::Node ast = CreateNode<NameAST>();
357
358
if ((*m_tokenIt) == Token_scope) {
359
ast->setGlobal(true);
360
++m_tokenIt;
361
}
362
363
TokenIterator idx = m_tokenIt;
364
365
while (true) {
366
ClassOrNamespaceNameAST::Node n;
367
if (!parseUnqualifiedName(n)) {
368
return false;
369
}
370
371
if ((*m_tokenIt) == Token_scope) {
372
++m_tokenIt;
373
ast->addClassOrNamespaceName(n);
374
if ((*m_tokenIt) == Token_template)
375
++m_tokenIt; /// skip optional template #### @todo CHECK
376
} else {
377
ast->setUnqualifiedName(n);
378
break;
379
}
380
}
381
382
if (idx == m_tokenIt)
383
return false;
384
385
update_pos(ast, start, m_tokenIt);
386
node = ast;
387
388
return true;
389
}
390
391
bool Parser::parseTranslationUnit(TranslationUnitAST::Node& node)
392
{
393
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseTranslationUnit()";
394
395
TokenIterator start = m_tokenIt = lex->tokenBegin();
396
397
m_problems = 0;
398
TranslationUnitAST::Node tun = CreateNode<TranslationUnitAST>();
399
node = tun;
400
while (!(*m_tokenIt).isNull()) {
401
DeclarationAST::Node def;
402
TokenIterator startDecl = m_tokenIt;
403
if (!parseDeclaration(def)) {
404
// error recovery
405
if (startDecl == m_tokenIt)
406
++m_tokenIt; // skip at least one token
407
skipUntilDeclaration();
408
}
409
node->addDeclaration(def);
410
}
411
412
update_pos(node, start, m_tokenIt);
413
414
// force (0, 0) as start position
415
node->setStartPosition(Position());
416
417
return m_problems == 0;
418
}
419
420
bool Parser::parseDeclaration(DeclarationAST::Node& node)
421
{
422
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseDeclaration()";
423
424
// catch first comment
425
Position ps = m_tokenIt->getStartPosition();
426
if (ps.line == 1 && ps.column == 1 && (*m_tokenIt) == Token_comment)
427
{
428
FileAST::Node ast = CreateNode<FileAST>();
429
ast->setFileName(m_driver->currentFileName());
430
QString comment = (*m_tokenIt).text();
431
432
if ((*m_tokenIt) == Token_comment) {
433
ast->setComment(comment);
434
++m_tokenIt;
435
}
436
//uDebug() << m_driver->currentFileName() << comment;
437
node = ast;
438
return true;
439
}
440
441
QString comment;
442
while ((*m_tokenIt) == Token_comment) {
443
comment += (*m_tokenIt).text();
444
++m_tokenIt;
445
}
446
447
if ((*m_tokenIt).isNull()) {
448
// FIXME: add fetched comment to FileAST
449
return false;
450
}
451
452
TokenIterator start = m_tokenIt;
453
bool success = false;
454
455
switch ((*m_tokenIt)) {
456
457
case ';':
458
++m_tokenIt;
459
return true;
460
461
case Token_extern:
462
success = parseLinkageSpecification(node);
463
break;
464
465
case Token_namespace:
466
success = parseNamespace(node);
467
break;
468
469
case Token_using:
470
success = parseUsing(node);
471
break;
472
473
case Token_typedef:
474
success = parseTypedef(node);
475
break;
476
477
case Token_asm:
478
success = parseAsmDefinition(node);
479
break;
480
481
case Token_template:
482
case Token_export:
483
success = parseTemplateDeclaration(node);
484
break;
485
486
default: {
487
// m_tokenIt = start;
488
489
if (objcp && parseObjcDef(node))
490
return true;
491
492
m_tokenIt = start;
493
494
GroupAST::Node storageSpec;
495
parseStorageClassSpecifier(storageSpec);
496
497
GroupAST::Node cv;
498
parseCvQualify(cv);
499
500
TypeSpecifierAST::Node spec;
501
AST::Node declarator;
502
if (parseEnumSpecifier(spec) || parseClassSpecifier(spec)) {
503
spec->setCvQualify(cv);
504
505
GroupAST::Node cv2;
506
parseCvQualify(cv2);
507
spec->setCv2Qualify(cv2);
508
509
InitDeclaratorListAST::Node declarators;
510
parseInitDeclaratorList(declarators);
511
512
if (!advance(';', ";"))
513
return false;
514
515
if (!comment.isEmpty()) {
516
//uDebug() << "Parser::parseDeclaration(spec): comment is " << comment;
517
spec->setComment(comment);
518
}
519
520
SimpleDeclarationAST::Node ast = CreateNode<SimpleDeclarationAST>();
521
ast->setStorageSpecifier(storageSpec);
522
ast->setTypeSpec(spec);
523
ast->setInitDeclaratorList(declarators);
524
update_pos(ast, start, m_tokenIt);
525
node = ast;
526
527
return true;
528
}
529
530
m_tokenIt = start;
531
success = parseDeclarationInternal(node, comment);
532
}
533
534
} // end switch
535
536
if (success && !comment.isEmpty()) {
537
//uDebug() << "Parser::parseDeclaration(): comment is " << comment;
538
node->setComment(comment);
539
}
540
return success;
541
}
542
543
bool Parser::parseLinkageSpecification(DeclarationAST::Node& node)
544
{
545
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseLinkageSpecification()";
546
547
TokenIterator start = m_tokenIt;
548
549
if ((*m_tokenIt) != Token_extern) {
550
return false;
551
}
552
++m_tokenIt;
553
554
LinkageSpecificationAST::Node ast = CreateNode<LinkageSpecificationAST>();
555
556
TokenIterator startExternType = m_tokenIt;
557
if ((*m_tokenIt) == Token_string_literal) {
558
++m_tokenIt;
559
AST::Node externType = CreateNode<AST>();
560
update_pos(externType, startExternType, m_tokenIt);
561
562
ast->setExternType(externType);
563
}
564
565
if ((*m_tokenIt) == '{') {
566
LinkageBodyAST::Node linkageBody;
567
parseLinkageBody(linkageBody);
568
ast->setLinkageBody(linkageBody);
569
} else {
570
DeclarationAST::Node decl;
571
if (!parseDeclaration(decl)) {
572
reportError(i18n("Declaration syntax error"));
573
}
574
ast->setDeclaration(decl);
575
}
576
577
update_pos(ast, start, m_tokenIt);
578
579
node = ast;
580
581
return true;
582
}
583
584
bool Parser::parseLinkageBody(LinkageBodyAST::Node& node)
585
{
586
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseLinkageBody()";
587
588
TokenIterator start = m_tokenIt;
589
590
if ((*m_tokenIt) != '{') {
591
return false;
592
}
593
++m_tokenIt;
594
595
LinkageBodyAST::Node lba = CreateNode<LinkageBodyAST>();
596
node = lba;
597
598
while (!(*m_tokenIt).isNull()) {
599
int tk = (*m_tokenIt);
600
601
if (tk == '}')
602
break;
603
604
DeclarationAST::Node def;
605
TokenIterator startDecl = m_tokenIt;
606
if (parseDeclaration(def)) {
607
node->addDeclaration(def);
608
} else {
609
// error recovery
610
if (startDecl == m_tokenIt)
611
++m_tokenIt; // skip at least one token
612
skipUntilDeclaration();
613
}
614
}
615
616
if ((*m_tokenIt) != '}') {
617
reportError(i18n("} expected"));
618
} else
619
++m_tokenIt;
620
621
update_pos(node, start, m_tokenIt);
622
return true;
623
}
624
625
bool Parser::parseNamespace(DeclarationAST::Node& node)
626
{
627
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseNamespace()";
628
629
TokenIterator start = m_tokenIt;
630
631
if ((*m_tokenIt) != Token_namespace) {
632
return false;
633
}
634
++m_tokenIt;
635
636
TokenIterator startNamespaceName = m_tokenIt;
637
if ((*m_tokenIt) == Token_identifier) {
638
++m_tokenIt;
639
}
640
AST::Node namespaceName = CreateNode<AST>();
641
update_pos(namespaceName, startNamespaceName, m_tokenIt);
642
643
if ((*m_tokenIt) == '=') {
644
// namespace alias
645
++m_tokenIt;
646
647
NameAST::Node name;
648
if (parseName(name)) {
649
if (!advance(';', ";"))
650
return false;
651
652
NamespaceAliasAST::Node ast = CreateNode<NamespaceAliasAST>();
653
ast->setNamespaceName(namespaceName);
654
ast->setAliasName(name);
655
update_pos(ast, start, m_tokenIt);
656
node = ast;
657
return true;
658
} else {
659
reportError(i18n("namespace expected"));
660
return false;
661
}
662
} else if ((*m_tokenIt) != '{') {
663
reportError(i18n("{ expected"));
664
return false;
665
}
666
667
NamespaceAST::Node ast = CreateNode<NamespaceAST>();
668
ast->setNamespaceName(namespaceName);
669
670
LinkageBodyAST::Node linkageBody;
671
parseLinkageBody(linkageBody);
672
673
ast->setLinkageBody(linkageBody);
674
update_pos(ast, start, m_tokenIt);
675
node = ast;
676
677
return true;
678
}
679
680
bool Parser::parseUsing(DeclarationAST::Node& node)
681
{
682
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseUsing()";
683
684
TokenIterator start = m_tokenIt;
685
686
if ((*m_tokenIt) != Token_using) {
687
return false;
688
}
689
++m_tokenIt;
690
691
if ((*m_tokenIt) == Token_namespace) {
692
if (!parseUsingDirective(node)) {
693
return false;
694
}
695
update_pos(node, start, m_tokenIt);
696
return true;
697
}
698
699
UsingAST::Node ast = CreateNode<UsingAST>();
700
701
TokenIterator startTypeName = m_tokenIt;
702
if ((*m_tokenIt) == Token_typename) {
703
++m_tokenIt;
704
AST::Node tn = CreateNode<AST>();
705
update_pos(tn, startTypeName, m_tokenIt);
706
ast->setTypeName(tn);
707
}
708
709
NameAST::Node name;
710
if (!parseName(name))
711
return false;
712
713
ast->setName(name);
714
715
if (!advance(';', ";"))
716
return false;
717
718
update_pos(ast, start, m_tokenIt);
719
node = ast;
720
721
return true;
722
}
723
724
bool Parser::parseUsingDirective(DeclarationAST::Node& node)
725
{
726
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseUsingDirective()";
727
728
TokenIterator start = m_tokenIt;
729
730
if ((*m_tokenIt) != Token_namespace) {
731
return false;
732
}
733
++m_tokenIt;
734
735
NameAST::Node name;
736
if (!parseName(name)) {
737
reportError(i18n("Namespace name expected"));
738
return false;
739
}
740
741
if (!advance(';', ";"))
742
return false;
743
744
UsingDirectiveAST::Node ast = CreateNode<UsingDirectiveAST>();
745
ast->setName(name);
746
update_pos(ast, start, m_tokenIt);
747
node = ast;
748
749
return true;
750
}
751
752
bool Parser::parseOperatorFunctionId(AST::Node& node)
753
{
754
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseOperatorFunctionId()";
755
756
TokenIterator start = m_tokenIt;
757
758
if ((*m_tokenIt) != Token_operator) {
759
return false;
760
}
761
++m_tokenIt;
762
763
AST::Node op;
764
if (parseOperator(op)) {
765
AST::Node asn = CreateNode<AST>();
766
node = asn;
767
update_pos(node, start, m_tokenIt);
768
return true;
769
} else {
770
// parse cast operator
771
GroupAST::Node cv;
772
parseCvQualify(cv);
773
774
TypeSpecifierAST::Node spec;
775
if (!parseSimpleTypeSpecifier(spec)) {
776
syntaxError();
777
return false;
778
}
779
spec->setCvQualify(cv);
780
781
GroupAST::Node cv2;
782
parseCvQualify(cv2);
783
spec->setCv2Qualify(cv2);
784
785
AST::Node ptrOp;
786
while (parsePtrOperator(ptrOp))
787
;
788
789
AST::Node asn = CreateNode<AST>();
790
node = asn;
791
update_pos(node, start, m_tokenIt);
792
return true;
793
}
794
}
795
796
bool Parser::parseTemplateArgumentList(TemplateArgumentListAST::Node& node, bool reportError)
797
{
798
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseTemplateArgumentList()";
799
800
TokenIterator start = m_tokenIt;
801
802
TemplateArgumentListAST::Node ast = CreateNode<TemplateArgumentListAST>();
803
804
AST::Node templArg;
805
if (!parseTemplateArgument(templArg))
806
return false;
807
ast->addArgument(templArg);
808
809
QString comment;
810
while ((*m_tokenIt) == ',') {
811
comment.clear();
812
advanceAndCheckTrailingComment(comment);
813
814
if (!parseTemplateArgument(templArg)) {
815
if (reportError) {
816
syntaxError();
817
break;
818
} else
819
return false;
820
}
821
if (!comment.isEmpty())
822
templArg->setComment(comment);
823
ast->addArgument(templArg);
824
}
825
826
update_pos(ast, start, m_tokenIt);
827
node = ast;
828
829
return true;
830
}
831
832
bool Parser::parseTypedef(DeclarationAST::Node& node)
833
{
834
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseTypedef()";
835
836
TokenIterator start = m_tokenIt;
837
838
if ((*m_tokenIt) != Token_typedef) {
839
return false;
840
}
841
++m_tokenIt;
842
843
TypeSpecifierAST::Node spec;
844
if (!parseTypeSpecifierOrClassSpec(spec)) {
845
reportError(i18n("Need a type specifier to declare"));
846
return false;
847
}
848
849
InitDeclaratorListAST::Node declarators;
850
if (!parseInitDeclaratorList(declarators)) {
851
//reportError(i18n("Need an identifier to declare"));
852
//return false;
853
}
854
855
if (!advance(';', ";"))
856
return false;
857
858
TypedefAST::Node ast = CreateNode<TypedefAST>();
859
ast->setTypeSpec(spec);
860
ast->setInitDeclaratorList(declarators);
861
update_pos(ast, start, m_tokenIt);
862
node = ast;
863
864
return true;
865
}
866
867
bool Parser::parseAsmDefinition(DeclarationAST::Node& /*node*/)
868
{
869
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseAsmDefinition()";
870
871
if (!advance(Token_asm, "asm"))
872
return false;
873
874
GroupAST::Node cv;
875
parseCvQualify(cv);
876
877
skip('(', ')');
878
if (!advance(')', ")"))
879
return false;
880
if (!advance(';', ";"))
881
return false;
882
883
return true;
884
}
885
886
bool Parser::parseTemplateDeclaration(DeclarationAST::Node& node)
887
{
888
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseTemplateDeclaration()";
889
890
TokenIterator start = m_tokenIt;
891
892
AST::Node exp;
893
894
TokenIterator startExport = m_tokenIt;
895
if ((*m_tokenIt) == Token_export) {
896
++m_tokenIt;
897
AST::Node n = CreateNode<AST>();
898
update_pos(n, startExport, m_tokenIt);
899
exp = n;
900
}
901
902
if ((*m_tokenIt) != Token_template) {
903
return false;
904
}
905
++m_tokenIt;
906
907
TemplateParameterListAST::Node params;
908
if ((*m_tokenIt) == '<') {
909
++m_tokenIt;
910
if ((*m_tokenIt) != '>')
911
parseTemplateParameterList(params);
912
913
if (!advance('>', ">"))
914
return false;
915
}
916
917
DeclarationAST::Node def;
918
if (!parseDeclaration(def)) {
919
reportError(i18n("expected a declaration"));
920
}
921
922
TemplateDeclarationAST::Node ast = CreateNode<TemplateDeclarationAST>();
923
ast->setExported(exp);
924
ast->setTemplateParameterList(params);
925
ast->setDeclaration(def);
926
update_pos(ast, start, m_tokenIt);
927
node = ast;
928
929
return true;
930
}
931
932
bool Parser::parseOperator(AST::Node& /*node*/)
933
{
934
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseOperator()";
935
QString text = (*m_tokenIt).text();
936
937
switch ((*m_tokenIt)) {
938
case Token_new:
939
case Token_delete:
940
++m_tokenIt;
941
if ((*m_tokenIt) == '[' && lex->lookAhead(m_tokenIt, 1) == ']') {
942
++m_tokenIt;
943
++m_tokenIt;
944
text += "[]";
945
}
946
return true;
947
948
case '+':
949
case '-':
950
case '*':
951
case '/':
952
case '%':
953
case '^':
954
case '&':
955
case '|':
956
case '~':
957
case '!':
958
case '=':
959
case '<':
960
case '>':
961
case ',':
962
case Token_assign:
963
case Token_left_shift:
964
case Token_eq:
965
case Token_not_eq:
966
case Token_leq:
967
case Token_geq:
968
case Token_and:
969
case Token_or:
970
case Token_incr:
971
case Token_decr:
972
case Token_ptrmem:
973
case Token_arrow:
974
++m_tokenIt;
975
return true;
976
977
default:
978
if ((*m_tokenIt) == '(' && lex->lookAhead(m_tokenIt, 1) == ')') {
979
++m_tokenIt;
980
++m_tokenIt;
981
return true;
982
} else if ((*m_tokenIt) == '[' && lex->lookAhead(m_tokenIt, 1) == ']') {
983
++m_tokenIt;
984
++m_tokenIt;
985
return true;
986
}
987
}
988
989
return false;
990
}
991
992
bool Parser::parseCvQualify(GroupAST::Node& node)
993
{
994
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseCvQualify()";
995
996
TokenIterator start = m_tokenIt;
997
998
GroupAST::Node ast = CreateNode<GroupAST>();
999
1000
int n = 0;
1001
while (!(*m_tokenIt).isNull()) {
1002
int tk = (*m_tokenIt);
1003
if (tk == Token_const || tk == Token_volatile) {
1004
++n;
1005
TokenIterator startWord = m_tokenIt;
1006
++m_tokenIt;
1007
AST::Node word = CreateNode<AST>();
1008
update_pos(word, startWord, m_tokenIt);
1009
ast->addNode(word);
1010
} else
1011
break;
1012
}
1013
1014
if (n == 0)
1015
return false;
1016
1017
1018
//uDebug() << "-----------------> token = " << (*m_tokenIt).text();
1019
update_pos(ast, start, m_tokenIt);
1020
1021
node = ast;
1022
return true;
1023
}
1024
1025
bool Parser::parseSimpleTypeSpecifier(TypeSpecifierAST::Node& node)
1026
{
1027
TokenIterator start = m_tokenIt;
1028
bool isIntegral = false;
1029
bool done = false;
1030
1031
while (!done) {
1032
1033
switch ((*m_tokenIt)) {
1034
case Token_char:
1035
case Token_wchar_t:
1036
case Token_bool:
1037
case Token_short:
1038
case Token_int:
1039
case Token_long:
1040
case Token_signed:
1041
case Token_unsigned:
1042
case Token_float:
1043
case Token_double:
1044
case Token_void:
1045
isIntegral = true;
1046
++m_tokenIt;
1047
break;
1048
1049
default:
1050
done = true;
1051
}
1052
}
1053
1054
TypeSpecifierAST::Node ast = CreateNode<TypeSpecifierAST>();
1055
if (isIntegral) {
1056
ClassOrNamespaceNameAST::Node cl = CreateNode<ClassOrNamespaceNameAST>();
1057
1058
AST::Node n = CreateNode<AST>();
1059
update_pos(n, start, m_tokenIt);
1060
cl->setName(n);
1061
update_pos(cl, start, m_tokenIt);
1062
1063
NameAST::Node name = CreateNode<NameAST>();
1064
name->setUnqualifiedName(cl);
1065
update_pos(name, start, m_tokenIt);
1066
ast->setName(name);
1067
1068
} else {
1069
NameAST::Node name;
1070
if (!parseName(name)) {
1071
m_tokenIt = start;
1072
return false;
1073
}
1074
ast->setName(name);
1075
}
1076
1077
update_pos(ast, start, m_tokenIt);
1078
node = ast;
1079
return true;
1080
}
1081
1082
bool Parser::parsePtrOperator(AST::Node& node)
1083
{
1084
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parsePtrOperator()";
1085
1086
TokenIterator start = m_tokenIt;
1087
1088
if ((*m_tokenIt) == '&') {
1089
++m_tokenIt;
1090
} else if ((*m_tokenIt) == '*') {
1091
++m_tokenIt;
1092
} else {
1093
TokenIterator index = m_tokenIt;
1094
AST::Node memPtr;
1095
if (!parsePtrToMember(memPtr)) {
1096
m_tokenIt = index;
1097
return false;
1098
}
1099
}
1100
1101
GroupAST::Node cv;
1102
parseCvQualify(cv);
1103
1104
AST::Node ast = CreateNode<AST>();
1105
update_pos(ast, start, m_tokenIt);
1106
node = ast;
1107
1108
return true;
1109
}
1110
1111
bool Parser::parseTemplateArgument(AST::Node& node)
1112
{
1113
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseTemplateArgument()";
1114
1115
TokenIterator start = m_tokenIt;
1116
if (parseTypeId(node)) {
1117
if ((*m_tokenIt) == ',' || (*m_tokenIt) == '>')
1118
return true;
1119
}
1120
1121
m_tokenIt = start;
1122
if (!parseLogicalOrExpression(node, true)) {
1123
return false;
1124
}
1125
1126
return true;
1127
}
1128
1129
bool Parser::parseTypeSpecifier(TypeSpecifierAST::Node& spec)
1130
{
1131
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseTypeSpecifier()";
1132
1133
GroupAST::Node cv;
1134
parseCvQualify(cv);
1135
1136
if (parseElaboratedTypeSpecifier(spec) || parseSimpleTypeSpecifier(spec)) {
1137
spec->setCvQualify(cv);
1138
1139
GroupAST::Node cv2;
1140
parseCvQualify(cv2);
1141
spec->setCv2Qualify(cv2);
1142
1143
return true;
1144
}
1145
1146
return false;
1147
}
1148
1149
bool Parser::parseDeclarator(DeclaratorAST::Node& node)
1150
{
1151
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseDeclarator()";
1152
1153
TokenIterator start = m_tokenIt;
1154
1155
DeclaratorAST::Node ast = CreateNode<DeclaratorAST>();
1156
1157
DeclaratorAST::Node decl;
1158
NameAST::Node declId;
1159
1160
AST::Node ptrOp;
1161
while (parsePtrOperator(ptrOp)) {
1162
ast->addPtrOp(ptrOp);
1163
}
1164
1165
if ((*m_tokenIt) == '(') {
1166
++m_tokenIt;
1167
1168
if (!parseDeclarator(decl)) {
1169
return false;
1170
}
1171
ast->setSubDeclarator(decl);
1172
1173
if ((*m_tokenIt) != ')') {
1174
return false;
1175
}
1176
++m_tokenIt;
1177
} else {
1178
1179
if ((*m_tokenIt) == ':') {
1180
// unnamed bitfield
1181
} else if (parseDeclaratorId(declId)) {
1182
ast->setDeclaratorId(declId);
1183
} else {
1184
m_tokenIt = start;
1185
return false;
1186
}
1187
1188
if ((*m_tokenIt) == ':') {
1189
++m_tokenIt;
1190
AST::Node expr;
1191
if (!parseConstantExpression(expr)) {
1192
reportError(i18n("Constant expression expected"));
1193
}
1194
goto update_pos;
1195
}
1196
}
1197
1198
{
1199
bool isVector = true;
1200
1201
while ((*m_tokenIt) == '[') {
1202
TokenIterator startArray = m_tokenIt;
1203
++m_tokenIt;
1204
AST::Node expr;
1205
parseCommaExpression(expr);
1206
1207
if (!advance(']', "]"))
1208
return false;
1209
AST::Node array = CreateNode<AST>();
1210
update_pos(array, startArray, m_tokenIt);
1211
ast->addArrayDimension(array);
1212
isVector = true;
1213
}
1214
1215
bool skipParen = false;
1216
if ((*m_tokenIt) == Token_identifier && lex->lookAhead(m_tokenIt, 1) == '(' && lex->lookAhead(m_tokenIt, 2) == '(') {
1217
++m_tokenIt;
1218
++m_tokenIt;
1219
skipParen = true;
1220
}
1221
1222
if (ast->subDeclarator() && (!isVector || (*m_tokenIt) != '(')) {
1223
m_tokenIt = start;
1224
return false;
1225
}
1226
1227
TokenIterator index = m_tokenIt;
1228
if ((*m_tokenIt) == '(') {
1229
++m_tokenIt;
1230
1231
ParameterDeclarationClauseAST::Node params;
1232
if (!parseParameterDeclarationClause(params)) {
1233
//uDebug() << "----------------------> not a parameter declaration, maybe an initializer!?";
1234
m_tokenIt = index;
1235
goto update_pos;
1236
}
1237
ast->setParameterDeclarationClause(params);
1238
1239
if ((*m_tokenIt) != ')') {
1240
m_tokenIt = index;
1241
goto update_pos;
1242
}
1243
1244
++m_tokenIt; // skip ')'
1245
1246
TokenIterator startConstant = m_tokenIt;
1247
if ((*m_tokenIt) == Token_const) {
1248
++m_tokenIt;
1249
AST::Node constant = CreateNode<AST>();
1250
update_pos(constant, startConstant, m_tokenIt);
1251
ast->setConstant(constant);
1252
}
1253
1254
GroupAST::Node except;
1255
if (parseExceptionSpecification(except)) {
1256
ast->setExceptionSpecification(except);
1257
}
1258
}
1259
1260
if (skipParen) {
1261
if ((*m_tokenIt) != ')') {
1262
reportError(i18n("')' expected"));
1263
} else
1264
++m_tokenIt;
1265
}
1266
}
1267
1268
update_pos:
1269
update_pos(ast, start, m_tokenIt);
1270
node = ast;
1271
1272
return true;
1273
}
1274
1275
bool Parser::parseAbstractDeclarator(DeclaratorAST::Node& node)
1276
{
1277
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseDeclarator()";
1278
TokenIterator start = m_tokenIt;
1279
1280
DeclaratorAST::Node ast = CreateNode<DeclaratorAST>();
1281
1282
DeclaratorAST::Node decl;
1283
NameAST::Node declId;
1284
1285
AST::Node ptrOp;
1286
while (parsePtrOperator(ptrOp)) {
1287
ast->addPtrOp(ptrOp);
1288
}
1289
1290
if ((*m_tokenIt) == '(') {
1291
++m_tokenIt;
1292
1293
if (!parseAbstractDeclarator(decl)) {
1294
return false;
1295
}
1296
ast->setSubDeclarator(decl);
1297
1298
if ((*m_tokenIt) != ')') {
1299
return false;
1300
}
1301
++m_tokenIt;
1302
}
1303
1304
{
1305
while ((*m_tokenIt) == '[') {
1306
TokenIterator startArray = m_tokenIt;
1307
++m_tokenIt;
1308
AST::Node expr;
1309
skipCommaExpression(expr);
1310
1311
if (!advance(']', "]"))
1312
return false;
1313
AST::Node array = CreateNode<AST>();
1314
update_pos(array, startArray, m_tokenIt);
1315
ast->addArrayDimension(array);
1316
}
1317
1318
bool skipParen = false;
1319
if ((*m_tokenIt) == Token_identifier && lex->lookAhead(m_tokenIt, 1) == '(' && lex->lookAhead(m_tokenIt, 2) == '(') {
1320
++m_tokenIt;
1321
++m_tokenIt;
1322
skipParen = true;
1323
}
1324
1325
TokenIterator index = m_tokenIt;
1326
if ((*m_tokenIt) == '(') {
1327
++m_tokenIt;
1328
1329
ParameterDeclarationClauseAST::Node params;
1330
if (!parseParameterDeclarationClause(params)) {
1331
m_tokenIt = index;
1332
goto update_pos;
1333
}
1334
ast->setParameterDeclarationClause(params);
1335
1336
if ((*m_tokenIt) != ')') {
1337
m_tokenIt = index;
1338
goto update_pos;
1339
} else
1340
++m_tokenIt;
1341
1342
TokenIterator startConstant = m_tokenIt;
1343
if ((*m_tokenIt) == Token_const) {
1344
++m_tokenIt;
1345
AST::Node constant = CreateNode<AST>();
1346
update_pos(constant, startConstant, m_tokenIt);
1347
ast->setConstant(constant);
1348
}
1349
1350
GroupAST::Node except;
1351
if (parseExceptionSpecification(except)) {
1352
ast->setExceptionSpecification(except);
1353
}
1354
}
1355
1356
if (skipParen) {
1357
if ((*m_tokenIt) != ')') {
1358
reportError(i18n("')' expected"));
1359
} else
1360
++m_tokenIt;
1361
}
1362
1363
}
1364
1365
update_pos:
1366
update_pos(ast, start, m_tokenIt);
1367
node = ast;
1368
1369
return true;
1370
}
1371
1372
bool Parser::parseEnumSpecifier(TypeSpecifierAST::Node& node)
1373
{
1374
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseEnumSpecifier()";
1375
1376
QString comment;
1377
while ((*m_tokenIt) == Token_comment) {
1378
comment += (*m_tokenIt).text();
1379
++m_tokenIt;
1380
}
1381
if ((*m_tokenIt).isNull())
1382
return false;
1383
1384
TokenIterator start = m_tokenIt;
1385
1386
if ((*m_tokenIt) != Token_enum) {
1387
return false;
1388
}
1389
1390
++m_tokenIt;
1391
1392
NameAST::Node name;
1393
parseName(name);
1394
1395
if ((*m_tokenIt) != '{') {
1396
m_tokenIt = start;
1397
return false;
1398
}
1399
++m_tokenIt;
1400
1401
EnumSpecifierAST::Node ast = CreateNode<EnumSpecifierAST>();
1402
ast->setName(name);
1403
1404
EnumeratorAST::Node enumerator;
1405
if (parseEnumerator(enumerator)) {
1406
ast->addEnumerator(enumerator);
1407
1408
QString comment;
1409
while ((*m_tokenIt) == ',') {
1410
comment = "";
1411
advanceAndCheckTrailingComment(comment);
1412
if (!comment.isEmpty()) {
1413
EnumeratorAST *lastLit = ast->enumeratorList().last();
1414
if (lastLit)
1415
lastLit->setComment(comment);
1416
}
1417
1418
if (!parseEnumerator(enumerator)) {
1419
//reportError(i18n("Enumerator expected"));
1420
break;
1421
}
1422
1423
ast->addEnumerator(enumerator);
1424
}
1425
}
1426
1427
if ((*m_tokenIt) == Token_comment)
1428
++m_tokenIt;
1429
if ((*m_tokenIt) != '}')
1430
reportError(i18n("} missing"));
1431
else
1432
++m_tokenIt;
1433
1434
update_pos(ast, start, m_tokenIt);
1435
node = ast;
1436
1437
return true;
1438
}
1439
1440
bool Parser::parseTemplateParameterList(TemplateParameterListAST::Node& node)
1441
{
1442
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseTemplateParameterList()";
1443
1444
TokenIterator start = m_tokenIt;
1445
1446
TemplateParameterListAST::Node ast = CreateNode<TemplateParameterListAST>();
1447
1448
TemplateParameterAST::Node param;
1449
if (!parseTemplateParameter(param)) {
1450
return false;
1451
}
1452
ast->addTemplateParameter(param);
1453
1454
QString comment;
1455
while ((*m_tokenIt) == ',') {
1456
comment.clear();
1457
advanceAndCheckTrailingComment(comment);
1458
1459
if (!parseTemplateParameter(param)) {
1460
syntaxError();
1461
break;
1462
} else {
1463
if (!comment.isEmpty())
1464
param->setComment(comment);
1465
ast->addTemplateParameter(param);
1466
}
1467
}
1468
1469
update_pos(ast, start, m_tokenIt);
1470
node = ast;
1471
1472
return true;
1473
}
1474
1475
bool Parser::parseTemplateParameter(TemplateParameterAST::Node& node)
1476
{
1477
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseTemplateParameter()";
1478
1479
TokenIterator start = m_tokenIt;
1480
TemplateParameterAST::Node ast = CreateNode<TemplateParameterAST>();
1481
1482
TypeParameterAST::Node typeParameter;
1483
ParameterDeclarationAST::Node param;
1484
1485
int tk = (*m_tokenIt);
1486
1487
if ((tk == Token_class || tk == Token_typename || tk == Token_template) && parseTypeParameter(typeParameter)) {
1488
ast->setTypeParameter(typeParameter);
1489
goto ok;
1490
}
1491
1492
if (!parseParameterDeclaration(param))
1493
return false;
1494
ast->setTypeValueParameter(param);
1495
1496
ok:
1497
update_pos(ast, start, m_tokenIt);
1498
node = ast;
1499
1500
return true;
1501
}
1502
1503
bool Parser::parseTypeParameter(TypeParameterAST::Node& node)
1504
{
1505
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseTypeParameter()";
1506
1507
TokenIterator start = m_tokenIt;
1508
TypeParameterAST::Node ast = CreateNode<TypeParameterAST>();
1509
1510
AST::Node kind = ast_from_token(m_tokenIt);
1511
ast->setKind(kind);
1512
1513
switch ((*m_tokenIt)) {
1514
1515
case Token_class:
1516
case Token_typename: {
1517
++m_tokenIt; // skip class
1518
1519
// parse optional name
1520
NameAST::Node name;
1521
if (parseName(name)) {
1522
ast->setName(name);
1523
if ((*m_tokenIt) == '=') {
1524
++m_tokenIt;
1525
1526
AST::Node typeId;
1527
if (!parseTypeId(typeId)) {
1528
syntaxError();
1529
return false;
1530
}
1531
ast->setTypeId(typeId);
1532
}
1533
}
1534
}
1535
break;
1536
1537
case Token_template: {
1538
++m_tokenIt; // skip template
1539
if (!advance('<', "<"))
1540
return false;
1541
1542
TemplateParameterListAST::Node params;
1543
if (!parseTemplateParameterList(params)) {
1544
return false;
1545
}
1546
ast->setTemplateParameterList(params);
1547
1548
if (!advance('>', ">"))
1549
return false;
1550
1551
if ((*m_tokenIt) == Token_class)
1552
++m_tokenIt;
1553
1554
// parse optional name
1555
NameAST::Node name;
1556
if (parseName(name)) {
1557
ast->setName(name);
1558
if ((*m_tokenIt) == '=') {
1559
++m_tokenIt;
1560
1561
AST::Node typeId;
1562
if (!parseTypeId(typeId)) {
1563
syntaxError();
1564
return false;
1565
}
1566
ast->setTypeId(typeId);
1567
}
1568
}
1569
1570
if ((*m_tokenIt) == '=') {
1571
++m_tokenIt;
1572
1573
NameAST::Node templ_name;
1574
parseName(templ_name);
1575
}
1576
}
1577
break;
1578
1579
default:
1580
return false;
1581
1582
} // end switch
1583
1584
1585
update_pos(ast, start, m_tokenIt);
1586
node = ast;
1587
return true;
1588
}
1589
1590
bool Parser::parseStorageClassSpecifier(GroupAST::Node& node)
1591
{
1592
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseStorageClassSpecifier()";
1593
1594
TokenIterator start = m_tokenIt;
1595
GroupAST::Node ast = CreateNode<GroupAST>();
1596
1597
while (!(*m_tokenIt).isNull()) {
1598
int tk = (*m_tokenIt);
1599
if (tk == Token_friend || tk == Token_auto || tk == Token_register || tk == Token_static ||
1600
tk == Token_extern || tk == Token_mutable) {
1601
TokenIterator startNode = m_tokenIt;
1602
++m_tokenIt;
1603
1604
AST::Node n = CreateNode<AST>();
1605
update_pos(n, startNode, m_tokenIt);
1606
ast->addNode(n);
1607
} else
1608
break;
1609
}
1610
1611
if (ast->nodeList().count() == 0)
1612
return false;
1613
1614
update_pos(ast, start, m_tokenIt);
1615
node = ast;
1616
return true;
1617
}
1618
1619
bool Parser::parseFunctionSpecifier(GroupAST::Node& node)
1620
{
1621
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseFunctionSpecifier()";
1622
1623
TokenIterator start = m_tokenIt;
1624
GroupAST::Node ast = CreateNode<GroupAST>();
1625
1626
while (!(*m_tokenIt).isNull()) {
1627
int tk = (*m_tokenIt);
1628
if (tk == Token_inline || tk == Token_virtual || tk == Token_explicit) {
1629
TokenIterator startNode = m_tokenIt;
1630
++m_tokenIt;
1631
1632
AST::Node n = CreateNode<AST>();
1633
update_pos(n, startNode, m_tokenIt);
1634
ast->addNode(n);
1635
} else {
1636
break;
1637
}
1638
}
1639
1640
if (ast->nodeList().count() == 0)
1641
return false;
1642
1643
update_pos(ast, start, m_tokenIt);
1644
node = ast;
1645
return true;
1646
}
1647
1648
bool Parser::parseTypeId(AST::Node& node)
1649
{
1650
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseTypeId()";
1651
1652
/// @todo implement the AST for typeId
1653
TokenIterator start = m_tokenIt;
1654
AST::Node ast = CreateNode<AST>();
1655
1656
TypeSpecifierAST::Node spec;
1657
if (!parseTypeSpecifier(spec)) {
1658
return false;
1659
}
1660
1661
DeclaratorAST::Node decl;
1662
parseAbstractDeclarator(decl);
1663
1664
update_pos(ast, start, m_tokenIt);
1665
node = ast;
1666
1667
return true;
1668
}
1669
1670
bool Parser::parseInitDeclaratorList(InitDeclaratorListAST::Node& node)
1671
{
1672
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseInitDeclaratorList()";
1673
1674
TokenIterator start = m_tokenIt;
1675
1676
InitDeclaratorListAST::Node ast = CreateNode<InitDeclaratorListAST>();
1677
InitDeclaratorAST::Node decl;
1678
1679
if (!parseInitDeclarator(decl)) {
1680
return false;
1681
}
1682
ast->addInitDeclarator(decl);
1683
1684
QString comment;
1685
while ((*m_tokenIt) == ',') {
1686
comment = "";
1687
advanceAndCheckTrailingComment(comment);
1688
1689
if (!parseInitDeclarator(decl)) {
1690
syntaxError();
1691
break;
1692
}
1693
if (!comment.isEmpty())
1694
decl->setComment(comment);
1695
ast->addInitDeclarator(decl);
1696
}
1697
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseInitDeclaratorList() -- end";
1698
1699
update_pos(ast, start, m_tokenIt);
1700
node = ast;
1701
1702
return true;
1703
}
1704
1705
bool Parser::parseParameterDeclarationClause(ParameterDeclarationClauseAST::Node& node)
1706
{
1707
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseParameterDeclarationClause()";
1708
1709
TokenIterator start = m_tokenIt;
1710
1711
ParameterDeclarationClauseAST::Node ast = CreateNode<ParameterDeclarationClauseAST>();
1712
1713
ParameterDeclarationListAST::Node params;
1714
if (!parseParameterDeclarationList(params)) {
1715
1716
if ((*m_tokenIt) == ')')
1717
goto good;
1718
1719
if ((*m_tokenIt) == Token_ellipsis && lex->lookAhead(m_tokenIt, 1) == ')') {
1720
AST::Node ellipsis = ast_from_token(m_tokenIt);
1721
ast->setEllipsis(ellipsis);
1722
++m_tokenIt;
1723
goto good;
1724
}
1725
return false;
1726
}
1727
1728
if ((*m_tokenIt) == Token_ellipsis) {
1729
AST::Node ellipsis = ast_from_token(m_tokenIt);
1730
ast->setEllipsis(ellipsis);
1731
++m_tokenIt;
1732
}
1733
1734
good:
1735
ast->setParameterDeclarationList(params);
1736
1737
/// @todo add ellipsis
1738
update_pos(ast, start, m_tokenIt);
1739
node = ast;
1740
1741
return true;
1742
}
1743
1744
bool Parser::parseParameterDeclarationList(ParameterDeclarationListAST::Node& node)
1745
{
1746
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseParameterDeclarationList()";
1747
1748
TokenIterator start = m_tokenIt;
1749
1750
ParameterDeclarationListAST::Node ast = CreateNode<ParameterDeclarationListAST>();
1751
1752
ParameterDeclarationAST::Node param;
1753
if (!parseParameterDeclaration(param)) {
1754
m_tokenIt = start;
1755
return false;
1756
}
1757
ast->addParameter(param);
1758
1759
QString comment;
1760
while ((*m_tokenIt) == ',') {
1761
comment.clear();
1762
advanceAndCheckTrailingComment(comment);
1763
1764
if ((*m_tokenIt) == Token_ellipsis)
1765
break;
1766
1767
if (!parseParameterDeclaration(param)) {
1768
m_tokenIt = start;
1769
return false;
1770
}
1771
if (!comment.isEmpty())
1772
param->setComment(comment);
1773
ast->addParameter(param);
1774
}
1775
1776
update_pos(ast, start, m_tokenIt);
1777
node = ast;
1778
1779
return true;
1780
}
1781
1782
bool Parser::parseParameterDeclaration(ParameterDeclarationAST::Node& node)
1783
{
1784
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseParameterDeclaration()";
1785
1786
TokenIterator start = m_tokenIt;
1787
1788
// parse decl spec
1789
TypeSpecifierAST::Node spec;
1790
if (!parseTypeSpecifier(spec)) {
1791
m_tokenIt = start;
1792
return false;
1793
}
1794
1795
TokenIterator index = m_tokenIt;
1796
1797
DeclaratorAST::Node decl;
1798
if (!parseDeclarator(decl)) {
1799
m_tokenIt = index;
1800
1801
// try with abstract declarator
1802
if (!parseAbstractDeclarator(decl))
1803
return false;
1804
}
1805
1806
AST::Node expr;
1807
if ((*m_tokenIt) == '=') {
1808
++m_tokenIt;
1809
if (!parseLogicalOrExpression(expr, true)) {
1810
//reportError(i18n("Expression expected"));
1811
}
1812
}
1813
1814
ParameterDeclarationAST::Node ast = CreateNode<ParameterDeclarationAST>();
1815
ast->setTypeSpec(spec);
1816
ast->setDeclarator(decl);
1817
ast->setExpression(expr);
1818
1819
update_pos(ast, start, m_tokenIt);
1820
node = ast;
1821
1822
return true;
1823
}
1824
1825
bool Parser::parseClassSpecifier(TypeSpecifierAST::Node& node)
1826
{
1827
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseClassSpecifier()";
1828
1829
TokenIterator start = m_tokenIt;
1830
1831
AST::Node classKey;
1832
TokenIterator classKeyStart = m_tokenIt;
1833
1834
int kind = (*m_tokenIt);
1835
if (kind == Token_class || kind == Token_struct || kind == Token_union) {
1836
AST::Node asn = CreateNode<AST>();
1837
classKey = asn;
1838
++m_tokenIt;
1839
update_pos(classKey, classKeyStart, m_tokenIt);
1840
} else {
1841
return false;
1842
}
1843
1844
GroupAST::Node winDeclSpec;
1845
parseWinDeclSpec(winDeclSpec);
1846
1847
while ((*m_tokenIt) == Token_identifier && lex->lookAhead(m_tokenIt, 1) == Token_identifier)
1848
++m_tokenIt;
1849
1850
NameAST::Node name;
1851
parseName(name);
1852
1853
BaseClauseAST::Node bases;
1854
if ((*m_tokenIt) == ':') {
1855
if (!parseBaseClause(bases)) {
1856
skipUntil('{');
1857
}
1858
}
1859
1860
QString comment;
1861
while ((*m_tokenIt) == Token_comment) {
1862
comment += (*m_tokenIt).text();
1863
++m_tokenIt;
1864
}
1865
if ((*m_tokenIt) != '{') {
1866
m_tokenIt = start;
1867
return false;
1868
}
1869
1870
if (!advance('{', "{"))
1871
return false;
1872
1873
ClassSpecifierAST::Node ast = CreateNode<ClassSpecifierAST>();
1874
ast->setWinDeclSpec(winDeclSpec);
1875
ast->setClassKey(classKey);
1876
ast->setName(name);
1877
ast->setBaseClause(bases);
1878
1879
while (!(*m_tokenIt).isNull()) {
1880
if ((*m_tokenIt) == '}')
1881
break;
1882
1883
DeclarationAST::Node memSpec = CreateNode<DeclarationAST>();
1884
TokenIterator startDecl = m_tokenIt;
1885
if (!parseMemberSpecification(memSpec)) {
1886
if (startDecl == m_tokenIt)
1887
++m_tokenIt; // skip at least one token
1888
skipUntilDeclaration();
1889
} else
1890
ast->addDeclaration(memSpec);
1891
}
1892
1893
if ((*m_tokenIt) != '}') {
1894
reportError(i18n("} missing"));
1895
} else
1896
++m_tokenIt;
1897
1898
update_pos(ast, start, m_tokenIt);
1899
node = ast;
1900
1901
return true;
1902
}
1903
1904
bool Parser::parseAccessSpecifier(AST::Node& node)
1905
{
1906
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseAccessSpecifier()";
1907
1908
TokenIterator start = m_tokenIt;
1909
1910
switch ((*m_tokenIt)) {
1911
case Token_public:
1912
case Token_protected:
1913
case Token_private: {
1914
AST::Node asn = CreateNode<AST>();
1915
node = asn;
1916
++m_tokenIt;
1917
update_pos(node, start, m_tokenIt);
1918
return true;
1919
}
1920
}
1921
1922
return false;
1923
}
1924
1925
void Parser::advanceAndCheckTrailingComment(QString& comment)
1926
{
1927
Token t = *m_tokenIt;
1928
int previousTokenEndLine = t.getEndPosition().line;
1929
++m_tokenIt;
1930
if ((*m_tokenIt) != Token_comment)
1931
return;
1932
t = *m_tokenIt;
1933
int commentStartLine = t.getStartPosition().line;
1934
if (commentStartLine != previousTokenEndLine)
1935
return;
1936
comment += (*m_tokenIt).text();
1937
++m_tokenIt;
1938
}
1939
1940
void Parser::advance_nr(int tk, char const* descr)
1941
{
1942
const Token& token = (*m_tokenIt);
1943
if (token != tk) {
1944
reportError(i18n("'%1' expected found '%2'", QString(descr),
1945
token.text()));
1946
} else
1947
++m_tokenIt;
1948
}
1949
1950
AST::Node Parser::ast_from_token(TokenIterator tk) const
1951
{
1952
AST::Node node = CreateNode<AST>();
1953
TokenIterator l_tmp = tk;
1954
++l_tmp;
1955
update_pos(node, tk, l_tmp);
1956
return node;
1957
}
1958
1959
bool Parser::parseMemberSpecification(DeclarationAST::Node& node)
1960
{
1961
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseMemberSpecification()";
1962
1963
QString comment;
1964
while ((*m_tokenIt) == Token_comment) {
1965
comment += (*m_tokenIt).text();
1966
++m_tokenIt;
1967
}
1968
if ((*m_tokenIt).isNull())
1969
return false;
1970
1971
TokenIterator start = m_tokenIt;
1972
1973
AST::Node access;
1974
1975
if ((*m_tokenIt) == ';') {
1976
advanceAndCheckTrailingComment(comment);
1977
if (!comment.isEmpty())
1978
node->setComment(comment);
1979
return true;
1980
} else if ((*m_tokenIt) == Token_Q_OBJECT || (*m_tokenIt) == Token_K_DCOP) {
1981
++m_tokenIt;
1982
return true;
1983
} else if ((*m_tokenIt) == Token_signals || (*m_tokenIt) == Token_k_dcop || (*m_tokenIt) == Token_k_dcop_signals) {
1984
AccessDeclarationAST::Node ast = CreateNode<AccessDeclarationAST>();
1985
++m_tokenIt;
1986
AST::Node n = CreateNode<AST>();
1987
update_pos(n, start, m_tokenIt);
1988
ast->addAccess(n);
1989
if (!advance(':', ":"))
1990
return false;
1991
update_pos(ast, start, m_tokenIt);
1992
node = ast;
1993
return true;
1994
} else if (parseTypedef(node)) {
1995
return true;
1996
} else if (parseUsing(node)) {
1997
return true;
1998
} else if (parseTemplateDeclaration(node)) {
1999
return true;
2000
} else if (parseAccessSpecifier(access)) {
2001
AccessDeclarationAST::Node ast = CreateNode<AccessDeclarationAST>();
2002
ast->addAccess(access);
2003
2004
TokenIterator startSlot = m_tokenIt;
2005
if ((*m_tokenIt) == Token_slots) {
2006
++m_tokenIt;
2007
AST::Node sl = CreateNode<AST>();
2008
update_pos(sl, startSlot, m_tokenIt);
2009
ast->addAccess(sl);
2010
}
2011
if (!advance(':', ":"))
2012
return false;
2013
update_pos(ast, start, m_tokenIt);
2014
node = ast;
2015
return true;
2016
}
2017
2018
m_tokenIt = start;
2019
2020
GroupAST::Node storageSpec;
2021
parseStorageClassSpecifier(storageSpec);
2022
2023
GroupAST::Node cv;
2024
parseCvQualify(cv);
2025
2026
TypeSpecifierAST::Node spec;
2027
if (parseEnumSpecifier(spec) || parseClassSpecifier(spec)) {
2028
spec->setCvQualify(cv);
2029
2030
GroupAST::Node cv2;
2031
parseCvQualify(cv2);
2032
spec->setCv2Qualify(cv2);
2033
2034
InitDeclaratorListAST::Node declarators;
2035
parseInitDeclaratorList(declarators);
2036
if (!advance(';', ";"))
2037
return false;
2038
2039
if (!comment.isEmpty()) {
2040
//uDebug() << "Parser::parseMemberSpecification(spec): comment is " << comment;
2041
spec->setComment(comment);
2042
}
2043
2044
SimpleDeclarationAST::Node ast = CreateNode<SimpleDeclarationAST>();
2045
ast->setTypeSpec(spec);
2046
ast->setInitDeclaratorList(declarators);
2047
update_pos(ast, start, m_tokenIt);
2048
node = ast;
2049
2050
return true;
2051
}
2052
2053
m_tokenIt = start;
2054
2055
bool success = parseDeclarationInternal(node, comment);
2056
if (success && !comment.isEmpty()) {
2057
node->setComment(comment);
2058
//uDebug() << "Parser::parseMemberSpecification(): comment is " << comment;
2059
}
2060
return success;
2061
}
2062
2063
bool Parser::parseCtorInitializer(AST::Node& /*node*/)
2064
{
2065
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseCtorInitializer()";
2066
2067
if ((*m_tokenIt) != ':') {
2068
return false;
2069
}
2070
++m_tokenIt;
2071
2072
AST::Node inits;
2073
if (!parseMemInitializerList(inits)) {
2074
reportError(i18n("Member initializers expected"));
2075
}
2076
2077
return true;
2078
}
2079
2080
bool Parser::parseElaboratedTypeSpecifier(TypeSpecifierAST::Node& node)
2081
{
2082
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseElaboratedTypeSpecifier()";
2083
2084
TokenIterator start = m_tokenIt;
2085
2086
int tk = (*m_tokenIt);
2087
if (tk == Token_class ||
2088
tk == Token_struct ||
2089
tk == Token_union ||
2090
tk == Token_enum ||
2091
tk == Token_typename) {
2092
AST::Node kind = CreateNode<AST>();
2093
++m_tokenIt;
2094
update_pos(kind, start, m_tokenIt);
2095
2096
NameAST::Node name;
2097
2098
if (parseName(name)) {
2099
ElaboratedTypeSpecifierAST::Node ast = CreateNode<ElaboratedTypeSpecifierAST>();
2100
ast->setKind(kind);
2101
ast->setName(name);
2102
update_pos(ast, start, m_tokenIt);
2103
node = ast;
2104
2105
return true;
2106
}
2107
}
2108
2109
m_tokenIt = start;
2110
return false;
2111
}
2112
2113
bool Parser::parseDeclaratorId(NameAST::Node& node)
2114
{
2115
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseDeclaratorId()";
2116
return parseName(node);
2117
}
2118
2119
bool Parser::parseExceptionSpecification(GroupAST::Node& node)
2120
{
2121
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseExceptionSpecification()";
2122
2123
if ((*m_tokenIt) != Token_throw) {
2124
return false;
2125
}
2126
++m_tokenIt;
2127
2128
if (!advance('(', "("))
2129
return false;
2130
if ((*m_tokenIt) == Token_ellipsis) {
2131
// extension found in MSVC++ 7.x headers
2132
TokenIterator start = m_tokenIt;
2133
GroupAST::Node ast = CreateNode<GroupAST>();
2134
AST::Node ellipsis = ast_from_token(m_tokenIt);
2135
ast->addNode(ellipsis);
2136
++m_tokenIt;
2137
update_pos(ast, start, m_tokenIt);
2138
node = ast;
2139
} else {
2140
parseTypeIdList(node);
2141
}
2142
if (!advance(')', ")"))
2143
return false;
2144
2145
return true;
2146
}
2147
2148
bool Parser::parseEnumerator(EnumeratorAST::Node& node)
2149
{
2150
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseEnumerator()";
2151
2152
QString comment;
2153
while ((*m_tokenIt) == Token_comment) {
2154
comment += (*m_tokenIt).text();
2155
++m_tokenIt;
2156
}
2157
if ((*m_tokenIt).isNull())
2158
return false;
2159
2160
TokenIterator start = m_tokenIt;
2161
2162
if ((*m_tokenIt) != Token_identifier) {
2163
return false;
2164
}
2165
++m_tokenIt;
2166
2167
EnumeratorAST::Node ena = CreateNode<EnumeratorAST>();
2168
node = ena;
2169
2170
AST::Node id = CreateNode<AST>();
2171
update_pos(id, start, m_tokenIt);
2172
node->setId(id);
2173
2174
if ((*m_tokenIt) == '=') {
2175
++m_tokenIt;
2176
2177
AST::Node expr;
2178
if (!parseConstantExpression(expr)) {
2179
reportError(i18n("Constant expression expected"));
2180
}
2181
node->setExpr(expr);
2182
}
2183
2184
update_pos(node, start, m_tokenIt);
2185
2186
return true;
2187
}
2188
2189
bool Parser::parseInitDeclarator(InitDeclaratorAST::Node& node)
2190
{
2191
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseInitDeclarator()";
2192
2193
TokenIterator start = m_tokenIt;
2194
2195
DeclaratorAST::Node decl;
2196
AST::Node init;
2197
if (!parseDeclarator(decl)) {
2198
return false;
2199
}
2200
2201
parseInitializer(init);
2202
2203
InitDeclaratorAST::Node ast = CreateNode<InitDeclaratorAST>();
2204
ast->setDeclarator(decl);
2205
ast->setInitializer(init);
2206
update_pos(ast, start, m_tokenIt);
2207
node = ast;
2208
2209
return true;
2210
}
2211
2212
2213
2214
bool Parser::parseBaseClause(BaseClauseAST::Node& node)
2215
{
2216
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseBaseClause()";
2217
2218
TokenIterator start = m_tokenIt;
2219
if ((*m_tokenIt) != ':') {
2220
return false;
2221
}
2222
++m_tokenIt;
2223
2224
BaseClauseAST::Node bca = CreateNode<BaseClauseAST>();
2225
2226
BaseSpecifierAST::Node baseSpec;
2227
if (parseBaseSpecifier(baseSpec)) {
2228
bca->addBaseSpecifier(baseSpec);
2229
2230
QString comment;
2231
while ((*m_tokenIt) == ',') {
2232
comment.clear();
2233
advanceAndCheckTrailingComment(comment);
2234
2235
if (!parseBaseSpecifier(baseSpec)) {
2236
reportError(i18n("Base class specifier expected"));
2237
return false;
2238
}
2239
if (!comment.isEmpty())
2240
baseSpec->setComment(comment);
2241
bca->addBaseSpecifier(baseSpec);
2242
}
2243
} else
2244
return false;
2245
2246
update_pos(bca, start, m_tokenIt);
2247
node = bca;
2248
2249
return true;
2250
}
2251
2252
bool Parser::parseInitializer(AST::Node& node)
2253
{
2254
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseInitializer()";
2255
2256
if ((*m_tokenIt) == '=') {
2257
++m_tokenIt;
2258
2259
AST::Node init;
2260
if (!parseInitializerClause(node)) {
2261
reportError(i18n("Initializer clause expected"));
2262
return false;
2263
}
2264
} else if ((*m_tokenIt) == '(') {
2265
++m_tokenIt;
2266
AST::Node expr;
2267
skipCommaExpression(expr);
2268
2269
if (!advance(')', ")"))
2270
return false;
2271
}
2272
2273
return false;
2274
}
2275
2276
bool Parser::parseMemInitializerList(AST::Node& /*node*/)
2277
{
2278
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseMemInitializerList()";
2279
2280
AST::Node init;
2281
if (!parseMemInitializer(init)) {
2282
return false;
2283
}
2284
2285
QString comment;
2286
while ((*m_tokenIt) == ',') {
2287
comment.clear();
2288
advanceAndCheckTrailingComment(comment);
2289
2290
if (parseMemInitializer(init)) {
2291
} else {
2292
break;
2293
}
2294
}
2295
2296
return true;
2297
}
2298
2299
bool Parser::parseMemInitializer(AST::Node& /*node*/)
2300
{
2301
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseMemInitializer()";
2302
2303
NameAST::Node initId;
2304
if (!parseMemInitializerId(initId)) {
2305
reportError(i18n("Identifier expected"));
2306
return false;
2307
}
2308
if (!advance('(', "("))
2309
return false;
2310
AST::Node expr;
2311
skipCommaExpression(expr);
2312
if (!advance(')', ")"))
2313
return false;
2314
2315
return true;
2316
}
2317
2318
bool Parser::parseTypeIdList(GroupAST::Node& node)
2319
{
2320
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseTypeIdList()";
2321
2322
TokenIterator start = m_tokenIt;
2323
2324
AST::Node typeId;
2325
if (!parseTypeId(typeId)) {
2326
return false;
2327
}
2328
2329
GroupAST::Node ast = CreateNode<GroupAST>();
2330
ast->addNode(typeId);
2331
2332
QString comment;
2333
while ((*m_tokenIt) == ',') {
2334
comment.clear();
2335
advanceAndCheckTrailingComment(comment);
2336
if (parseTypeId(typeId)) {
2337
if (!comment.isEmpty())
2338
typeId->setComment(comment);
2339
ast->addNode(typeId);
2340
} else {
2341
reportError(i18n("Type id expected"));
2342
break;
2343
}
2344
}
2345
2346
update_pos(ast, start, m_tokenIt);
2347
node = ast;
2348
return true;
2349
}
2350
2351
bool Parser::parseBaseSpecifier(BaseSpecifierAST::Node& node)
2352
{
2353
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseBaseSpecifier()";
2354
2355
TokenIterator start = m_tokenIt;
2356
BaseSpecifierAST::Node ast = CreateNode<BaseSpecifierAST>();
2357
2358
AST::Node access;
2359
if ((*m_tokenIt) == Token_virtual) {
2360
AST::Node virt = ast_from_token(m_tokenIt);
2361
ast->setIsVirtual(virt);
2362
2363
++m_tokenIt;
2364
2365
parseAccessSpecifier(access);
2366
} else {
2367
parseAccessSpecifier(access);
2368
2369
if ((*m_tokenIt) == Token_virtual) {
2370
AST::Node virt = ast_from_token(m_tokenIt);
2371
ast->setIsVirtual(virt);
2372
++m_tokenIt;
2373
}
2374
}
2375
2376
NameAST::Node name;
2377
if (!parseName(name)) {
2378
reportError(i18n("Class name expected"));
2379
}
2380
2381
ast->setAccess(access);
2382
ast->setName(name);
2383
update_pos(ast, start, m_tokenIt);
2384
node = ast;
2385
2386
return true;
2387
}
2388
2389
2390
bool Parser::parseInitializerClause(AST::Node& node)
2391
{
2392
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseInitializerClause()";
2393
2394
if ((*m_tokenIt) == '{') {
2395
if (!skip('{', '}')) {
2396
reportError(i18n("} missing"));
2397
} else
2398
++m_tokenIt;
2399
} else {
2400
if (!parseAssignmentExpression(node)) {
2401
//reportError(i18n("Expression expected"));
2402
}
2403
}
2404
2405
return true;
2406
}
2407
2408
bool Parser::parseMemInitializerId(NameAST::Node& node)
2409
{
2410
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseMemInitializerId()";
2411
2412
return parseName(node);
2413
}
2414
2415
bool Parser::parsePtrToMember(AST::Node& /*node*/)
2416
{
2417
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parsePtrToMember()";
2418
2419
if ((*m_tokenIt) == Token_scope) {
2420
++m_tokenIt;
2421
}
2422
2423
while ((*m_tokenIt) == Token_identifier) {
2424
++m_tokenIt;
2425
2426
if ((*m_tokenIt) == Token_scope && lex->lookAhead(m_tokenIt, 1) == '*') {
2427
++m_tokenIt; // skip ::
2428
++m_tokenIt; // skip *
2429
return true;
2430
} else
2431
break;
2432
}
2433
2434
return false;
2435
}
2436
2437
bool Parser::parseUnqualifiedName(ClassOrNamespaceNameAST::Node& node)
2438
{
2439
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseUnqualifiedName()";
2440
2441
TokenIterator start = m_tokenIt;
2442
bool isDestructor = false;
2443
2444
ClassOrNamespaceNameAST::Node ast = CreateNode<ClassOrNamespaceNameAST>();
2445
2446
if ((*m_tokenIt) == Token_identifier) {
2447
TokenIterator startName = m_tokenIt;
2448
AST::Node n = CreateNode<AST>();
2449
++m_tokenIt;
2450
update_pos(n, startName, m_tokenIt);
2451
ast->setName(n);
2452
} else if ((*m_tokenIt) == '~' && lex->lookAhead(m_tokenIt, 1) == Token_identifier) {
2453
TokenIterator startName = m_tokenIt;
2454
AST::Node n = CreateNode<AST>();
2455
++m_tokenIt; // skip ~
2456
++m_tokenIt; // skip classname
2457
update_pos(n, startName, m_tokenIt);
2458
ast->setName(n);
2459
isDestructor = true;
2460
} else if ((*m_tokenIt) == Token_operator) {
2461
AST::Node n;
2462
if (!parseOperatorFunctionId(n))
2463
return false;
2464
ast->setName(n);
2465
} else {
2466
return false;
2467
}
2468
2469
if (!isDestructor) {
2470
2471
TokenIterator index = m_tokenIt;
2472
2473
if ((*m_tokenIt) == '<') {
2474
++m_tokenIt;
2475
2476
// optional template arguments
2477
TemplateArgumentListAST::Node args;
2478
parseTemplateArgumentList(args);
2479
2480
if ((*m_tokenIt) != '>') {
2481
m_tokenIt = index;
2482
} else {
2483
++m_tokenIt;
2484
ast->setTemplateArgumentList(args);
2485
}
2486
}
2487
}
2488
2489
update_pos(ast, start, m_tokenIt);
2490
node = ast;
2491
2492
return true;
2493
}
2494
2495
bool Parser::parseStringLiteral(AST::Node& /*node*/)
2496
{
2497
while (!(*m_tokenIt).isNull()) {
2498
if ((*m_tokenIt) == Token_identifier &&
2499
(*m_tokenIt).text() == "L" && lex->lookAhead(m_tokenIt, 1) == Token_string_literal) {
2500
2501
++m_tokenIt;
2502
++m_tokenIt;
2503
} else if ((*m_tokenIt) == Token_string_literal) {
2504
++m_tokenIt;
2505
} else
2506
return false;
2507
}
2508
return true;
2509
}
2510
2511
bool Parser::skipExpressionStatement(StatementAST::Node& node)
2512
{
2513
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::skipExpressionStatement()";
2514
2515
TokenIterator start = m_tokenIt;
2516
2517
AST::Node expr;
2518
skipCommaExpression(expr);
2519
2520
if (!advance(';', ";"))
2521
return false;
2522
2523
ExpressionStatementAST::Node ast = CreateNode<ExpressionStatementAST>();
2524
ast->setExpression(expr);
2525
update_pos(ast, start, m_tokenIt);
2526
node = ast;
2527
2528
return true;
2529
}
2530
2531
bool Parser::parseStatement(StatementAST::Node& node) // thanks to fiore@8080.it ;)
2532
{
2533
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseStatement()";
2534
switch ((*m_tokenIt)) {
2535
2536
case Token_while:
2537
return parseWhileStatement(node);
2538
2539
case Token_do:
2540
return parseDoStatement(node);
2541
2542
case Token_for:
2543
return parseForStatement(node);
2544
2545
case Token_if:
2546
return parseIfStatement(node);
2547
2548
case Token_switch:
2549
return parseSwitchStatement(node);
2550
2551
case Token_try:
2552
return parseTryBlockStatement(node);
2553
2554
case Token_case:
2555
case Token_default:
2556
return parseLabeledStatement(node);
2557
2558
case Token_break:
2559
case Token_continue:
2560
++m_tokenIt;
2561
if (!advance(';', ";"))
2562
return false;
2563
return true;
2564
2565
case Token_goto:
2566
++m_tokenIt;
2567
if (!advance(Token_identifier, "identifier"))
2568
return false;
2569
if (!advance(';', ";"))
2570
return false;
2571
return true;
2572
2573
case Token_return: {
2574
++m_tokenIt;
2575
AST::Node expr;
2576
skipCommaExpression(expr);
2577
if (!advance(';', ";"))
2578
return false;
2579
}
2580
return true;
2581
2582
case '{':
2583
return parseCompoundStatement(node);
2584
2585
case Token_identifier:
2586
if (parseLabeledStatement(node))
2587
return true;
2588
break;
2589
}
2590
2591
//uDebug() << "------------> try with declaration statement";
2592
if (parseDeclarationStatement(node))
2593
return true;
2594
2595
return skipExpressionStatement(node);
2596
}
2597
2598
bool Parser::parseCondition(ConditionAST::Node& node)
2599
{
2600
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseCondition()";
2601
2602
TokenIterator start = m_tokenIt;
2603
2604
ConditionAST::Node ast = CreateNode<ConditionAST>();
2605
2606
TypeSpecifierAST::Node spec;
2607
if (parseTypeSpecifier(spec)) {
2608
DeclaratorAST::Node decl;
2609
if (parseDeclarator(decl) && (*m_tokenIt) == '=') {
2610
++m_tokenIt;
2611
2612
AST::Node expr;
2613
if (skipExpression(expr)) {
2614
ast->setTypeSpec(spec);
2615
ast->setDeclarator(decl);
2616
ast->setExpression(expr);
2617
2618
update_pos(ast, start, m_tokenIt);
2619
node = ast;
2620
2621
return true;
2622
}
2623
}
2624
}
2625
2626
m_tokenIt = start;
2627
2628
AST::Node expr;
2629
if (!skipCommaExpression(expr))
2630
return false;
2631
2632
ast->setExpression(expr);
2633
update_pos(ast, start, m_tokenIt);
2634
node = ast;
2635
return true;
2636
}
2637
2638
2639
bool Parser::parseWhileStatement(StatementAST::Node& node)
2640
{
2641
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseWhileStatement()";
2642
TokenIterator start = m_tokenIt;
2643
2644
if (!advance(Token_while, "while"))
2645
return false;
2646
if (!advance('(', "("))
2647
return false;
2648
2649
ConditionAST::Node cond;
2650
if (!parseCondition(cond)) {
2651
reportError(i18n("condition expected"));
2652
return false;
2653
}
2654
if (!advance(')', ")"))
2655
return false;
2656
2657
StatementAST::Node body;
2658
if (!parseStatement(body)) {
2659
reportError(i18n("statement expected"));
2660
return false;
2661
}
2662
2663
WhileStatementAST::Node ast = CreateNode<WhileStatementAST>();
2664
ast->setCondition(cond);
2665
ast->setStatement(body);
2666
update_pos(ast, start, m_tokenIt);
2667
node = ast;
2668
2669
return true;
2670
}
2671
2672
bool Parser::parseDoStatement(StatementAST::Node& node)
2673
{
2674
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseDoStatement()";
2675
TokenIterator start = m_tokenIt;
2676
2677
if (!advance(Token_do, "do"))
2678
return false;
2679
2680
StatementAST::Node body;
2681
if (!parseStatement(body)) {
2682
reportError(i18n("statement expected"));
2683
//return false;
2684
}
2685
2686
advance_nr(Token_while, "while");
2687
advance_nr('(', "(");
2688
2689
AST::Node expr;
2690
if (!skipCommaExpression(expr)) {
2691
reportError(i18n("expression expected"));
2692
//return false;
2693
}
2694
2695
advance_nr(')', ")");
2696
advance_nr(';', ";");
2697
2698
DoStatementAST::Node ast = CreateNode<DoStatementAST>();
2699
ast->setStatement(body);
2700
//ast->setCondition(condition);
2701
update_pos(ast, start, m_tokenIt);
2702
node = ast;
2703
2704
return true;
2705
}
2706
2707
bool Parser::parseForStatement(StatementAST::Node& node)
2708
{
2709
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseForStatement()";
2710
TokenIterator start = m_tokenIt;
2711
2712
if (!advance(Token_for, "for"))
2713
return false;
2714
if (!advance('(', "("))
2715
return false;
2716
2717
StatementAST::Node init;
2718
if (!parseForInitStatement(init)) {
2719
reportError(i18n("for initialization expected"));
2720
return false;
2721
}
2722
2723
ConditionAST::Node cond;
2724
parseCondition(cond);
2725
if (!advance(';', ";"))
2726
return false;
2727
2728
AST::Node expr;
2729
skipCommaExpression(expr);
2730
if (!advance(')', ")"))
2731
return false;
2732
2733
StatementAST::Node body;
2734
if (!parseStatement(body))
2735
return false;
2736
2737
ForStatementAST::Node ast = CreateNode<ForStatementAST>();
2738
ast->setInitStatement(init);
2739
ast->setCondition(cond);
2740
// ast->setExpression(expression);
2741
ast->setStatement(body);
2742
update_pos(ast, start, m_tokenIt);
2743
node = ast;
2744
2745
return true;
2746
}
2747
2748
bool Parser::parseForInitStatement(StatementAST::Node& node)
2749
{
2750
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseForInitStatement()";
2751
2752
if (parseDeclarationStatement(node))
2753
return true;
2754
2755
return skipExpressionStatement(node);
2756
}
2757
2758
bool Parser::parseCompoundStatement(StatementAST::Node& node)
2759
{
2760
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseCompoundStatement()";
2761
TokenIterator start = m_tokenIt;
2762
2763
if ((*m_tokenIt) != '{') {
2764
return false;
2765
}
2766
++m_tokenIt;
2767
2768
StatementListAST::Node ast = CreateNode<StatementListAST>();
2769
2770
while (!(*m_tokenIt).isNull()) {
2771
if ((*m_tokenIt) == '}')
2772
break;
2773
2774
StatementAST::Node stmt;
2775
TokenIterator startStmt = m_tokenIt;
2776
if (!parseStatement(stmt)) {
2777
if (startStmt == m_tokenIt)
2778
++m_tokenIt;
2779
skipUntilStatement();
2780
} else {
2781
ast->addStatement(stmt);
2782
}
2783
}
2784
2785
if ((*m_tokenIt) != '}') {
2786
reportError(i18n("} expected"));
2787
} else {
2788
++m_tokenIt;
2789
}
2790
2791
update_pos(ast, start, m_tokenIt);
2792
node = ast;
2793
2794
return true;
2795
}
2796
2797
bool Parser::parseIfStatement(StatementAST::Node& node)
2798
{
2799
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseIfStatement()";
2800
2801
TokenIterator start = m_tokenIt;
2802
2803
if (!advance(Token_if, "if"))
2804
return false;
2805
2806
if (!advance('(', "("))
2807
return false;
2808
2809
IfStatementAST::Node ast = CreateNode<IfStatementAST>();
2810
2811
ConditionAST::Node cond;
2812
if (!parseCondition(cond)) {
2813
reportError(i18n("condition expected"));
2814
return false;
2815
}
2816
if (!advance(')', ")"))
2817
return false;
2818
2819
StatementAST::Node stmt;
2820
if (!parseStatement(stmt)) {
2821
reportError(i18n("statement expected"));
2822
return false;
2823
}
2824
2825
ast->setCondition(cond);
2826
ast->setStatement(stmt);
2827
2828
if ((*m_tokenIt) == Token_else) {
2829
++m_tokenIt;
2830
StatementAST::Node elseStmt;
2831
if (!parseStatement(elseStmt)) {
2832
reportError(i18n("statement expected"));
2833
return false;
2834
}
2835
ast->setElseStatement(elseStmt);
2836
}
2837
2838
update_pos(ast, start, m_tokenIt);
2839
node = ast;
2840
2841
return true;
2842
}
2843
2844
bool Parser::parseSwitchStatement(StatementAST::Node& node)
2845
{
2846
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseSwitchStatement()";
2847
TokenIterator start = m_tokenIt;
2848
if (!advance(Token_switch, "switch"))
2849
return false;
2850
2851
if (!advance('(', "("))
2852
return false;
2853
2854
ConditionAST::Node cond;
2855
if (!parseCondition(cond)) {
2856
reportError(i18n("condition expected"));
2857
return false;
2858
}
2859
if (!advance(')', ")"))
2860
return false;
2861
2862
StatementAST::Node stmt;
2863
if (!parseCompoundStatement(stmt)) {
2864
syntaxError();
2865
return false;
2866
}
2867
2868
SwitchStatementAST::Node ast = CreateNode<SwitchStatementAST>();
2869
ast->setCondition(cond);
2870
ast->setStatement(stmt);
2871
update_pos(ast, start, m_tokenIt);
2872
node = ast;
2873
2874
return true;
2875
}
2876
2877
bool Parser::parseLabeledStatement(StatementAST::Node& node)
2878
{
2879
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseLabeledStatement()";
2880
switch ((*m_tokenIt)) {
2881
case Token_identifier:
2882
case Token_default:
2883
if (lex->lookAhead(m_tokenIt, 1) == ':') {
2884
++m_tokenIt;
2885
++m_tokenIt;
2886
2887
StatementAST::Node stmt;
2888
if (parseStatement(stmt)) {
2889
node = stmt;
2890
return true;
2891
}
2892
}
2893
break;
2894
2895
case Token_case: {
2896
++m_tokenIt;
2897
AST::Node expr;
2898
if (!parseConstantExpression(expr)) {
2899
reportError(i18n("expression expected"));
2900
} else if ((*m_tokenIt) == Token_ellipsis) {
2901
++m_tokenIt;
2902
2903
AST::Node expr2;
2904
if (!parseConstantExpression(expr2)) {
2905
reportError(i18n("expression expected"));
2906
}
2907
}
2908
if (!advance(':', ":"))
2909
return false;
2910
2911
StatementAST::Node stmt;
2912
if (parseStatement(stmt)) {
2913
node = stmt;
2914
return true;
2915
}
2916
}
2917
break;
2918
2919
}
2920
2921
return false;
2922
}
2923
2924
bool Parser::parseBlockDeclaration(DeclarationAST::Node& node)
2925
{
2926
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseBlockDeclaration()";
2927
switch ((*m_tokenIt)) {
2928
case Token_typedef:
2929
return parseTypedef(node);
2930
case Token_using:
2931
return parseUsing(node);
2932
case Token_asm:
2933
return parseAsmDefinition(node);
2934
case Token_namespace:
2935
return parseNamespaceAliasDefinition(node);
2936
}
2937
2938
TokenIterator start = m_tokenIt;
2939
2940
GroupAST::Node storageSpec;
2941
parseStorageClassSpecifier(storageSpec);
2942
2943
GroupAST::Node cv;
2944
parseCvQualify(cv);
2945
2946
TypeSpecifierAST::Node spec;
2947
if (!parseTypeSpecifierOrClassSpec(spec)) { // replace with simpleTypeSpecifier?!?!
2948
m_tokenIt = start;
2949
return false;
2950
}
2951
spec->setCvQualify(cv);
2952
2953
GroupAST::Node cv2;
2954
parseCvQualify(cv2);
2955
spec->setCv2Qualify(cv2);
2956
2957
InitDeclaratorListAST::Node declarators;
2958
parseInitDeclaratorList(declarators);
2959
2960
if ((*m_tokenIt) != ';') {
2961
m_tokenIt = start;
2962
return false;
2963
}
2964
++m_tokenIt;
2965
2966
SimpleDeclarationAST::Node ast = CreateNode<SimpleDeclarationAST>();
2967
ast->setTypeSpec(spec);
2968
ast->setInitDeclaratorList(declarators);
2969
update_pos(ast, start, m_tokenIt);
2970
node = ast;
2971
2972
return true;
2973
}
2974
2975
bool Parser::parseNamespaceAliasDefinition(DeclarationAST::Node& /*node*/)
2976
{
2977
if ((*m_tokenIt) != Token_namespace) {
2978
return false;
2979
}
2980
++m_tokenIt;
2981
2982
if (!advance(Token_identifier, "identifier"))
2983
return false;
2984
if (!advance('=', "="))
2985
return false;
2986
2987
NameAST::Node name;
2988
if (!parseName(name)) {
2989
reportError(i18n("Namespace name expected"));
2990
}
2991
2992
if (!advance(';', ";"))
2993
return false;
2994
2995
return true;
2996
2997
}
2998
2999
bool Parser::parseDeclarationStatement(StatementAST::Node& node)
3000
{
3001
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseDeclarationStatement()";
3002
3003
TokenIterator start = m_tokenIt;
3004
3005
DeclarationAST::Node decl;
3006
if (!parseBlockDeclaration(decl)) {
3007
return false;
3008
}
3009
3010
DeclarationStatementAST::Node ast = CreateNode<DeclarationStatementAST>();
3011
ast->setDeclaration(decl);
3012
update_pos(ast, start, m_tokenIt);
3013
node = ast;
3014
3015
//uDebug() << "---------------------> found a block declaration";
3016
return true;
3017
}
3018
3019
bool Parser::parseDeclarationInternal(DeclarationAST::Node& node, QString& comment)
3020
{
3021
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseDeclarationInternal()";
3022
3023
TokenIterator start = m_tokenIt;
3024
3025
// that is for the case '__declspec(dllexport) int ...' or
3026
// '__declspec(dllexport) inline int ...', etc.
3027
GroupAST::Node winDeclSpec;
3028
parseWinDeclSpec(winDeclSpec);
3029
3030
GroupAST::Node funSpec;
3031
bool hasFunSpec = parseFunctionSpecifier(funSpec);
3032
3033
GroupAST::Node storageSpec;
3034
bool hasStorageSpec = parseStorageClassSpecifier(storageSpec);
3035
3036
if (hasStorageSpec && !hasFunSpec)
3037
hasFunSpec = parseFunctionSpecifier(funSpec);
3038
3039
// that is for the case 'friend __declspec(dllexport) ....'
3040
GroupAST::Node winDeclSpec2;
3041
parseWinDeclSpec(winDeclSpec2);
3042
3043
GroupAST::Node cv;
3044
parseCvQualify(cv);
3045
3046
TokenIterator index = m_tokenIt;
3047
NameAST::Node name;
3048
if (parseName(name) && (*m_tokenIt) == '(') {
3049
// no type specifier, maybe a constructor or a cast operator??
3050
3051
m_tokenIt = index;
3052
3053
InitDeclaratorAST::Node declarator;
3054
if (parseInitDeclarator(declarator)) {
3055
TokenIterator endSignature = m_tokenIt;
3056
3057
switch ((*m_tokenIt)) {
3058
case ';': {
3059
++m_tokenIt;
3060
3061
InitDeclaratorListAST::Node declarators = CreateNode<InitDeclaratorListAST>();
3062
3063
// update declarators position
3064
if (declarator.get()) {
3065
declarators->setStartPosition(declarator->getStartPosition());
3066
declarators->setEndPosition(declarator->getEndPosition());
3067
}
3068
declarators->addInitDeclarator(declarator);
3069
3070
SimpleDeclarationAST::Node ast = CreateNode<SimpleDeclarationAST>();
3071
ast->setInitDeclaratorList(declarators);
3072
ast->setText(toString(start, endSignature));
3073
node = ast;
3074
update_pos(node, start, m_tokenIt);
3075
return true;
3076
3077
}
3078
break;
3079
3080
case ':': {
3081
AST::Node ctorInit;
3082
StatementListAST::Node funBody;
3083
if (parseCtorInitializer(ctorInit) && parseFunctionBody(funBody)) {
3084
FunctionDefinitionAST::Node ast = CreateNode<FunctionDefinitionAST>();
3085
ast->setStorageSpecifier(storageSpec);
3086
ast->setFunctionSpecifier(funSpec);
3087
ast->setInitDeclarator(declarator);
3088
ast->setFunctionBody(funBody);
3089
ast->setText(toString(start, endSignature));
3090
node = ast;
3091
update_pos(node, start, m_tokenIt);
3092
return true;
3093
}
3094
}
3095
break;
3096
3097
case '{': {
3098
StatementListAST::Node funBody;
3099
if (parseFunctionBody(funBody)) {
3100
FunctionDefinitionAST::Node ast = CreateNode<FunctionDefinitionAST>();
3101
ast->setStorageSpecifier(storageSpec);
3102
ast->setFunctionSpecifier(funSpec);
3103
ast->setInitDeclarator(declarator);
3104
ast->setText(toString(start, endSignature));
3105
ast->setFunctionBody(funBody);
3106
node = ast;
3107
update_pos(node, start, m_tokenIt);
3108
return true;
3109
}
3110
}
3111
break;
3112
3113
case '(':
3114
case '[':
3115
// ops!! it seems a declarator
3116
goto start_decl;
3117
break;
3118
}
3119
3120
}
3121
3122
syntaxError();
3123
return false;
3124
}
3125
3126
start_decl:
3127
m_tokenIt = index;
3128
3129
if ((*m_tokenIt) == Token_const && lex->lookAhead(m_tokenIt, 1) == Token_identifier && lex->lookAhead(m_tokenIt, 2) == '=') {
3130
// constant definition
3131
++m_tokenIt;
3132
InitDeclaratorListAST::Node declarators;
3133
if (parseInitDeclaratorList(declarators)) {
3134
if (!advance(';', ";"))
3135
return false;
3136
DeclarationAST::Node ast = CreateNode<DeclarationAST>();
3137
node = ast;
3138
update_pos(node, start, m_tokenIt);
3139
return true;
3140
}
3141
syntaxError();
3142
return false;
3143
}
3144
3145
TypeSpecifierAST::Node spec;
3146
if (parseTypeSpecifier(spec)) {
3147
if (!hasFunSpec)
3148
parseFunctionSpecifier(funSpec); // e.g. "void inline"
3149
spec->setCvQualify(cv);
3150
3151
InitDeclaratorListAST::Node declarators;
3152
3153
InitDeclaratorAST::Node decl;
3154
TokenIterator startDeclarator = m_tokenIt;
3155
bool maybeFunctionDefinition = false;
3156
3157
if ((*m_tokenIt) != ';') {
3158
if (parseInitDeclarator(decl) && (*m_tokenIt) == '{') {
3159
// function definition
3160
maybeFunctionDefinition = true;
3161
} else {
3162
m_tokenIt = startDeclarator;
3163
if (!parseInitDeclaratorList(declarators)) {
3164
syntaxError();
3165
return false;
3166
}
3167
}
3168
}
3169
3170
TokenIterator endSignature = m_tokenIt;
3171
switch ((*m_tokenIt)) {
3172
case ';': {
3173
advanceAndCheckTrailingComment(comment);
3174
SimpleDeclarationAST::Node ast = CreateNode<SimpleDeclarationAST>();
3175
ast->setStorageSpecifier(storageSpec);
3176
ast->setFunctionSpecifier(funSpec);
3177
ast->setText(toString(start, endSignature));
3178
ast->setTypeSpec(spec);
3179
ast->setWinDeclSpec(winDeclSpec);
3180
ast->setInitDeclaratorList(declarators);
3181
node = ast;
3182
update_pos(node, start, m_tokenIt);
3183
}
3184
return true;
3185
3186
case '{': {
3187
if (!maybeFunctionDefinition) {
3188
syntaxError();
3189
return false;
3190
}
3191
StatementListAST::Node funBody;
3192
if (parseFunctionBody(funBody)) {
3193
FunctionDefinitionAST::Node ast = CreateNode<FunctionDefinitionAST>();
3194
ast->setWinDeclSpec(winDeclSpec);
3195
ast->setStorageSpecifier(storageSpec);
3196
ast->setFunctionSpecifier(funSpec);
3197
ast->setText(toString(start, endSignature));
3198
ast->setTypeSpec(spec);
3199
ast->setFunctionBody(funBody);
3200
ast->setInitDeclarator(decl);
3201
node = ast;
3202
update_pos(node, start, m_tokenIt);
3203
return true;
3204
}
3205
}
3206
break;
3207
3208
}
3209
}
3210
3211
syntaxError();
3212
return false;
3213
}
3214
3215
bool Parser::parseFunctionBody(StatementListAST::Node& node)
3216
{
3217
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseFunctionBody()";
3218
3219
TokenIterator start = m_tokenIt;
3220
if ((*m_tokenIt) != '{') {
3221
return false;
3222
}
3223
++m_tokenIt;
3224
3225
StatementListAST::Node ast = CreateNode<StatementListAST>();
3226
3227
while (!(*m_tokenIt).isNull()) {
3228
if ((*m_tokenIt) == '}')
3229
break;
3230
3231
StatementAST::Node stmt;
3232
TokenIterator startStmt = m_tokenIt;
3233
if (!parseStatement(stmt)) {
3234
if (startStmt == m_tokenIt)
3235
++m_tokenIt;
3236
skipUntilStatement();
3237
} else
3238
ast->addStatement(stmt);
3239
}
3240
3241
if ((*m_tokenIt) != '}') {
3242
reportError(i18n("} expected"));
3243
} else
3244
++m_tokenIt;
3245
3246
update_pos(ast, start, m_tokenIt);
3247
node = ast;
3248
3249
return true;
3250
}
3251
3252
QString Parser::toString(TokenIterator start, TokenIterator end,
3253
const QString& sep) const
3254
{
3255
QStringList l;
3256
3257
for (; start != end; ++start) {
3258
l << (*start).text();
3259
}
3260
3261
return l.join(sep).trimmed();
3262
}
3263
3264
bool Parser::parseTypeSpecifierOrClassSpec(TypeSpecifierAST::Node& node)
3265
{
3266
if (parseClassSpecifier(node))
3267
return true;
3268
else if (parseEnumSpecifier(node))
3269
return true;
3270
else if (parseTypeSpecifier(node))
3271
return true;
3272
3273
return false;
3274
}
3275
3276
bool Parser::parseTryBlockStatement(StatementAST::Node& node)
3277
{
3278
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseTryBlockStatement()";
3279
3280
if ((*m_tokenIt) != Token_try) {
3281
return false;
3282
}
3283
++m_tokenIt;
3284
3285
StatementAST::Node stmt;
3286
if (!parseCompoundStatement(stmt)) {
3287
syntaxError();
3288
return false;
3289
}
3290
3291
if ((*m_tokenIt) != Token_catch) {
3292
reportError(i18n("catch expected"));
3293
return false;
3294
}
3295
3296
while ((*m_tokenIt) == Token_catch) {
3297
++m_tokenIt;
3298
if (!advance('(', "("))
3299
return false;
3300
ConditionAST::Node cond;
3301
if (!parseCondition(cond)) {
3302
reportError(i18n("condition expected"));
3303
return false;
3304
}
3305
if (!advance(')', ")"))
3306
return false;
3307
3308
StatementAST::Node body;
3309
if (!parseCompoundStatement(body)) {
3310
syntaxError();
3311
return false;
3312
}
3313
}
3314
3315
node = stmt;
3316
return true;
3317
}
3318
3319
bool Parser::parsePrimaryExpression(AST::Node& /*node*/)
3320
{
3321
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parsePrimarExpression()";
3322
3323
3324
switch ((*m_tokenIt)) {
3325
case Token_string_literal: {
3326
AST::Node lit;
3327
parseStringLiteral(lit);
3328
}
3329
return true;
3330
3331
case Token_number_literal:
3332
case Token_char_literal:
3333
case Token_true:
3334
case Token_false:
3335
++m_tokenIt;
3336
return true;
3337
3338
case Token_this:
3339
++m_tokenIt;
3340
return true;
3341
3342
case Token_dynamic_cast:
3343
case Token_static_cast:
3344
case Token_reinterpret_cast:
3345
case Token_const_cast: {
3346
++m_tokenIt;
3347
3348
if (! check('<'))
3349
return false;
3350
AST::Node typeId;
3351
parseTypeId(typeId);
3352
if (! check('>'))
3353
return false;
3354
3355
if (! check('('))
3356
return false;
3357
AST::Node expr;
3358
parseCommaExpression(expr);
3359
if (! check(')'))
3360
return false;
3361
}
3362
return true;
3363
3364
case Token_typeid: {
3365
++m_tokenIt;
3366
if (! check('('))
3367
return false;
3368
AST::Node expr;
3369
parseCommaExpression(expr);
3370
if (! check(')'))
3371
return false;
3372
}
3373
return true;
3374
3375
case '(': {
3376
++m_tokenIt;
3377
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "token = " << (*m_tokenIt).text();
3378
AST::Node expr;
3379
if (!parseExpression(expr)) {
3380
return false;
3381
}
3382
if (! check(')'))
3383
return false;
3384
}
3385
return true;
3386
3387
default: {
3388
TokenIterator start = m_tokenIt;
3389
TypeSpecifierAST::Node typeSpec;
3390
if (parseSimpleTypeSpecifier(typeSpec) && (*m_tokenIt) == '(') {
3391
++m_tokenIt;
3392
AST::Node expr;
3393
parseCommaExpression(expr);
3394
if (! check(')'))
3395
return false;
3396
return true;
3397
}
3398
3399
m_tokenIt = start;
3400
NameAST::Node name;
3401
if (parseName(name))
3402
return true;
3403
}
3404
}
3405
3406
return false;
3407
}
3408
3409
bool Parser::parsePostfixExpression(AST::Node& /*node*/)
3410
{
3411
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parsePostfixExpression()";
3412
3413
AST::Node expr;
3414
if (!parsePrimaryExpression(expr))
3415
return false;
3416
3417
while (true) {
3418
switch ((*m_tokenIt)) {
3419
case '[': {
3420
++m_tokenIt;
3421
AST::Node e;
3422
parseCommaExpression(e);
3423
if (! check(']'))
3424
return false;
3425
}
3426
break;
3427
3428
case '(': {
3429
++m_tokenIt;
3430
AST::Node funArgs;
3431
parseCommaExpression(funArgs);
3432
if (! check(')'))
3433
return false;
3434
}
3435
break;
3436
3437
case Token_incr:
3438
case Token_decr:
3439
++m_tokenIt;
3440
break;
3441
3442
case '.':
3443
case Token_arrow: {
3444
++m_tokenIt;
3445
if ((*m_tokenIt) == Token_template)
3446
++m_tokenIt;
3447
3448
NameAST::Node name;
3449
if (!parseName(name)) {
3450
return false;
3451
}
3452
}
3453
break;
3454
3455
case Token_typename: {
3456
++m_tokenIt;
3457
3458
NameAST::Node name;
3459
if (!parseName(name)) {
3460
return false;
3461
}
3462
3463
if (! check('('))
3464
return false;
3465
AST::Node expr;
3466
parseCommaExpression(expr);
3467
if (! check(')'))
3468
return false;
3469
}
3470
return true;
3471
3472
default:
3473
return true;
3474
3475
} // end switch
3476
3477
} // end while
3478
3479
return true;
3480
}
3481
3482
bool Parser::parseUnaryExpression(AST::Node& node)
3483
{
3484
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseUnaryExpression()";
3485
3486
switch ((*m_tokenIt)) {
3487
case Token_incr:
3488
case Token_decr:
3489
case '*':
3490
case '&':
3491
case '+':
3492
case '-':
3493
case '!':
3494
case '~': {
3495
++m_tokenIt;
3496
AST::Node expr;
3497
return parseCastExpression(expr);
3498
}
3499
3500
case Token_sizeof: {
3501
++m_tokenIt;
3502
TokenIterator index = m_tokenIt;
3503
if ((*m_tokenIt) == '(') {
3504
++m_tokenIt;
3505
AST::Node typeId;
3506
if (parseTypeId(typeId) && (*m_tokenIt) == ')') {
3507
++m_tokenIt;
3508
return true;
3509
}
3510
m_tokenIt = index;
3511
}
3512
AST::Node expr;
3513
return parseUnaryExpression(expr);
3514
}
3515
3516
case Token_new:
3517
return parseNewExpression(node);
3518
3519
case Token_delete:
3520
return parseDeleteExpression(node);
3521
}
3522
3523
return parsePostfixExpression(node);
3524
}
3525
3526
bool Parser::parseNewExpression(AST::Node& /*node*/)
3527
{
3528
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseNewExpression()";
3529
if ((*m_tokenIt) == Token_scope && lex->lookAhead(m_tokenIt, 1) == Token_new)
3530
++m_tokenIt;
3531
3532
if (! check(Token_new))
3533
return false;
3534
3535
if ((*m_tokenIt) == '(') {
3536
++m_tokenIt;
3537
AST::Node expr;
3538
parseCommaExpression(expr);
3539
if (! check(')'))
3540
return false;
3541
}
3542
3543
if ((*m_tokenIt) == '(') {
3544
++m_tokenIt;
3545
AST::Node typeId;
3546
parseTypeId(typeId);
3547
if (! check(')'))
3548
return false;
3549
} else {
3550
AST::Node typeId;
3551
parseNewTypeId(typeId);
3552
}
3553
3554
AST::Node init;
3555
parseNewInitializer(init);
3556
return true;
3557
}
3558
3559
bool Parser::parseNewTypeId(AST::Node& /*node*/)
3560
{
3561
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseNewTypeId()";
3562
TypeSpecifierAST::Node typeSpec;
3563
if (parseTypeSpecifier(typeSpec)) {
3564
AST::Node declarator;
3565
parseNewDeclarator(declarator);
3566
return true;
3567
}
3568
3569
return false;
3570
}
3571
3572
bool Parser::parseNewDeclarator(AST::Node& /*node*/)
3573
{
3574
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseNewDeclarator()";
3575
AST::Node ptrOp;
3576
if (parsePtrOperator(ptrOp)) {
3577
AST::Node declarator;
3578
parseNewDeclarator(declarator);
3579
return true;
3580
}
3581
3582
if ((*m_tokenIt) == '[') {
3583
while ((*m_tokenIt) == '[') {
3584
++m_tokenIt;
3585
AST::Node expr;
3586
parseExpression(expr);
3587
if (!advance(']', "]"))
3588
return false;
3589
}
3590
return true;
3591
}
3592
3593
return false;
3594
}
3595
3596
bool Parser::parseNewInitializer(AST::Node& /*node*/)
3597
{
3598
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseNewInitializer()";
3599
if ((*m_tokenIt) != '(')
3600
return false;
3601
3602
++m_tokenIt;
3603
AST::Node expr;
3604
parseCommaExpression(expr);
3605
if (! check(')'))
3606
return false;
3607
3608
return true;
3609
}
3610
3611
bool Parser::parseDeleteExpression(AST::Node& /*node*/)
3612
{
3613
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseDeleteExpression()";
3614
if ((*m_tokenIt) == Token_scope && lex->lookAhead(m_tokenIt, 1) == Token_delete)
3615
++m_tokenIt;
3616
3617
if (! check(Token_delete))
3618
return false;
3619
3620
if ((*m_tokenIt) == '[') {
3621
++m_tokenIt;
3622
if (! check(']'))
3623
return false;
3624
}
3625
3626
AST::Node expr;
3627
return parseCastExpression(expr);
3628
}
3629
3630
bool Parser::parseCastExpression(AST::Node& /*node*/)
3631
{
3632
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseCastExpression()";
3633
3634
TokenIterator index = m_tokenIt;
3635
3636
if ((*m_tokenIt) == '(') {
3637
++m_tokenIt;
3638
AST::Node typeId;
3639
if (parseTypeId(typeId)) {
3640
if ((*m_tokenIt) == ')') {
3641
++m_tokenIt;
3642
AST::Node expr;
3643
if (parseCastExpression(expr))
3644
return true;
3645
}
3646
}
3647
}
3648
3649
m_tokenIt = index;
3650
3651
AST::Node expr;
3652
return parseUnaryExpression(expr);
3653
}
3654
3655
bool Parser::parsePmExpression(AST::Node& /*node*/)
3656
{
3657
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser:parsePmExpression()";
3658
AST::Node expr;
3659
if (!parseCastExpression(expr))
3660
return false;
3661
3662
while ((*m_tokenIt) == Token_ptrmem) {
3663
++m_tokenIt;
3664
3665
if (!parseCastExpression(expr))
3666
return false;
3667
}
3668
3669
return true;
3670
}
3671
3672
bool Parser::parseMultiplicativeExpression(AST::Node& /*node*/)
3673
{
3674
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseMultiplicativeExpression()";
3675
AST::Node expr;
3676
if (!parsePmExpression(expr))
3677
return false;
3678
3679
while ((*m_tokenIt) == '*' || (*m_tokenIt) == '/' || (*m_tokenIt) == '%') {
3680
++m_tokenIt;
3681
3682
if (!parsePmExpression(expr))
3683
return false;
3684
}
3685
3686
return true;
3687
}
3688
3689
3690
bool Parser::parseAdditiveExpression(AST::Node& /*node*/)
3691
{
3692
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseAdditiveExpression()";
3693
AST::Node expr;
3694
if (!parseMultiplicativeExpression(expr))
3695
return false;
3696
3697
while ((*m_tokenIt) == '+' || (*m_tokenIt) == '-') {
3698
++m_tokenIt;
3699
3700
if (!parseMultiplicativeExpression(expr))
3701
return false;
3702
}
3703
3704
return true;
3705
}
3706
3707
bool Parser::parseShiftExpression(AST::Node& /*node*/)
3708
{
3709
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseShiftExpression()";
3710
AST::Node expr;
3711
if (!parseAdditiveExpression(expr))
3712
return false;
3713
3714
if ((*m_tokenIt) == '>') {
3715
uWarning() << "TODO: add support for '>>'";
3716
}
3717
3718
while ((*m_tokenIt) == Token_left_shift) {
3719
++m_tokenIt;
3720
3721
if (!parseAdditiveExpression(expr))
3722
return false;
3723
}
3724
3725
return true;
3726
}
3727
3728
bool Parser::parseRelationalExpression(AST::Node& /*node*/, bool templArgs)
3729
{
3730
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseRelationalExpression()";
3731
AST::Node expr;
3732
if (!parseShiftExpression(expr))
3733
return false;
3734
3735
while ((*m_tokenIt) == '<' || ((*m_tokenIt) == '>' && !templArgs) ||
3736
(*m_tokenIt) == Token_leq || (*m_tokenIt) == Token_geq) {
3737
++m_tokenIt;
3738
3739
if (!parseShiftExpression(expr))
3740
return false;
3741
}
3742
3743
return true;
3744
}
3745
3746
bool Parser::parseEqualityExpression(AST::Node& /*node*/, bool templArgs)
3747
{
3748
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseEqualityExpression()";
3749
AST::Node expr;
3750
if (!parseRelationalExpression(expr, templArgs))
3751
return false;
3752
3753
while ((*m_tokenIt) == Token_eq || (*m_tokenIt) == Token_not_eq) {
3754
++m_tokenIt;
3755
3756
if (!parseRelationalExpression(expr, templArgs))
3757
return false;
3758
}
3759
3760
return true;
3761
}
3762
3763
bool Parser::parseAndExpression(AST::Node& /*node*/, bool templArgs)
3764
{
3765
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseAndExpression()";
3766
AST::Node expr;
3767
if (!parseEqualityExpression(expr, templArgs))
3768
return false;
3769
3770
while ((*m_tokenIt) == '&') {
3771
++m_tokenIt;
3772
3773
if (!parseEqualityExpression(expr, templArgs))
3774
return false;
3775
}
3776
3777
return true;
3778
}
3779
3780
bool Parser::parseExclusiveOrExpression(AST::Node& /*node*/, bool templArgs)
3781
{
3782
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseExclusiveOrExpression()";
3783
AST::Node expr;
3784
if (!parseAndExpression(expr, templArgs))
3785
return false;
3786
3787
while ((*m_tokenIt) == '^') {
3788
++m_tokenIt;
3789
3790
if (!parseAndExpression(expr, templArgs))
3791
return false;
3792
}
3793
3794
return true;
3795
}
3796
3797
bool Parser::parseInclusiveOrExpression(AST::Node& /*node*/, bool templArgs)
3798
{
3799
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseInclusiveOrExpression()";
3800
AST::Node expr;
3801
if (!parseExclusiveOrExpression(expr, templArgs))
3802
return false;
3803
3804
while ((*m_tokenIt) == '|') {
3805
++m_tokenIt;
3806
3807
if (!parseExclusiveOrExpression(expr, templArgs))
3808
return false;
3809
}
3810
3811
return true;
3812
}
3813
3814
bool Parser::parseLogicalAndExpression(AST::Node& /*node*/, bool templArgs)
3815
{
3816
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseLogicalAndExpression()";
3817
3818
AST::Node expr;
3819
if (!parseInclusiveOrExpression(expr, templArgs))
3820
return false;
3821
3822
while ((*m_tokenIt) == Token_and) {
3823
++m_tokenIt;
3824
3825
if (!parseInclusiveOrExpression(expr, templArgs))
3826
return false;
3827
}
3828
3829
return true;
3830
}
3831
3832
bool Parser::parseLogicalOrExpression(AST::Node& node, bool templArgs)
3833
{
3834
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseLogicalOrExpression()";
3835
3836
TokenIterator start = m_tokenIt;
3837
3838
AST::Node expr;
3839
if (!parseLogicalAndExpression(expr, templArgs))
3840
return false;
3841
3842
while ((*m_tokenIt) == Token_or) {
3843
++m_tokenIt;
3844
3845
if (!parseLogicalAndExpression(expr, templArgs))
3846
return false;
3847
}
3848
3849
AST::Node ast = CreateNode<AST>();
3850
update_pos(ast, start, m_tokenIt);
3851
node = ast;
3852
return true;
3853
}
3854
3855
bool Parser::parseConditionalExpression(AST::Node& /*node*/)
3856
{
3857
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseConditionalExpression()";
3858
AST::Node expr;
3859
if (!parseLogicalOrExpression(expr))
3860
return false;
3861
3862
if ((*m_tokenIt) == '?') {
3863
++m_tokenIt;
3864
3865
if (!parseExpression(expr))
3866
return false;
3867
3868
if (! check(':'))
3869
return false;
3870
3871
if (!parseAssignmentExpression(expr))
3872
return false;
3873
}
3874
3875
return true;
3876
}
3877
3878
bool Parser::parseAssignmentExpression(AST::Node& node)
3879
{
3880
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseAssignmentExpression()";
3881
TokenIterator start = m_tokenIt;
3882
AST::Node expr;
3883
if ((*m_tokenIt) == Token_throw && !parseThrowExpression(expr))
3884
return false;
3885
else if (!parseConditionalExpression(expr))
3886
return false;
3887
3888
while ((*m_tokenIt) == Token_assign || (*m_tokenIt) == '=') {
3889
++m_tokenIt;
3890
3891
if (!parseConditionalExpression(expr))
3892
return false;
3893
}
3894
3895
AST::Node ast = CreateNode<AST>();
3896
update_pos(ast, start, m_tokenIt);
3897
node = ast;
3898
return true;
3899
}
3900
3901
bool Parser::parseConstantExpression(AST::Node& node)
3902
{
3903
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseConstantExpression()";
3904
TokenIterator start = m_tokenIt;
3905
if (parseConditionalExpression(node)) {
3906
AST::Node ast = CreateNode<AST>();
3907
update_pos(ast, start, m_tokenIt);
3908
node = ast;
3909
return true;
3910
}
3911
return false;
3912
}
3913
3914
bool Parser::parseExpression(AST::Node& node)
3915
{
3916
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseExpression()";
3917
3918
TokenIterator start = m_tokenIt;
3919
3920
if (!parseCommaExpression(node))
3921
return false;
3922
3923
AST::Node ast = CreateNode<AST>();
3924
update_pos(ast, start, m_tokenIt);
3925
node = ast;
3926
return true;
3927
}
3928
3929
bool Parser::parseCommaExpression(AST::Node& node)
3930
{
3931
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseCommaExpression()";
3932
TokenIterator start = m_tokenIt;
3933
3934
AST::Node expr;
3935
if (!parseAssignmentExpression(expr))
3936
return false;
3937
3938
QString comment;
3939
while ((*m_tokenIt) == ',') {
3940
comment.clear();
3941
advanceAndCheckTrailingComment(comment);
3942
3943
if (!parseAssignmentExpression(expr))
3944
return false;
3945
if (!comment.isEmpty())
3946
expr->setComment(comment);
3947
}
3948
3949
AST::Node ast = CreateNode<AST>();
3950
update_pos(ast, start, m_tokenIt);
3951
node = ast;
3952
return true;
3953
}
3954
3955
bool Parser::parseThrowExpression(AST::Node& /*node*/)
3956
{
3957
//uDebug() << "--- tok = " << (*m_tokenIt).text() << " -- " << "Parser::parseThrowExpression()";
3958
if ((*m_tokenIt) != Token_throw)
3959
return false;
3960
3961
if (! check(Token_throw))
3962
return false;
3963
AST::Node expr;
3964
if (!parseAssignmentExpression(expr))
3965
return false;
3966
3967
return true;
3968
}
3969
3970
bool Parser::parseIvarDeclList(AST::Node & node)
3971
{
3972
Q_UNUSED(node);
3973
return false;
3974
}
3975
3976
bool Parser::parseIvarDecls(AST::Node & node)
3977
{
3978
Q_UNUSED(node);
3979
return false;
3980
}
3981
3982
bool Parser::parseIvarDecl(AST::Node & node)
3983
{
3984
Q_UNUSED(node);
3985
return false;
3986
}
3987
3988
bool Parser::parseIvars(AST::Node & node)
3989
{
3990
Q_UNUSED(node);
3991
return false;
3992
}
3993
3994
bool Parser::parseIvarDeclarator(AST::Node & node)
3995
{
3996
Q_UNUSED(node);
3997
return false;
3998
}
3999
4000
bool Parser::parseMethodDecl(AST::Node & node)
4001
{
4002
Q_UNUSED(node);
4003
return false;
4004
}
4005
4006
bool Parser::parseUnarySelector(AST::Node & node)
4007
{
4008
Q_UNUSED(node);
4009
return false;
4010
}
4011
4012
bool Parser::parseKeywordSelector(AST::Node & node)
4013
{
4014
Q_UNUSED(node);
4015
return false;
4016
}
4017
4018
bool Parser::parseSelector(AST::Node & node)
4019
{
4020
Q_UNUSED(node);
4021
return false;
4022
}
4023
4024
bool Parser::parseKeywordDecl(AST::Node & node)
4025
{
4026
Q_UNUSED(node);
4027
return false;
4028
}
4029
4030
bool Parser::parseReceiver(AST::Node & node)
4031
{
4032
Q_UNUSED(node);
4033
return false;
4034
}
4035
4036
bool Parser::parseObjcMessageExpr(AST::Node & node)
4037
{
4038
Q_UNUSED(node);
4039
return false;
4040
}
4041
4042
bool Parser::parseMessageArgs(AST::Node & node)
4043
{
4044
Q_UNUSED(node);
4045
return false;
4046
}
4047
4048
bool Parser::parseKeywordExpr(AST::Node & node)
4049
{
4050
Q_UNUSED(node);
4051
return false;
4052
}
4053
4054
bool Parser::parseKeywordArgList(AST::Node & node)
4055
{
4056
Q_UNUSED(node);
4057
return false;
4058
}
4059
4060
bool Parser::parseKeywordArg(AST::Node & node)
4061
{
4062
Q_UNUSED(node);
4063
return false;
4064
}
4065
4066
bool Parser::parseReservedWord(AST::Node & node)
4067
{
4068
Q_UNUSED(node);
4069
return false;
4070
}
4071
4072
bool Parser::parseMyParms(AST::Node & node)
4073
{
4074
Q_UNUSED(node);
4075
return false;
4076
}
4077
4078
bool Parser::parseMyParm(AST::Node & node)
4079
{
4080
Q_UNUSED(node);
4081
return false;
4082
}
4083
4084
bool Parser::parseOptParmList(AST::Node & node)
4085
{
4086
Q_UNUSED(node);
4087
return false;
4088
}
4089
4090
bool Parser::parseObjcSelectorExpr(AST::Node & node)
4091
{
4092
Q_UNUSED(node);
4093
return false;
4094
}
4095
4096
bool Parser::parseSelectorArg(AST::Node & node)
4097
{
4098
Q_UNUSED(node);
4099
return false;
4100
}
4101
4102
bool Parser::parseKeywordNameList(AST::Node & node)
4103
{
4104
Q_UNUSED(node);
4105
return false;
4106
}
4107
4108
bool Parser::parseKeywordName(AST::Node & node)
4109
{
4110
Q_UNUSED(node);
4111
return false;
4112
}
4113
4114
bool Parser::parseObjcEncodeExpr(AST::Node & node)
4115
{
4116
Q_UNUSED(node);
4117
return false;
4118
}
4119
4120
bool Parser::parseObjcString(AST::Node & node)
4121
{
4122
Q_UNUSED(node);
4123
return false;
4124
}
4125
4126
bool Parser::parseProtocolRefs(AST::Node & node)
4127
{
4128
Q_UNUSED(node);
4129
return false;
4130
}
4131
4132
bool Parser::parseIdentifierList(GroupAST::Node & node)
4133
{
4134
TokenIterator start = m_tokenIt;
4135
4136
if ((*m_tokenIt) != Token_identifier)
4137
return false;
4138
4139
GroupAST::Node ast = CreateNode<GroupAST>();
4140
4141
AST::Node tk = ast_from_token(m_tokenIt);
4142
ast->addNode(tk);
4143
++m_tokenIt;
4144
4145
QString comment;
4146
while ((*m_tokenIt) == ',') {
4147
comment.clear();
4148
advanceAndCheckTrailingComment(comment);
4149
if ((*m_tokenIt) == Token_identifier) {
4150
AST::Node tk = ast_from_token(m_tokenIt);
4151
ast->addNode(tk);
4152
++m_tokenIt;
4153
}
4154
if (!advance(Token_identifier, "identifier"))
4155
return false;
4156
}
4157
4158
node = ast;
4159
update_pos(node, start, m_tokenIt);
4160
return true;
4161
}
4162
4163
bool Parser::parseIdentifierColon(AST::Node & node)
4164
{
4165
Q_UNUSED(node);
4166
4167
if ((*m_tokenIt) == Token_identifier && lex->lookAhead(m_tokenIt, 1) == ':') {
4168
++m_tokenIt;
4169
++m_tokenIt;
4170
return true;
4171
} // ### else if PTYPENAME -> return true ;
4172
4173
return false;
4174
}
4175
4176
bool Parser::parseObjcProtocolExpr(AST::Node & node)
4177
{
4178
Q_UNUSED(node);
4179
return false;
4180
}
4181
4182
bool Parser::parseObjcOpenBracketExpr(AST::Node & node)
4183
{
4184
Q_UNUSED(node);
4185
return false;
4186
}
4187
4188
bool Parser::parseObjcCloseBracket(AST::Node & node)
4189
{
4190
Q_UNUSED(node);
4191
return false;
4192
}
4193
4194
bool Parser::parseObjcDef(DeclarationAST::Node & node)
4195
{
4196
Q_UNUSED(node);
4197
return false;
4198
}
4199
4200
bool Parser::parseObjcClassDef(DeclarationAST::Node & node)
4201
{
4202
Q_UNUSED(node);
4203
return false;
4204
}
4205
4206
bool Parser::parseObjcClassDecl(DeclarationAST::Node & node)
4207
{
4208
Q_UNUSED(node);
4209
4210
if (!advance(OBJC_CLASS, "@class"))
4211
return false;
4212
4213
GroupAST::Node idList;
4214
parseIdentifierList(idList);
4215
if (!advance(';', ";"))
4216
return false;
4217
4218
return true;
4219
}
4220
4221
bool Parser::parseObjcProtocolDecl(DeclarationAST::Node & node)
4222
{
4223
Q_UNUSED(node);
4224
4225
if (!advance(OBJC_PROTOCOL, "@protocol"))
4226
return false;
4227
4228
GroupAST::Node idList;
4229
parseIdentifierList(idList);
4230
if (!advance(';', ";"))
4231
return false;
4232
4233
return true;
4234
}
4235
4236
bool Parser::parseObjcAliasDecl(DeclarationAST::Node & node)
4237
{
4238
Q_UNUSED(node);
4239
4240
if (!advance(OBJC_ALIAS, "@alias"))
4241
return false;
4242
4243
GroupAST::Node idList;
4244
parseIdentifierList(idList);
4245
if (!advance(';', ";"))
4246
return false;
4247
4248
return true;
4249
}
4250
4251
bool Parser::parseObjcProtocolDef(DeclarationAST::Node & node)
4252
{
4253
Q_UNUSED(node);
4254
return false;
4255
}
4256
4257
bool Parser::parseObjcMethodDef(DeclarationAST::Node & node)
4258
{
4259
Q_UNUSED(node);
4260
return false;
4261
}
4262
4263
bool Parser::parseWinDeclSpec(GroupAST::Node & node)
4264
{
4265
if ((*m_tokenIt) == Token_identifier && (*m_tokenIt).text() == "__declspec" && lex->lookAhead(m_tokenIt, 1) == '(') {
4266
TokenIterator start = m_tokenIt;
4267
++m_tokenIt;
4268
++m_tokenIt; // skip '('
4269
4270
parseIdentifierList(node);
4271
if (!advance(')', ")"))
4272
return false;
4273
4274
update_pos(node, start, m_tokenIt);
4275
return true;
4276
}
4277
4278
return false;
4279
}
4280
Loggerhead is a web-based interface for Breezy
Version: 2.0.1