qqmljs.g #1

IterationStatement: T_FOR T_LPAREN ExpressionOpt T_SEMICOLON ExpressionOpt_In T_SEMICOLON ExpressionOpt_In T_RPAREN Statement; -- [lookahead != { let [ }]

3131

3132

case $rule_number: {

3133

AST::ForStatement *node = new (pool) AST::ForStatement(sym(3).Expression, sym(5).Expression, sym(7).Expression, sym(9).Statement);

3134

node->forToken = loc(1);

3135

node->lparenToken = loc(2);

3136

node->firstSemicolonToken = loc(4);

3137

node->secondSemicolonToken = loc(6);

3138

node->rparenToken = loc(8);

sym(1).Node = node;

} break;

IterationStatement: T_FOR T_LPAREN VarDeclaration T_SEMICOLON ExpressionOpt_In T_SEMICOLON ExpressionOpt_In T_RPAREN Statement;

3144

/. case $rule_number: Q_FALLTHROUGH(); ./

3145

IterationStatement: T_FOR T_LPAREN LexicalDeclaration T_SEMICOLON ExpressionOpt_In T_SEMICOLON ExpressionOpt_In T_RPAREN Statement;

3146

3147

case $rule_number: {

3148

// ### get rid of the static_cast!

3149

AST::ForStatement *node = new (pool) AST::ForStatement(

3150

static_cast<AST::VariableStatement *>(sym(3).Node)->declarations, sym(5).Expression,

3151

sym(7).Expression, sym(9).Statement);

3152

node->forToken = loc(1);

3153

node->lparenToken = loc(2);

3154

node->firstSemicolonToken = loc(4);

3155

node->secondSemicolonToken = loc(6);

3156

node->rparenToken = loc(8);

sym(1).Node = node;

} break;

InOrOf: T_IN;

case $rule_number: {

sym(1).forEachType = AST::ForEachType::In;

} break;

InOrOf: T_OF;

case $rule_number: {

sym(1).forEachType = AST::ForEachType::Of;

} break;

IterationStatement: T_FOR T_LPAREN LeftHandSideExpression InOrOf Expression_In T_RPAREN Statement;

3176

3177

case $rule_number: {

3178

// need to convert the LHS to an AssignmentPattern if it was an Array/ObjectLiteral

3179

if (AST::Pattern *p = sym(3).Expression->patternCast()) {

3180

AST::SourceLocation errorLoc;

3181

QString errorMsg;

3182

if (!p->convertLiteralToAssignmentPattern(pool, &errorLoc, &errorMsg)) {

3183

syntaxError(errorLoc, errorMsg);

return false;

}

}

AST::ForEachStatement *node = new (pool) AST::ForEachStatement(sym(3).Expression, sym(5).Expression, sym(7).Statement);

3188

node->forToken = loc(1);

3189

node->lparenToken = loc(2);

3190

node->inOfToken = loc(4);

3191

node->rparenToken = loc(6);

3192

node->type = sym(4).forEachType;

sym(1).Node = node;

} break;

IterationStatement: T_FOR T_LPAREN ForDeclaration InOrOf Expression_In T_RPAREN Statement;

3198

3199

case $rule_number: {

3200

AST::ForEachStatement *node = new (pool) AST::ForEachStatement(sym(3).PatternElement, sym(5).Expression, sym(7).Statement);

3201

node->forToken = loc(1);

3202

node->lparenToken = loc(2);

3203

node->inOfToken = loc(4);

3204

node->rparenToken = loc(6);

3205

node->type = sym(4).forEachType;

sym(1).Node = node;

} break;

ForDeclaration: LetOrConst BindingIdentifier;

3211

/. case $rule_number: Q_FALLTHROUGH(); ./

3212

ForDeclaration: Var BindingIdentifier;

3213

3214

case $rule_number: {

3215

auto *node = new (pool) AST::PatternElement(stringRef(2), nullptr);

3216

node->identifierToken = loc(2);

3217

node->scope = sym(1).scope;

sym(1).Node = node;

} break;

ForDeclaration: LetOrConst BindingPattern;

3223

/. case $rule_number: Q_FALLTHROUGH(); ./

3224

ForDeclaration: Var BindingPattern;

3225

3226

case $rule_number: {

3227

auto *node = new (pool) AST::PatternElement(sym(2).Pattern, nullptr);

3228

node->scope = sym(1).scope;

sym(1).Node = node;

} break;

ContinueStatement: T_CONTINUE T_AUTOMATIC_SEMICOLON;

3234

ContinueStatement: T_CONTINUE T_SEMICOLON;

3235

3236

case $rule_number: {

3237

AST::ContinueStatement *node = new (pool) AST::ContinueStatement();

3238

node->continueToken = loc(1);

3239

node->semicolonToken = loc(2);

sym(1).Node = node;

} break;

ContinueStatement: T_CONTINUE IdentifierReference T_AUTOMATIC_SEMICOLON;

3245

ContinueStatement: T_CONTINUE IdentifierReference T_SEMICOLON;

3246

3247

case $rule_number: {

3248

AST::ContinueStatement *node = new (pool) AST::ContinueStatement(stringRef(2));

3249

node->continueToken = loc(1);

3250

node->identifierToken = loc(2);

3251

node->semicolonToken = loc(3);

sym(1).Node = node;

} break;

BreakStatement: T_BREAK T_AUTOMATIC_SEMICOLON;

3257

BreakStatement: T_BREAK T_SEMICOLON;

3258

3259

case $rule_number: {

3260

AST::BreakStatement *node = new (pool) AST::BreakStatement(QStringRef());

3261

node->breakToken = loc(1);

3262

node->semicolonToken = loc(2);

sym(1).Node = node;

} break;

BreakStatement: T_BREAK IdentifierReference T_AUTOMATIC_SEMICOLON;

3268

BreakStatement: T_BREAK IdentifierReference T_SEMICOLON;

3269

3270

case $rule_number: {

3271

AST::BreakStatement *node = new (pool) AST::BreakStatement(stringRef(2));

3272

node->breakToken = loc(1);

3273

node->identifierToken = loc(2);

3274

node->semicolonToken = loc(3);

sym(1).Node = node;

} break;

ReturnStatement: T_RETURN ExpressionOpt_In T_AUTOMATIC_SEMICOLON;

3280

ReturnStatement: T_RETURN ExpressionOpt_In T_SEMICOLON;

3281

3282

case $rule_number: {

3283

if (!functionNestingLevel) {

3284

syntaxError(loc(1), "Return statement not allowed outside of Function declaration.");

3285

return false;

3286

}

3287

AST::ReturnStatement *node = new (pool) AST::ReturnStatement(sym(2).Expression);

3288

node->returnToken = loc(1);

3289

node->semicolonToken = loc(3);

sym(1).Node = node;

} break;

WithStatement: T_WITH T_LPAREN Expression_In T_RPAREN Statement;

3295

3296

case $rule_number: {

3297

AST::WithStatement *node = new (pool) AST::WithStatement(sym(3).Expression, sym(5).Statement);

3298

node->withToken = loc(1);

3299

node->lparenToken = loc(2);

3300

node->rparenToken = loc(4);

sym(1).Node = node;

} break;

SwitchStatement: T_SWITCH T_LPAREN Expression_In T_RPAREN CaseBlock;

3306

3307

case $rule_number: {

3308

AST::SwitchStatement *node = new (pool) AST::SwitchStatement(sym(3).Expression, sym(5).CaseBlock);

3309

node->switchToken = loc(1);

3310

node->lparenToken = loc(2);

3311

node->rparenToken = loc(4);

sym(1).Node = node;

} break;

CaseBlock: T_LBRACE CaseClausesOpt T_RBRACE;

3317

3318

case $rule_number: {

3319

AST::CaseBlock *node = new (pool) AST::CaseBlock(sym(2).CaseClauses);

3320

node->lbraceToken = loc(1);

3321

node->rbraceToken = loc(3);

sym(1).Node = node;

} break;

CaseBlock: T_LBRACE CaseClausesOpt DefaultClause CaseClausesOpt T_RBRACE;

3327

3328

case $rule_number: {

3329

AST::CaseBlock *node = new (pool) AST::CaseBlock(sym(2).CaseClauses, sym(3).DefaultClause, sym(4).CaseClauses);

3330

node->lbraceToken = loc(1);

3331

node->rbraceToken = loc(5);

sym(1).Node = node;

} break;

CaseClauses: CaseClause;

3337

3338

case $rule_number: {

3339

sym(1).Node = new (pool) AST::CaseClauses(sym(1).CaseClause);

} break;

CaseClauses: CaseClauses CaseClause;

3344

3345

case $rule_number: {

3346

sym(1).Node = new (pool) AST::CaseClauses(sym(1).CaseClauses, sym(2).CaseClause);

} break;

CaseClausesOpt: ;

case $rule_number: {

sym(1).Node = nullptr;

} break;

CaseClausesOpt: CaseClauses;

3358

3359

case $rule_number: {

3360

sym(1).Node = sym(1).CaseClauses->finish();

} break;

CaseClause: T_CASE Expression_In T_COLON StatementListOpt;

3365

3366

case $rule_number: {

3367

AST::CaseClause *node = new (pool) AST::CaseClause(sym(2).Expression, sym(4).StatementList);

3368

node->caseToken = loc(1);

3369

node->colonToken = loc(3);

sym(1).Node = node;

} break;

DefaultClause: T_DEFAULT T_COLON StatementListOpt;

3375

3376

case $rule_number: {

3377

AST::DefaultClause *node = new (pool) AST::DefaultClause(sym(3).StatementList);

3378

node->defaultToken = loc(1);

3379

node->colonToken = loc(2);

sym(1).Node = node;

} break;

LabelledStatement: IdentifierReference T_COLON LabelledItem;

3385

3386

case $rule_number: {

3387

AST::LabelledStatement *node = new (pool) AST::LabelledStatement(stringRef(1), sym(3).Statement);

3388

node->identifierToken = loc(1);

3389

node->colonToken = loc(2);

sym(1).Node = node;

} break;

LabelledItem: Statement;

3395

3396

LabelledItem: ExpressionStatementLookahead T_FORCE_DECLARATION FunctionDeclaration;

3397

3398

case $rule_number: {

3399

syntaxError(loc(3), "FunctionDeclarations are not allowed after a label.");

return false;

} break;

ThrowStatement: T_THROW Expression_In T_AUTOMATIC_SEMICOLON;

3405

ThrowStatement: T_THROW Expression_In T_SEMICOLON;

3406

3407

case $rule_number: {

3408

AST::ThrowStatement *node = new (pool) AST::ThrowStatement(sym(2).Expression);

3409

node->throwToken = loc(1);

3410

node->semicolonToken = loc(3);

sym(1).Node = node;

} break;

TryStatement: T_TRY Block Catch;

3416

3417

case $rule_number: {

3418

AST::TryStatement *node = new (pool) AST::TryStatement(sym(2).Statement, sym(3).Catch);

3419

node->tryToken = loc(1);

sym(1).Node = node;

} break;

TryStatement: T_TRY Block Finally;

3425

3426

case $rule_number: {

3427

AST::TryStatement *node = new (pool) AST::TryStatement(sym(2).Statement, sym(3).Finally);

3428

node->tryToken = loc(1);

sym(1).Node = node;

} break;

TryStatement: T_TRY Block Catch Finally;

3434

3435

case $rule_number: {

3436

AST::TryStatement *node = new (pool) AST::TryStatement(sym(2).Statement, sym(3).Catch, sym(4).Finally);

3437

node->tryToken = loc(1);

sym(1).Node = node;

} break;

Catch: T_CATCH T_LPAREN CatchParameter T_RPAREN Block;

3443

3444

case $rule_number: {

3445

AST::Catch *node = new (pool) AST::Catch(sym(3).PatternElement, sym(5).Block);

3446

node->catchToken = loc(1);

3447

node->lparenToken = loc(2);

3448

node->identifierToken = loc(3);

3449

node->rparenToken = loc(4);

sym(1).Node = node;

} break;

Finally: T_FINALLY Block;

3455

3456

case $rule_number: {

3457

AST::Finally *node = new (pool) AST::Finally(sym(2).Block);

3458

node->finallyToken = loc(1);

sym(1).Node = node;

} break;

CatchParameter: BindingIdentifier;

3464

3465

case $rule_number: {

3466

AST::PatternElement *node = new (pool) AST::PatternElement(stringRef(1));

3467

node->identifierToken = loc(1);

3468

node->scope = AST::VariableScope::Let;

sym(1).Node = node;

} break;

CatchParameter: BindingPattern;

3474

3475

case $rule_number: {

3476

AST::PatternElement *node = new (pool) AST::PatternElement(sym(1).Pattern);

3477

node->scope = AST::VariableScope::Let;

sym(1).Node = node;

} break;

DebuggerStatement: T_DEBUGGER T_AUTOMATIC_SEMICOLON; -- automatic semicolon

3483

DebuggerStatement: T_DEBUGGER T_SEMICOLON;

3484

3485

case $rule_number: {

3486

AST::DebuggerStatement *node = new (pool) AST::DebuggerStatement();

3487

node->debuggerToken = loc(1);

3488

node->semicolonToken = loc(2);

sym(1).Node = node;

} break;

-- tell the parser to prefer function declarations to function expressions.

3494

-- That is, the `Function' symbol is used to mark the start of a function

3495

-- declaration.

3496

-- This is still required for parsing QML, where MemberExpression and FunctionDeclaration would

3497

-- otherwise conflict.

3498

Function: T_FUNCTION %prec REDUCE_HERE;

3499

3500

FunctionDeclaration: Function BindingIdentifier T_LPAREN FormalParameters T_RPAREN FunctionLBrace FunctionBody FunctionRBrace;

3501

3502

case $rule_number: {

3503

AST::FunctionDeclaration *node = new (pool) AST::FunctionDeclaration(stringRef(2), sym(4).FormalParameterList, sym(7).StatementList);

3504

node->functionToken = loc(1);

3505

node->identifierToken = loc(2);

3506

node->lparenToken = loc(3);

3507

node->rparenToken = loc(5);

3508

node->lbraceToken = loc(6);

3509

node->rbraceToken = loc(8);

sym(1).Node = node;

} break;

FunctionDeclaration_Default: FunctionDeclaration;

3516

FunctionDeclaration_Default: Function T_LPAREN FormalParameters T_RPAREN FunctionLBrace FunctionBody FunctionRBrace;

3517

3518

case $rule_number: {

3519

AST::FunctionDeclaration *node = new (pool) AST::FunctionDeclaration(stringRef(1), sym(3).FormalParameterList, sym(6).StatementList);

3520

node->functionToken = loc(1);

3521

node->identifierToken = loc(1);

3522

node->lparenToken = loc(2);

3523

node->rparenToken = loc(4);

3524

node->lbraceToken = loc(5);

3525

node->rbraceToken = loc(7);

sym(1).Node = node;

} break;

FunctionExpression: T_FUNCTION BindingIdentifier T_LPAREN FormalParameters T_RPAREN FunctionLBrace FunctionBody FunctionRBrace;

3531

3532

case $rule_number: {

3533

AST::FunctionExpression *node = new (pool) AST::FunctionExpression(stringRef(2), sym(4).FormalParameterList, sym(7).StatementList);

3534

node->functionToken = loc(1);

3535

if (! stringRef(2).isNull())

3536

node->identifierToken = loc(2);

3537

node->lparenToken = loc(3);

3538

node->rparenToken = loc(5);

3539

node->lbraceToken = loc(6);

3540

node->rbraceToken = loc(8);

sym(1).Node = node;

} break;

FunctionExpression: T_FUNCTION T_LPAREN FormalParameters T_RPAREN FunctionLBrace FunctionBody FunctionRBrace;

3546

3547

case $rule_number: {

3548

AST::FunctionExpression *node = new (pool) AST::FunctionExpression(QStringRef(), sym(3).FormalParameterList, sym(6).StatementList);

3549

node->functionToken = loc(1);

3550

node->lparenToken = loc(2);

3551

node->rparenToken = loc(4);

3552

node->lbraceToken = loc(5);

3553

node->rbraceToken = loc(7);

sym(1).Node = node;

} break;

StrictFormalParameters: FormalParameters;

FormalParameters: ;

case $rule_number: {

sym(1).Node = nullptr;

} break;

FormalParameters: BindingRestElement;

3568

3569

case $rule_number: {

3570

AST::FormalParameterList *node = (new (pool) AST::FormalParameterList(nullptr, sym(1).PatternElement))->finish(pool);

sym(1).Node = node;

} break;

FormalParameters: FormalParameterList;

3576

/. case $rule_number: ./

3577

FormalParameters: FormalParameterList T_COMMA;

3578

3579

case $rule_number: {

3580

sym(1).Node = sym(1).FormalParameterList->finish(pool);

} break;

FormalParameters: FormalParameterList T_COMMA BindingRestElement;

3585

3586

case $rule_number: {

3587

AST::FormalParameterList *node = (new (pool) AST::FormalParameterList(sym(1).FormalParameterList, sym(3).PatternElement))->finish(pool);

sym(1).Node = node;

} break;

FormalParameterList: BindingElement;

3593

3594

case $rule_number: {

3595

AST::FormalParameterList *node = new (pool) AST::FormalParameterList(nullptr, sym(1).PatternElement);

sym(1).Node = node;

} break;

FormalParameterList: FormalParameterList T_COMMA BindingElement;

3602

3603

case $rule_number: {

3604

AST::FormalParameterList *node = new (pool) AST::FormalParameterList(sym(1).FormalParameterList, sym(3).PatternElement);

sym(1).Node = node;

} break;

FormalParameter: BindingElement;

3610

3611

FunctionLBrace: T_LBRACE;

3612

3613

case $rule_number: {

3614

++functionNestingLevel;

} break;

FunctionRBrace: T_RBRACE;

3619

3620

case $rule_number: {

3621

--functionNestingLevel;

} break;

FunctionBody: StatementListOpt;

3627

3628

ArrowFunction: ArrowParameters T_ARROW ConciseBodyLookahead AssignmentExpression; -- [lookahead ≠ {]

3629

/. case $rule_number: Q_FALLTHROUGH(); ./

3630

ArrowFunction_In: ArrowParameters T_ARROW ConciseBodyLookahead AssignmentExpression_In; -- [lookahead ≠ {]

3631

3632

case $rule_number: {

3633

AST::ReturnStatement *ret = new (pool) AST::ReturnStatement(sym(4).Expression);

3634

ret->returnToken = sym(4).Node->firstSourceLocation();

3635

ret->semicolonToken = sym(4).Node->lastSourceLocation();

3636

AST::StatementList *statements = (new (pool) AST::StatementList(ret))->finish();

3637

AST::FunctionExpression *f = new (pool) AST::FunctionExpression(QStringRef(), sym(1).FormalParameterList, statements);

3638

f->isArrowFunction = true;

3639

f->functionToken = sym(1).Node ? sym(1).Node->firstSourceLocation() : loc(1);

3640

f->lbraceToken = sym(4).Node->firstSourceLocation();

3641

f->rbraceToken = sym(4).Node->lastSourceLocation();

sym(1).Node = f;

} break;

ArrowFunction: ArrowParameters T_ARROW ConciseBodyLookahead T_FORCE_BLOCK FunctionLBrace FunctionBody FunctionRBrace;

3647

/. case $rule_number: Q_FALLTHROUGH(); ./

3648

ArrowFunction_In: ArrowParameters T_ARROW ConciseBodyLookahead T_FORCE_BLOCK FunctionLBrace FunctionBody FunctionRBrace;

3649

3650

case $rule_number: {

3651

AST::FunctionExpression *f = new (pool) AST::FunctionExpression(QStringRef(), sym(1).FormalParameterList, sym(6).StatementList);

3652

f->isArrowFunction = true;

3653

f->functionToken = sym(1).Node ? sym(1).Node->firstSourceLocation() : loc(1);

3654

f->lbraceToken = loc(6);

3655

f->rbraceToken = loc(7);

sym(1).Node = f;

} break;

ArrowParameters: BindingIdentifier;

3661

3662

case $rule_number: {

3663

AST::PatternElement *e = new (pool) AST::PatternElement(stringRef(1), nullptr, AST::PatternElement::Binding);

3664

e->identifierToken = loc(1);

3665

sym(1).FormalParameterList = (new (pool) AST::FormalParameterList(nullptr, e))->finish(pool);

} break;

-- CoverParenthesizedExpressionAndArrowParameterList for ArrowParameters i being refined to:

3670

-- ArrowFormalParameters: T_LPAREN StrictFormalParameters T_RPAREN

3671

ArrowParameters: CoverParenthesizedExpressionAndArrowParameterList;

3672

3673

case $rule_number: {

3674

if (coverExpressionType != CE_FormalParameterList) {

3675

AST::NestedExpression *ne = static_cast<AST::NestedExpression *>(sym(1).Node);

3676

AST::FormalParameterList *list = ne->expression->reparseAsFormalParameterList(pool);

3677

if (!list) {

3678

syntaxError(loc(1), "Invalid Arrow parameter list.");

3679

return false;

3680

}

3681

sym(1).Node = list->finish(pool);

}

} break;

ConciseBodyLookahead: ;

3687

3688

#define J_SCRIPT_CONCISEBODYLOOKAHEAD_RULE $rule_number

case $rule_number: {

if (lookaheadToken(lexer) == T_LBRACE)

3693

pushToken(T_FORCE_BLOCK);

} break;

MethodDefinition: PropertyName T_LPAREN StrictFormalParameters T_RPAREN FunctionLBrace FunctionBody FunctionRBrace;

3698

3699

case $rule_number: {

3700

AST::FunctionExpression *f = new (pool) AST::FunctionExpression(stringRef(1), sym(3).FormalParameterList, sym(6).StatementList);

3701

f->functionToken = sym(1).PropertyName->firstSourceLocation();

3702

f->lparenToken = loc(2);

3703

f->rparenToken = loc(4);

3704

f->lbraceToken = loc(5);

3705

f->rbraceToken = loc(7);

3706

AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(1).PropertyName, f);

3707

node->colonToken = loc(2);

sym(1).Node = node;

} break;

MethodDefinition: T_STAR PropertyName GeneratorLParen StrictFormalParameters T_RPAREN FunctionLBrace GeneratorBody GeneratorRBrace;

3713

3714

case $rule_number: {

3715

AST::FunctionExpression *f = new (pool) AST::FunctionExpression(stringRef(2), sym(4).FormalParameterList, sym(7).StatementList);

3716

f->functionToken = sym(2).PropertyName->firstSourceLocation();

3717

f->lparenToken = loc(3);

3718

f->rparenToken = loc(5);

3719

f->lbraceToken = loc(6);

3720

f->rbraceToken = loc(8);

3721

f->isGenerator = true;

3722

AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(2).PropertyName, f);

3723

node->colonToken = loc(2);

sym(1).Node = node;

} break;

MethodDefinition: T_GET PropertyName T_LPAREN T_RPAREN FunctionLBrace FunctionBody FunctionRBrace;

3730

3731

case $rule_number: {

3732

AST::FunctionExpression *f = new (pool) AST::FunctionExpression(stringRef(2), nullptr, sym(6).StatementList);

3733

f->functionToken = sym(2).PropertyName->firstSourceLocation();

3734

f->lparenToken = loc(3);

3735

f->rparenToken = loc(4);

3736

f->lbraceToken = loc(5);

3737

f->rbraceToken = loc(7);

3738

AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(2).PropertyName, f, AST::PatternProperty::Getter);

3739

node->colonToken = loc(2);

sym(1).Node = node;

} break;

MethodDefinition: T_SET PropertyName T_LPAREN PropertySetParameterList T_RPAREN FunctionLBrace FunctionBody FunctionRBrace;

3745

3746

case $rule_number: {

3747

AST::FunctionExpression *f = new (pool) AST::FunctionExpression(stringRef(2), sym(4).FormalParameterList, sym(7).StatementList);

3748

f->functionToken = sym(2).PropertyName->firstSourceLocation();

3749

f->lparenToken = loc(3);

3750

f->rparenToken = loc(5);

3751

f->lbraceToken = loc(6);

3752

f->rbraceToken = loc(8);

3753

AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(2).PropertyName, f, AST::PatternProperty::Setter);

3754

node->colonToken = loc(2);

sym(1).Node = node;

} break;

PropertySetParameterList: FormalParameter;

3761

3762

case $rule_number: {

3763

AST::FormalParameterList *node = (new (pool) AST::FormalParameterList(nullptr, sym(1).PatternElement))->finish(pool);

sym(1).Node = node;

} break;

GeneratorLParen: T_LPAREN;

3769

3770

case $rule_number: {

3771

lexer->enterGeneratorBody();

} break;

GeneratorRBrace: T_RBRACE;

3776

3777

case $rule_number: {

3778

--functionNestingLevel;

3779

lexer->leaveGeneratorBody();

} break;

GeneratorDeclaration: Function T_STAR BindingIdentifier GeneratorLParen FormalParameters T_RPAREN FunctionLBrace GeneratorBody GeneratorRBrace;

3784

3785

case $rule_number: {

3786

AST::FunctionDeclaration *node = new (pool) AST::FunctionDeclaration(stringRef(3), sym(5).FormalParameterList, sym(8).StatementList);

3787

node->functionToken = loc(1);

3788

node->identifierToken = loc(3);

3789

node->lparenToken = loc(4);

3790

node->rparenToken = loc(6);

3791

node->lbraceToken = loc(7);

3792

node->rbraceToken = loc(9);

3793

node->isGenerator = true;

sym(1).Node = node;

} break;

GeneratorDeclaration_Default: GeneratorDeclaration;

3799

GeneratorDeclaration_Default: Function T_STAR GeneratorLParen FormalParameters T_RPAREN FunctionLBrace GeneratorBody GeneratorRBrace;

3800

3801

case $rule_number: {

3802

AST::FunctionDeclaration *node = new (pool) AST::FunctionDeclaration(stringRef(1), sym(4).FormalParameterList, sym(7).StatementList);

3803

node->functionToken = loc(1);

3804

node->identifierToken = loc(1);

3805

node->lparenToken = loc(3);

3806

node->rparenToken = loc(5);

3807

node->lbraceToken = loc(6);

3808

node->rbraceToken = loc(8);

3809

node->isGenerator = true;

sym(1).Node = node;

} break;

GeneratorExpression: T_FUNCTION T_STAR BindingIdentifier GeneratorLParen FormalParameters T_RPAREN FunctionLBrace GeneratorBody GeneratorRBrace;

3815

3816

case $rule_number: {

3817

AST::FunctionExpression *node = new (pool) AST::FunctionExpression(stringRef(3), sym(5).FormalParameterList, sym(8).StatementList);

3818

node->functionToken = loc(1);

3819

if (!stringRef(3).isNull())

3820

node->identifierToken = loc(3);

3821

node->lparenToken = loc(4);

3822

node->rparenToken = loc(6);

3823

node->lbraceToken = loc(7);

3824

node->rbraceToken = loc(9);

3825

node->isGenerator = true;

sym(1).Node = node;

} break;

GeneratorExpression: T_FUNCTION T_STAR GeneratorLParen FormalParameters T_RPAREN FunctionLBrace GeneratorBody GeneratorRBrace;

3831

3832

case $rule_number: {

3833

AST::FunctionExpression *node = new (pool) AST::FunctionExpression(QStringRef(), sym(4).FormalParameterList, sym(7).StatementList);

3834

node->functionToken = loc(1);

3835

node->lparenToken = loc(3);

3836

node->rparenToken = loc(5);

3837

node->lbraceToken = loc(6);

3838

node->rbraceToken = loc(8);

3839

node->isGenerator = true;

sym(1).Node = node;

} break;

GeneratorBody: FunctionBody;

3845

3846

YieldExpression: T_YIELD;

3847

/. case $rule_number: Q_FALLTHROUGH(); ./

3848

YieldExpression_In: T_YIELD;

3849

3850

case $rule_number: {

3851

AST::YieldExpression *node = new (pool) AST::YieldExpression();

3852

node->yieldToken = loc(1);

sym(1).Node = node;

} break;

YieldExpression: T_YIELD T_STAR AssignmentExpression;

3858

/. case $rule_number: Q_FALLTHROUGH(); ./

3859

YieldExpression_In: T_YIELD T_STAR AssignmentExpression_In;

3860

3861

case $rule_number: {

3862

AST::YieldExpression *node = new (pool) AST::YieldExpression(sym(3).Expression);

3863

node->yieldToken = loc(1);

3864

node->isYieldStar = true;

sym(1).Node = node;

} break;

YieldExpression: T_YIELD AssignmentExpression;

3870

/. case $rule_number: Q_FALLTHROUGH(); ./

3871

YieldExpression_In: T_YIELD AssignmentExpression_In;

3872

3873

case $rule_number: {

3874

AST::YieldExpression *node = new (pool) AST::YieldExpression(sym(2).Expression);

3875

node->yieldToken = loc(1);

sym(1).Node = node;

} break;

ClassDeclaration: T_CLASS BindingIdentifier ClassHeritageOpt ClassLBrace ClassBodyOpt ClassRBrace;

3882

3883

case $rule_number: {

3884

AST::ClassDeclaration *node = new (pool) AST::ClassDeclaration(stringRef(2), sym(3).Expression, sym(5).ClassElementList);

3885

node->classToken = loc(1);

3886

node->identifierToken = loc(2);

3887

node->lbraceToken = loc(4);

3888

node->rbraceToken = loc(6);

sym(1).Node = node;

} break;

ClassExpression: T_CLASS BindingIdentifier ClassHeritageOpt ClassLBrace ClassBodyOpt ClassRBrace;

3894

3895

case $rule_number: {

3896

AST::ClassExpression *node = new (pool) AST::ClassExpression(stringRef(2), sym(3).Expression, sym(5).ClassElementList);

3897

node->classToken = loc(1);

3898

node->identifierToken = loc(2);

3899

node->lbraceToken = loc(4);

3900

node->rbraceToken = loc(6);

sym(1).Node = node;

} break;

ClassDeclaration_Default: T_CLASS ClassHeritageOpt ClassLBrace ClassBodyOpt ClassRBrace;

3906

3907

case $rule_number: {

3908

AST::ClassDeclaration *node = new (pool) AST::ClassDeclaration(QStringRef(), sym(2).Expression, sym(4).ClassElementList);

3909

node->classToken = loc(1);

3910

node->lbraceToken = loc(3);

3911

node->rbraceToken = loc(5);

sym(1).Node = node;

} break;

ClassExpression: T_CLASS ClassHeritageOpt ClassLBrace ClassBodyOpt ClassRBrace;

3917

3918

case $rule_number: {

3919

AST::ClassExpression *node = new (pool) AST::ClassExpression(QStringRef(), sym(2).Expression, sym(4).ClassElementList);

3920

node->classToken = loc(1);

3921

node->lbraceToken = loc(3);

3922

node->rbraceToken = loc(5);

sym(1).Node = node;

} break;

ClassDeclaration_Default: ClassDeclaration;

3928

3929

ClassLBrace: T_LBRACE;

3930

3931

case $rule_number: {

3932

lexer->setStaticIsKeyword(true);

} break;

ClassRBrace: T_RBRACE;

3937

/. case $rule_number: ./

3938

ClassStaticQualifier: T_STATIC;

3939

3940

case $rule_number: {

3941

lexer->setStaticIsKeyword(false);

} break;

ClassHeritageOpt: ;

case $rule_number: {

sym(1).Node = nullptr;

} break;

ClassHeritageOpt: T_EXTENDS LeftHandSideExpression;

3953

3954

case $rule_number: {

3955

sym(1).Node = sym(2).Node;

} break;

ClassBodyOpt: ;

case $rule_number: {

sym(1).Node = nullptr;

} break;

ClassBodyOpt: ClassElementList;

case $rule_number: {

if (sym(1).Node)

sym(1).Node = sym(1).ClassElementList->finish();

} break;

ClassElementList: ClassElement;

3975

3976

ClassElementList: ClassElementList ClassElement;

case $rule_number: {

if (sym(2).Node)

sym(1).ClassElementList = sym(1).ClassElementList->append(sym(2).ClassElementList);

} break;

ClassElement: MethodDefinition;

3985

3986

case $rule_number: {

3987

AST::ClassElementList *node = new (pool) AST::ClassElementList(sym(1).PatternProperty, false);

sym(1).Node = node;

} break;

ClassElement: ClassStaticQualifier MethodDefinition;

3993

3994

case $rule_number: {

3995

lexer->setStaticIsKeyword(true);

3996

AST::ClassElementList *node = new (pool) AST::ClassElementList(sym(2).PatternProperty, true);

sym(1).Node = node;

} break;

ClassElement: T_SEMICOLON;

4002

4003

case $rule_number: {

4004

sym(1).Node = nullptr;

} break;

-- Scripts and Modules

Script: ;

case $rule_number: {

sym(1).Node = nullptr;

} break;

Script: ScriptBody;

ScriptBody: StatementList;

4020

4021

case $rule_number: {

4022

sym(1).Node = new (pool) AST::Program(sym(1).StatementList->finish());

} break;

Module: ModuleBodyOpt;

4027

/. case $rule_number: { UNIMPLEMENTED; } ./

4028

4029

ModuleBody: ModuleItemList;

4030

4031

ModuleBodyOpt: ;

4032

ModuleBodyOpt: ModuleBody;

4033

4034

ModuleItemList: ModuleItem;

4035

ModuleItemList: ModuleItemList ModuleItem;

4036

4037

ModuleItem: ImportDeclaration T_AUTOMATIC_SEMICOLON;

4038

ModuleItem: ImportDeclaration T_SEMICOLON;

4039

ModuleItem: ExportDeclaration T_AUTOMATIC_SEMICOLON;

4040

ModuleItem: ExportDeclaration T_SEMICOLON;

4041

ModuleItem: StatementListItem;

4042

4043

ImportDeclaration: T_IMPORT ImportClause FromClause;

4044

ImportDeclaration: T_IMPORT ModuleSpecifier;

4045

4046

ImportClause: ImportedDefaultBinding;

4047

ImportClause: NameSpaceImport;

4048

ImportClause: NamedImports;

4049

ImportClause: ImportedDefaultBinding T_COMMA NameSpaceImport;

4050

ImportClause: ImportedDefaultBinding T_COMMA NamedImports;

4051

4052

ImportedDefaultBinding: ImportedBinding;

4053

4054

NameSpaceImport: T_STAR T_AS ImportedBinding;

4055

4056

NamedImports: T_LBRACE T_RBRACE;

4057

NamedImports: T_LBRACE ImportsList T_RBRACE;

4058

NamedImports: T_LBRACE ImportsList T_COMMA T_RBRACE;

4059

4060

FromClause: T_FROM ModuleSpecifier;

4061

4062

ImportsList: ImportSpecifier;

4063

ImportsList: ImportsList T_COMMA ImportSpecifier;

4064

4065

ImportSpecifier: ImportedBinding;

4066

ImportSpecifier: IdentifierName T_AS ImportedBinding;

4067

4068

ModuleSpecifier: T_STRING_LITERAL;

4069

4070

ImportedBinding: BindingIdentifier;

4071

4072

ExportDeclarationLookahead: ;

4073

4074

#define J_SCRIPT_EXPORTDECLARATIONLOOKAHEAD_RULE $rule_number

case $rule_number: {

int token = lookaheadToken(lexer);

4079

if (token == T_FUNCTION || token == T_CLASS)

4080

pushToken(T_FORCE_DECLARATION);

} break;

ExportDeclaration: T_EXPORT T_STAR FromClause;

4085

ExportDeclaration: T_EXPORT ExportClause FromClause;

4086

ExportDeclaration: T_EXPORT ExportClause;

4087

ExportDeclaration: T_EXPORT VariableStatement;

4088

ExportDeclaration: T_EXPORT Declaration;

4089

ExportDeclaration: T_EXPORT T_DEFAULT ExportDeclarationLookahead T_FORCE_DECLARATION HoistableDeclaration_Default;

4090

ExportDeclaration: T_EXPORT T_DEFAULT ExportDeclarationLookahead T_FORCE_DECLARATION ClassDeclaration_Default;

4091

ExportDeclaration: T_EXPORT T_DEFAULT ExportDeclarationLookahead AssignmentExpression_In; -- [lookahead ∉ { function, class }]

4092

4093

ExportClause: T_LBRACE T_RBRACE;

4094

ExportClause: T_LBRACE ExportsList T_RBRACE;

4095

ExportClause: T_LBRACE ExportsList T_COMMA T_RBRACE;

4096

4097

ExportsList: ExportSpecifier;

4098

ExportsList: ExportsList T_COMMA ExportSpecifier;

4099

4100

ExportSpecifier: IdentifierName;

4101

ExportSpecifier: IdentifierName T_AS IdentifierName;

4102

4103

-- Old top level code

4104

4105

4106

// ------------ end of switch statement

4107

} // switch

4108

action = nt_action(state_stack[tos], lhs[r] - TERMINAL_COUNT);

4109

} // if

4110

} while (action != 0);

4111

4112

#ifdef PARSER_DEBUG

4113

qDebug() << "Done or error.";

4114

#endif

4115

4116

if (first_token == last_token) {

4117

const int errorState = state_stack[tos];

4118

4119

// automatic insertion of `;'

4120

if (yytoken != -1 && ((t_action(errorState, T_AUTOMATIC_SEMICOLON) && lexer->canInsertAutomaticSemicolon(yytoken))

4121

|| t_action(errorState, T_COMPATIBILITY_SEMICOLON))) {

4122

#ifdef PARSER_DEBUG

4123

qDebug() << "Inserting automatic semicolon.";

4124

#endif

4125

SavedToken &tk = token_buffer[0];

4126

tk.token = yytoken;

4127

tk.dval = yylval;

4128

tk.spell = yytokenspell;

tk.loc = yylloc;

yylloc = yyprevlloc;

yylloc.offset += yylloc.length;

4133

yylloc.startColumn += yylloc.length;

4134

yylloc.length = 0;

4135

4136

//const QString msg = QCoreApplication::translate("QQmlParser", "Missing `;'");

4137

//diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Warning, yylloc, msg));

4138

4139

first_token = &token_buffer[0];

4140

last_token = &token_buffer[1];

4141

4142

yytoken = T_SEMICOLON;

yylval = 0;

action = errorState;

goto _Lcheck_token;

}

hadErrors = true;

token_buffer[0].token = yytoken;

4153

token_buffer[0].dval = yylval;

4154

token_buffer[0].spell = yytokenspell;

4155

token_buffer[0].loc = yylloc;

4156

4157

token_buffer[1].token = yytoken = lexer->lex();

4158

token_buffer[1].dval = yylval = lexer->tokenValue();

4159

token_buffer[1].spell = yytokenspell = lexer->tokenSpell();

4160

token_buffer[1].loc = yylloc = location(lexer);

4161

4162

if (t_action(errorState, yytoken)) {

4163

QString msg;

4164

int token = token_buffer[0].token;

4165

if (token < 0 || token >= TERMINAL_COUNT)

4166

msg = QCoreApplication::translate("QQmlParser", "Syntax error");

4167

else

4168

msg = QCoreApplication::translate("QQmlParser", "Unexpected token `%1'").arg(QLatin1String(spell[token]));

4169

diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, token_buffer[0].loc, msg));

action = errorState;

goto _Lcheck_token;

}

static int tokens[] = {

T_PLUS,

T_EQ,

T_COMMA,

T_COLON,

T_SEMICOLON,

T_RPAREN, T_RBRACKET, T_RBRACE,

T_NUMERIC_LITERAL,

T_IDENTIFIER,

T_LPAREN, T_LBRACKET, T_LBRACE,

EOF_SYMBOL

};

for (int *tk = tokens; *tk != EOF_SYMBOL; ++tk) {

4194

int a = t_action(errorState, *tk);

4195

if (a > 0 && t_action(a, yytoken)) {

4196

const QString msg = QCoreApplication::translate("QQmlParser", "Expected token `%1'").arg(QLatin1String(spell[*tk]));

4197

diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, token_buffer[0].loc, msg));

yytoken = *tk;

yylval = 0;

yylloc = token_buffer[0].loc;

4202

yylloc.length = 0;

4203

4204

first_token = &token_buffer[0];

4205

last_token = &token_buffer[2];

action = errorState;

goto _Lcheck_token;

}

}

for (int tk = 1; tk < TERMINAL_COUNT; ++tk) {

4213

if (tk == T_AUTOMATIC_SEMICOLON || tk == T_FEED_UI_PROGRAM ||

4214

tk == T_FEED_JS_STATEMENT || tk == T_FEED_JS_EXPRESSION)

4215

continue;

4216

4217

int a = t_action(errorState, tk);

4218

if (a > 0 && t_action(a, yytoken)) {

4219

const QString msg = QCoreApplication::translate("QQmlParser", "Expected token `%1'").arg(QLatin1String(spell[tk]));

4220

diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, token_buffer[0].loc, msg));

yytoken = tk;

yylval = 0;

yylloc = token_buffer[0].loc;

yylloc.length = 0;

action = errorState;

goto _Lcheck_token;

}

}

const QString msg = QCoreApplication::translate("QQmlParser", "Syntax error");

4233

diagnostic_messages.append(DiagnosticMessage(DiagnosticMessage::Error, token_buffer[0].loc, msg));

}

return false;

}

QT_QML_END_NAMESPACE

QT_QML_END_NAMESPACE

#endif // QQMLJSPARSER_P_H

4249

Generated by Squish Coco 4.2.0