~ubuntu-branches/ubuntu/lucid/swftools/lucid : revision 6

1

2

/* A Bison parser, made by GNU Bison 2.4. */

3

4

/* Skeleton implementation for Bison's Yacc-like parsers in C

5

6

7

Free Software Foundation, Inc.

8

9

This program is free software: you can redistribute it and/or modify

10

it under the terms of the GNU General Public License as published by

11

the Free Software Foundation, either version 3 of the License, or

12

(at your option) any later version.

13

14

This program is distributed in the hope that it will be useful,

15

but WITHOUT ANY WARRANTY; without even the implied warranty of

16

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

17

GNU General Public License for more details.

18

19

You should have received a copy of the GNU General Public License

20

along with this program. If not, see <http://www.gnu.org/licenses/>. */

21

22

/* As a special exception, you may create a larger work that contains

23

part or all of the Bison parser skeleton and distribute that work

24

under terms of your choice, so long as that work isn't itself a

25

parser generator using the skeleton or a modified version thereof

26

as a parser skeleton. Alternatively, if you modify or redistribute

27

the parser skeleton itself, you may (at your option) remove this

28

special exception, which will cause the skeleton and the resulting

29

Bison output files to be licensed under the GNU General Public

30

License without this special exception.

31

32

This special exception was added by the Free Software Foundation in

33

version 2.2 of Bison. */

34

35

/* C LALR(1) parser skeleton written by Richard Stallman, by

36

simplifying the original so-called "semantic" parser. */

37

38

/* All symbols defined below should begin with yy or YY, to avoid

39

infringing on user name space. This should be done even for local

40

variables, as they might otherwise be expanded by user macros.

41

There are some unavoidable exceptions within include files to

42

define necessary library symbols; they are noted "INFRINGES ON

43

USER NAME SPACE" below. */

44

45

/* Identify Bison output. */

46

#define YYBISON 1

47

48

/* Bison version. */

49

#define YYBISON_VERSION "2.4"

50

51

/* Skeleton name. */

52

#define YYSKELETON_NAME "./skeleton.m4"

53

54

/* Pure parsers. */

55

#define YYPURE 0

56

57

/* Push parsers. */

58

#define YYPUSH 0

59

60

/* Pull parsers. */

61

#define YYPULL 1

62

63

/* Using locations. */

64

#define YYLSP_NEEDED 0

65

66

/* Substitute the variable and function names. */

67

#define yyparse a3_parse

68

#define yylex a3_lex

69

#define yyerror a3_error

70

#define yylval a3_lval

71

#define yychar a3_char

72

#define yydebug a3_debug

73

#define yynerrs a3_nerrs

74

75

76

/* Copy the first part of user declarations. */

77

78

/* Line 198 of skeleton.m4 */

79

#line 23 "parser.y"

80

81

#include <stdlib.h>

82

#include <stdio.h>

83

#include <memory.h>

84

#include "abc.h"

85

#include "pool.h"

86

#include "files.h"

87

#include "common.h"

88

#include "tokenizer.h"

89

#include "registry.h"

90

#include "code.h"

91

#include "opcodes.h"

92

#include "compiler.h"

93

#include "expr.h"

94

#include "initcode.h"

95

96

extern int a3_lex();

97

98

99

100

/* Line 198 of skeleton.m4 */

101

#line 102 "parser.tab.c"

102

103

/* Enabling traces. */

104

#ifndef YYDEBUG

105

# define YYDEBUG 0

106

#endif

107

108

/* Enabling verbose error messages. */

109

#ifdef YYERROR_VERBOSE

110

# undef YYERROR_VERBOSE

111

# define YYERROR_VERBOSE 1

112

#else

113

# define YYERROR_VERBOSE 1

114

#endif

115

116

/* Enabling the token table. */

117

#ifndef YYTOKEN_TABLE

118

# define YYTOKEN_TABLE 0

119

#endif

120

121

122

/* Tokens. */

123

#ifndef YYTOKENTYPE

124

# define YYTOKENTYPE

125

/* Put the tokens into the symbol table, so that GDB and other debuggers

126

know about them. */

127

enum yytokentype {

128

T_IDENTIFIER = 258,

129

T_NAMESPACE = 259,

130

T_STRING = 260,

131

T_REGEXP = 261,

132

T_EMPTY = 262,

133

T_INT = 263,

134

T_UINT = 264,

135

T_FLOAT = 265,

136

T_FOR = 266,

137

T_WHILE = 267,

138

T_DO = 268,

139

T_SWITCH = 269,

140

KW_IMPLEMENTS = 270,

141

KW_NAMESPACE = 271,

142

KW_PACKAGE = 272,

143

KW_PROTECTED = 273,

144

KW_ARGUMENTS = 274,

145

KW_PUBLIC = 275,

146

KW_PRIVATE = 276,

147

KW_USE = 277,

148

KW_INTERNAL = 278,

149

KW_NEW = 279,

150

KW_NATIVE = 280,

151

KW_FUNCTION = 281,

152

KW_FINALLY = 282,

153

KW_UNDEFINED = 283,

154

KW_NAN = 284,

155

KW_CONTINUE = 285,

156

KW_CLASS = 286,

157

KW_CONST = 287,

158

KW_CATCH = 288,

159

KW_CASE = 289,

160

KW_SET = 290,

161

KW_VOID = 291,

162

KW_THROW = 292,

163

KW_STATIC = 293,

164

KW_WITH = 294,

165

KW_INSTANCEOF = 295,

166

KW_IMPORT = 296,

167

KW_RETURN = 297,

168

KW_TYPEOF = 298,

169

KW_INTERFACE = 299,

170

KW_NULL = 300,

171

KW_VAR = 301,

172

KW_DYNAMIC = 302,

173

KW_OVERRIDE = 303,

174

KW_FINAL = 304,

175

KW_EACH = 305,

176

KW_GET = 306,

177

KW_TRY = 307,

178

KW_SUPER = 308,

179

KW_EXTENDS = 309,

180

KW_FALSE = 310,

181

KW_TRUE = 311,

182

KW_BOOLEAN = 312,

183

KW_UINT = 313,

184

KW_INT = 314,

185

KW_NUMBER = 315,

186

KW_STRING = 316,

187

KW_DEFAULT = 317,

188

KW_DEFAULT_XML = 318,

189

KW_DELETE = 319,

190

KW_IF = 320,

191

KW_ELSE = 321,

192

KW_BREAK = 322,

193

KW_IS = 323,

194

KW_IN = 324,

195

KW_AS = 325,

196

T_DICTSTART = 326,

197

T_EQEQ = 327,

198

T_EQEQEQ = 328,

199

T_NE = 329,

200

T_NEE = 330,

201

T_LE = 331,

202

T_GE = 332,

203

T_ORBY = 333,

204

T_DIVBY = 334,

205

T_MODBY = 335,

206

T_MULBY = 336,

207

T_ANDBY = 337,

208

T_PLUSBY = 338,

209

T_MINUSBY = 339,

210

T_XORBY = 340,

211

T_SHRBY = 341,

212

T_SHLBY = 342,

213

T_USHRBY = 343,

214

T_OROR = 344,

215

T_ANDAND = 345,

216

T_COLONCOLON = 346,

217

T_MINUSMINUS = 347,

218

T_PLUSPLUS = 348,

219

T_DOTDOT = 349,

220

T_DOTDOTDOT = 350,

221

T_SHL = 351,

222

T_USHR = 352,

223

T_SHR = 353,

224

prec_none = 354,

225

below_semicolon = 355,

226

below_assignment = 356,

227

below_lt = 357,

228

below_minus = 358,

229

minusminus_prefix = 359,

230

plusplus_prefix = 360,

231

below_curly = 361,

232

new2 = 362,

233

above_identifier = 363,

234

below_else = 364,

235

above_function = 365

236

};

237

#endif

238

239

240

241

#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED

242

typedef union

243

/* Line 223 of skeleton.m4 */

244

#line 47 "parser.y"

245

tokenunion

246

{

247

248

/* Line 223 of skeleton.m4 */

249

#line 47 "parser.y"

250

251

enum yytokentype token;

252

253

classinfo_t*classinfo;

254

classinfo_list_t*classinfo_list;

255

slotinfo_t*slotinfo;

256

slotinfo_list_t*slotinfo_list;

257

258

int number_int;

259

unsigned int number_uint;

260

double number_float;

261

code_t*code;

262

typedcode_t value;

263

//typedcode_list_t*value_list;

264

codeandnumber_t value_list;

265

param_t* param;

266

params_t params;

267

string_t str;

268

char*id;

269

constant_t*constant;

270

for_start_t for_start;

271

abc_exception_t *exception;

272

regexp_t regexp;

273

modifiers_t flags;

274

namespace_decl_t* namespace_decl;

275

node_t*node;

276

struct {

277

abc_exception_list_t *l;

278

code_t*finally;

279

} catch_list;

280

281

282

283

/* Line 223 of skeleton.m4 */

284

#line 285 "parser.tab.c"

285

} YYSTYPE;

286

# define YYSTYPE_IS_TRIVIAL 1

287

# define yystype YYSTYPE /* obsolescent; will be withdrawn */

288

# define YYSTYPE_IS_DECLARED 1

289

#endif

290

291

292

/* Copy the second part of user declarations. */

293

294

/* Line 273 of skeleton.m4 */

295

#line 276 "parser.y"

296

297

298

static int a3_error(char*s)

299

{

300

syntaxerror("%s", s);

301

return 0; //make gcc happy

302

}

303

304

static void parsererror(const char*file, int line, const char*f)

305

{

306

syntaxerror("internal error in %s, %s:%d", f, file, line);

307

}

308

309

#define parserassert(b) {if(!(b)) parsererror(__FILE__, __LINE__,__func__);}

310

311

312

static char* concat2(const char* t1, const char* t2)

313

{

314

int l1 = strlen(t1);

315

int l2 = strlen(t2);

316

char*text = malloc(l1+l2+1);

317

memcpy(text , t1, l1);

318

memcpy(text+l1, t2, l2);

319

text[l1+l2] = 0;

320

return text;

321

}

322

static char* concat3(const char* t1, const char* t2, const char* t3)

323

{

324

int l1 = strlen(t1);

325

int l2 = strlen(t2);

326

int l3 = strlen(t3);

327

char*text = malloc(l1+l2+l3+1);

328

memcpy(text , t1, l1);

329

memcpy(text+l1, t2, l2);

330

memcpy(text+l1+l2, t3, l3);

331

text[l1+l2+l3] = 0;

332

return text;

333

}

334

335

typedef struct _import {

336

char*package;

337

} import_t;

338

DECLARE_LIST(import);

339

340

DECLARE(methodstate);

341

DECLARE_LIST(methodstate);

342

343

typedef struct _classstate {

344

/* class data */

345

classinfo_t*info;

346

abc_class_t*abc;

347

348

methodstate_t*init;

349

methodstate_t*static_init;

350

//code_t*init;

351

//code_t*static_init;

352

parsedclass_t*dependencies;

353

354

char has_constructor;

355

} classstate_t;

356

357

struct _methodstate {

358

/* method data */

359

methodinfo_t*info;

360

char has_exceptions;

361

char late_binding;

362

char is_constructor;

363

char has_super;

364

char is_global;

365

char is_static;

366

int variable_count;

367

368

dict_t*unresolved_variables;

369

370

char inner;

371

char uses_parent_function;

372

char no_variable_scoping;

373

int uses_slots;

374

dict_t*slots;

375

int activation_var;

376

377

int need_arguments;

378

379

abc_method_t*abc;

380

int var_index; // for inner methods

381

int slot_index; // for inner methods

382

char is_a_slot; // for inner methods

383

384

code_t*header;

385

386

code_t*scope_code;

387

abc_exception_list_t*exceptions;

388

389

methodstate_list_t*innerfunctions;

390

};

391

392

typedef struct _state {

393

struct _state*old;

394

int level;

395

396

char*package;

397

import_list_t*wildcard_imports;

398

dict_t*import_toplevel_packages;

399

dict_t*imports;

400

401

namespace_list_t*active_namespace_urls;

402

403

char has_own_imports;

404

char new_vars; // e.g. transition between two functions

405

char xmlfilter; // are we inside a xmlobj..() filter?

406

407

classstate_t*cls;

408

methodstate_t*method;

409

410

char*exception_name;

411

412

int switch_var;

413

414

dict_t*vars;

415

dict_t*allvars; // also contains variables from sublevels

416

} state_t;

417

418

typedef struct _global {

419

abc_file_t*file;

420

421

parsedclass_list_t*classes;

422

abc_script_t*classinit;

423

424

abc_script_t*init; //package-level code

425

426

dict_t*token2info;

427

dict_t*file2token2info;

428

} global_t;

429

430

static global_t*global = 0;

431

static state_t* state = 0;

432

433

DECLARE_LIST(state);

434

435

/* protected handling here is a big hack: we just assume the protectedns

436

is package:class. the correct approach would be to add the proper

437

namespace to all protected members in the registry, even though that

438

would slow down searching */

439

#define MEMBER_MULTINAME(m,f,n) \

440

multiname_t m;\

441

namespace_t m##_ns;\

442

if(f) { \

443

m##_ns.access = ((slotinfo_t*)(f))->access; \

444

if(m##_ns.access == ACCESS_NAMESPACE) \

445

m##_ns.name = ((slotinfo_t*)(f))->package; \

446

else if(m##_ns.access == ACCESS_PROTECTED && (f)->parent) \

447

m##_ns.name = concat3((f)->parent->package,":",(f)->parent->name); \

448

else \

449

m##_ns.name = ""; \

450

m.type = QNAME; \

451

m.ns = &m##_ns; \

452

m.namespace_set = 0; \

453

m.name = ((slotinfo_t*)(f))->name; \

454

} else { \

455

m.type = MULTINAME; \

456

m.ns =0; \

457

m.namespace_set = &nopackage_namespace_set; \

458

m.name = n; \

459

}

460

461

/* warning: list length of namespace set is undefined */

462

#define MULTINAME_LATE(m, access, package) \

463

namespace_t m##_ns = {access, package}; \

464

namespace_set_t m##_nsset; \

465

namespace_list_t m##_l;m##_l.next = 0; \

466

m##_nsset.namespaces = &m##_l; \

467

m##_nsset = m##_nsset; \

468

m##_l.namespace = &m##_ns; \

469

multiname_t m = {MULTINAMEL, 0, &m##_nsset, 0};

470

471

static namespace_t ns1 = {ACCESS_PRIVATE, ""};

472

static namespace_t ns2 = {ACCESS_PROTECTED, ""};

473

static namespace_t ns3 = {ACCESS_PACKAGEINTERNAL, ""};

474

static namespace_t stdns = {ACCESS_PACKAGE, ""};

475

static namespace_list_t nl4 = {&stdns,0};

476

static namespace_list_t nl3 = {&ns3,&nl4};

477

static namespace_list_t nl2 = {&ns2,&nl3};

478

static namespace_list_t nl1 = {&ns1,&nl2};

479

static namespace_set_t nopackage_namespace_set = {&nl1};

480

481

static dict_t*definitions=0;

482

void as3_set_define(const char*c)

483

{

484

if(!definitions)

485

definitions = dict_new();

486

if(!dict_contains(definitions,c))

487

dict_put(definitions,c,0);

488

}

489

490

static void new_state()

491

{

492

NEW(state_t, s);

493

state_t*oldstate = state;

494

if(state)

495

memcpy(s, state, sizeof(state_t)); //shallow copy

496

if(!s->imports) {

497

s->imports = dict_new();

498

}

499

if(!s->import_toplevel_packages) {

500

s->import_toplevel_packages = dict_new();

501

}

502

state = s;

503

state->level++;

504

state->has_own_imports = 0;

505

state->vars = dict_new();

506

state->old = oldstate;

507

state->new_vars = 0;

508

509

trie_remember(active_namespaces);

510

511

if(oldstate)

512

state->active_namespace_urls = list_clone(oldstate->active_namespace_urls);

513

}

514

515

static void state_destroy(state_t*state)

516

{

517

if(state->has_own_imports) {

518

list_free(state->wildcard_imports);

519

dict_destroy(state->imports);state->imports=0;

520

}

521

if(state->imports && (!state->old || state->old->imports!=state->imports)) {

522

dict_destroy(state->imports);state->imports=0;

523

}

524

if(state->vars) {

525

dict_destroy(state->vars);state->vars=0;

526

}

527

if(state->new_vars && state->allvars) {

528

parserassert(!state->old || state->old->allvars != state->allvars);

529

DICT_ITERATE_DATA(state->allvars, void*, data) {

530

free(data);

531

}

532

dict_destroy(state->allvars);

533

}

534

535

list_free(state->active_namespace_urls)

536

state->active_namespace_urls = 0;

537

538

free(state);

539

}

540

541

static void old_state()

542

{

543

trie_rollback(active_namespaces);

544

545

if(!state || !state->old)

546

syntaxerror("invalid nesting");

547

state_t*leaving = state;

548

549

state = state->old;

550

551

if(as3_pass>1 && leaving->method && leaving->method != state->method && !leaving->method->inner) {

552

free(leaving->method);

553

leaving->method=0;

554

}

555

if(as3_pass>1 && leaving->cls && leaving->cls != state->cls) {

556

free(leaving->cls);

557

leaving->cls=0;

558

}

559

560

state_destroy(leaving);

561

}

562

563

static code_t* method_header(methodstate_t*m);

564

static code_t* wrap_function(code_t*c,code_t*header, code_t*body);

565

static void function_initvars(methodstate_t*m, char has_params, params_t*params, int flags, char var0);

566

567

568

static char* internal_filename_package = 0;

569

void initialize_file(char*filename)

570

{

571

if(state) {

572

syntaxerror("invalid call to initialize_file during parsing of another file");

573

}

574

575

active_namespaces = trie_new();

576

577

new_state();

578

state->package = internal_filename_package = strdup(filename);

579

state->allvars = dict_new();

580

581

global->token2info = dict_lookup(global->file2token2info,

582

current_filename // use long version

583

);

584

if(!global->token2info) {

585

global->token2info = dict_new2(&ptr_type);

586

dict_put(global->file2token2info, current_filename, global->token2info);

587

}

588

589

if(as3_pass==1) {

590

state->method = rfx_calloc(sizeof(methodstate_t));

591

dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->method);

592

state->method->late_binding = 1; // init scripts use getglobalscope, so we need a getlocal0/pushscope

593

} else {

594

state->method = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);

595

state->method->variable_count = 0;

596

if(!state->method)

597

syntaxerror("internal error: skewed tokencount");

598

function_initvars(state->method, 0, 0, 0, 1);

599

global->init = 0;

600

}

601

}

602

603

void finish_file()

604

{

605

if(!state || state->level!=1) {

606

syntaxerror("unexpected end of file in pass %d", as3_pass);

607

}

608

609

if(as3_pass==2) {

610

dict_del(global->file2token2info, current_filename);

611

code_t*header = method_header(state->method);

612

//if(global->init->method->body->code || global->init->traits) {

613

if(global->init) {

614

code_t*c = wrap_function(header, 0, global->init->method->body->code);

615

global->init->method->body->code = abc_returnvoid(c);

616

free(state->method);state->method=0;

617

}

618

}

619

620

//free(state->package);state->package=0; // used in registry

621

state_destroy(state);state=0;

622

}

623

624

void initialize_parser()

625

{

626

global = rfx_calloc(sizeof(global_t));

627

global->file = abc_file_new();

628

global->file->flags &= ~ABCFILE_LAZY;

629

global->file2token2info = dict_new();

630

global->token2info = 0;

631

global->classinit = abc_initscript(global->file);

632

}

633

634

void* finish_parser()

635

{

636

dict_free_all(global->file2token2info, 1, (void*)dict_destroy);

637

global->token2info=0;

638

639

initcode_add_classlist(global->classinit, global->classes);

640

641

return global->file;

642

}

643

644

typedef struct _variable {

645

int index;

646

classinfo_t*type;

647

char init;

648

char kill;

649

char is_parameter;

650

methodstate_t*is_inner_method;

651

} variable_t;

652

653

static variable_t* find_variable(state_t*s, char*name)

654

{

655

if(s->method->no_variable_scoping) {

656

return dict_lookup(s->allvars, name);

657

} else {

658

state_t*top = s;

659

while(s) {

660

variable_t*v = 0;

661

v = dict_lookup(s->vars, name);

662

if(v) return v;

663

if(s->new_vars) break;

664

s = s->old;

665

}

666

return 0;

667

}

668

}

669

static variable_t* find_slot(state_t*s, const char*name)

670

{

671

if(s->method && s->method->slots)

672

return dict_lookup(s->method->slots, name);

673

return 0;

674

}

675

676

static variable_t* find_variable_safe(state_t*s, char*name)

677

{

678

variable_t* v = find_variable(s, name);

679

if(!v)

680

syntaxerror("undefined variable: %s", name);

681

return v;

682

}

683

684

static char variable_exists(char*name)

685

{

686

return dict_contains(state->vars, name);

687

}

688

689

static code_t*defaultvalue(code_t*c, classinfo_t*type)

690

{

691

if(TYPE_IS_INT(type)) {

692

c = abc_pushbyte(c, 0);

693

} else if(TYPE_IS_UINT(type)) {

694

c = abc_pushuint(c, 0);

695

} else if(TYPE_IS_FLOAT(type)) {

696

c = abc_pushnan(c);

697

} else if(TYPE_IS_BOOLEAN(type)) {

698

c = abc_pushfalse(c);

699

} else if(TYPE_IS_STRING(type)) {

700

c = abc_pushnull(c);

701

c = abc_coerce_s(c);

702

} else if(!type) {

703

//c = abc_pushundefined(c);

704

syntaxerror("internal error: can't generate default value for * type");

705

} else {

706

c = abc_pushnull(c);

707

MULTINAME(m, type);

708

c = abc_coerce2(c, &m);

709

}

710

return c;

711

}

712

713

static int alloc_local()

714

{

715

return state->method->variable_count++;

716

}

717

718

static variable_t* new_variable2(const char*name, classinfo_t*type, char init, char maybeslot)

719

{

720

if(maybeslot) {

721

variable_t*v = find_slot(state, name);

722

if(v) {

723

alloc_local();

724

return v;

725

}

726

}

727

728

NEW(variable_t, v);

729

v->index = alloc_local();

730

v->type = type;

731

v->init = v->kill = init;

732

733

if(name) {

734

if(!state->method->no_variable_scoping)

735

{

736

if(dict_contains(state->vars, name))

737

syntaxerror("variable %s already defined", name);

738

dict_put(state->vars, name, v);

739

}

740

if(state->method->no_variable_scoping &&

741

as3_pass==2 &&

742

dict_contains(state->allvars, name))

743

{

744

variable_t*v = dict_lookup(state->allvars, name);

745

if(v->type != type)

746

syntaxerror("variable %s already defined.", name);

747

return v;

748

}

749

dict_put(state->allvars, name, v);

750

}

751

752

return v;

753

}

754

static int new_variable(const char*name, classinfo_t*type, char init, char maybeslot)

755

{

756

return new_variable2(name, type, init, maybeslot)->index;

757

}

758

759

#define TEMPVARNAME "__as3_temp__"

760

int gettempvar()

761

{

762

variable_t*v = find_variable(state, TEMPVARNAME);

763

int i;

764

if(v)

765

i = v->index;

766

else

767

i = new_variable(TEMPVARNAME, 0, 0, 0);

768

parserassert(i);

769

return i;

770

}

771

772

static code_t* var_block(code_t*body, dict_t*vars)

773

{

774

code_t*c = 0;

775

code_t*k = 0;

776

int t;

777

DICT_ITERATE_DATA(vars, variable_t*, v) {

778

if(v->type && v->init) {

779

c = defaultvalue(c, v->type);

780

c = abc_setlocal(c, v->index);

781

}

782

if(v->type && v->kill) {

783

k = abc_kill(k, v->index);

784

}

785

}

786

787

if(k) {

788

code_t*x = body;

789

while(x) {

790

if(x->opcode== OPCODE___BREAK__ ||

791

x->opcode== OPCODE___CONTINUE__) {

792

/* link kill code before break/continue */

793

code_t*e = code_dup(k);

794

code_t*s = code_start(e);

795

s->prev = x->prev;

796

if(x->prev) {

797

x->prev->next = s;

798

}

799

e->next = x;

800

x->prev = e;

801

}

802

x = x->prev;

803

}

804

}

805

806

c = code_append(c, body);

807

c = code_append(c, k);

808

return c;

809

}

810

811

static void unknown_variable(char*name)

812

{

813

if(!state->method->unresolved_variables)

814

state->method->unresolved_variables = dict_new();

815

if(!dict_contains(state->method->unresolved_variables, name))

816

dict_put(state->method->unresolved_variables, name, 0);

817

}

818

819

static code_t* add_scope_code(code_t*c, methodstate_t*m, char init)

820

{

821

if(m->uses_slots || (m->late_binding && !m->inner)) { //???? especially inner functions need the pushscope

822

c = abc_getlocal_0(c);

823

c = abc_pushscope(c);

824

}

825

if(m->uses_slots) {

826

/* FIXME: this alloc_local() causes variable indexes to be

827

different in pass2 than in pass1 */

828

if(!m->activation_var) {

829

m->activation_var = alloc_local();

830

}

831

if(init) {

832

c = abc_newactivation(c);

833

c = abc_dup(c);

834

c = abc_pushscope(c);

835

c = abc_setlocal(c, m->activation_var);

836

} else {

837

c = abc_getlocal(c, m->activation_var);

838

c = abc_pushscope(c);

839

}

840

}

841

return c;

842

}

843

844

static code_t* method_header(methodstate_t*m)

845

{

846

code_t*c = 0;

847

848

c = add_scope_code(c, m, 1);

849

850

methodstate_list_t*l = m->innerfunctions;

851

while(l) {

852

parserassert(l->methodstate->abc);

853

if(m->uses_slots && l->methodstate->is_a_slot) {

854

c = abc_getscopeobject(c, 1);

855

c = abc_newfunction(c, l->methodstate->abc);

856

c = abc_dup(c);

857

c = abc_setlocal(c, l->methodstate->var_index);

858

c = abc_setslot(c, l->methodstate->slot_index);

859

} else {

860

c = abc_newfunction(c, l->methodstate->abc);

861

c = abc_setlocal(c, l->methodstate->var_index);

862

}

863

free(l->methodstate);l->methodstate=0;

864

l = l->next;

865

}

866

if(m->header) {

867

c = code_append(c, m->header);

868

m->header = 0;

869

}

870

if(m->is_constructor && !m->has_super) {

871

// call default constructor

872

c = abc_getlocal_0(c);

873

c = abc_constructsuper(c, 0);

874

}

875

876

if(m->slots) {

877

/* all parameters that are used by inner functions

878

need to be copied from local to slot */

879

parserassert(m->activation_var);

880

DICT_ITERATE_ITEMS(m->slots,char*,name,variable_t*,v) {

881

if(v->is_parameter) {

882

c = abc_getlocal(c, m->activation_var);

883

c = abc_getlocal(c, v->index);

884

c = abc_setslot(c, v->index);

885

}

886

}

887

}

888

list_free(m->innerfunctions);

889

m->innerfunctions = 0;

890

return c;

891

}

892

893

894

static code_t* wrap_function(code_t*c,code_t*header, code_t*body)

895

{

896

c = code_append(c, header);

897

c = code_append(c, var_block(body, state->method->no_variable_scoping?state->allvars:state->vars));

898

/* append return if necessary */

899

if(!c || (c->opcode != OPCODE_RETURNVOID &&

900

c->opcode != OPCODE_RETURNVALUE)) {

901

c = abc_returnvoid(c);

902

}

903

return c;

904

}

905

906

static void startpackage(char*name)

907

{

908

new_state();

909

state->package = strdup(name);

910

}

911

static void endpackage()

912

{

913

//used e.g. in classinfo_register:

914

//free(state->package);state->package=0;

915

old_state();

916

}

917

918

#define FLAG_PUBLIC 256

919

#define FLAG_PROTECTED 512

920

#define FLAG_PRIVATE 1024

921

#define FLAG_PACKAGEINTERNAL 2048

922

#define FLAG_NAMESPACE 4096

923

924

static namespace_t modifiers2access(modifiers_t*mod)

925

{

926

namespace_t ns;

927

ns.access = 0;

928

ns.name = "";

929

if(mod->flags&FLAG_NAMESPACE) {

930

if(mod->flags&(FLAG_PRIVATE|FLAG_PROTECTED|FLAG_PACKAGEINTERNAL))

931

syntaxerror("invalid combination of access levels and namespaces");

932

ns.access = ACCESS_NAMESPACE;

933

state_t*s = state;

934

const char*url = (const char*)trie_lookup(active_namespaces, mod->ns);

935

if(!url) {

936

/* shouldn't happen- the tokenizer only reports something as a namespace

937

if it was already registered */

938

trie_dump(active_namespaces);

939

syntaxerror("unknown namespace: %s", mod->ns);

940

}

941

ns.name = url;

942

} else if(mod->flags&FLAG_PUBLIC) {

943

if(mod->flags&(FLAG_PRIVATE|FLAG_PROTECTED|FLAG_PACKAGEINTERNAL))

944

syntaxerror("invalid combination of access levels");

945

ns.access = ACCESS_PACKAGE;

946

} else if(mod->flags&FLAG_PRIVATE) {

947

if(mod->flags&(FLAG_PUBLIC|FLAG_PROTECTED|FLAG_PACKAGEINTERNAL))

948

syntaxerror("invalid combination of access levels");

949

ns.access = ACCESS_PRIVATE;

950

} else if(mod->flags&FLAG_PROTECTED) {

951

if(mod->flags&(FLAG_PUBLIC|FLAG_PRIVATE|FLAG_PACKAGEINTERNAL))

952

syntaxerror("invalid combination of access levels");

953

ns.access = ACCESS_PROTECTED;

954

} else {

955

ns.access = ACCESS_PACKAGEINTERNAL;

956

}

957

return ns;

958

}

959

static slotinfo_t* find_class(const char*name);

960

961

static memberinfo_t* findmember_nsset(classinfo_t*cls, const char*name, char recurse)

962

{

963

return registry_findmember_nsset(cls, state->active_namespace_urls, name, recurse);

964

}

965

966

static void innerfunctions2vars(methodstate_t*m)

967

{

968

methodstate_list_t*l = m->innerfunctions;

969

while(l) {

970

methodstate_t*m = l->methodstate;

971

972

variable_t* v = new_variable2(m->info->name, TYPE_FUNCTION(m->info), 0, 0);

973

m->var_index = v->index;

974

if(m->is_a_slot)

975

m->slot_index = m->is_a_slot;

976

v->is_inner_method = m;

977

l = l->next;

978

}

979

}

980

981

static void function_initvars(methodstate_t*m, char has_params, params_t*params, int flags, char var0)

982

{

983

if(var0) {

984

int index = -1;

985

if(m->inner)

986

index = new_variable("this", 0, 0, 0);

987

else if(!m->is_global)

988

index = new_variable((flags&FLAG_STATIC)?"class":"this", state->cls?state->cls->info:0, 0, 0);

989

else

990

index = new_variable("globalscope", 0, 0, 0);

991

parserassert(!index);

992

}

993

994

if(has_params) {

995

param_list_t*p=0;

996

for(p=params->list;p;p=p->next) {

997

variable_t*v = new_variable2(p->param->name, p->param->type, 0, 1);

998

v->is_parameter = 1;

999

}

1000

if(as3_pass==2 && m->need_arguments) {

1001

/* arguments can never be used by an innerfunction (the inner functions

1002

have their own arguments var), so it's ok to not initialize this until

1003

pass 2. (We don't know whether we need it before, anyway) */

1004

variable_t*v = new_variable2("arguments", TYPE_ARRAY, 0, 0);

1005

m->need_arguments = v->index;

1006

}

1007

}

1008

1009

innerfunctions2vars(m);

1010

1011

if(as3_pass==2) {

1012

m->scope_code = add_scope_code(m->scope_code, m, 0);

1013

if(m->slots) {

1014

/* exchange unresolved identifiers with the actual objects */

1015

DICT_ITERATE_ITEMS(m->slots, char*, name, variable_t*, v) {

1016

if(v->type && v->type->kind == INFOTYPE_UNRESOLVED) {

1017

classinfo_t*type = (classinfo_t*)registry_resolve((slotinfo_t*)v->type);

1018

if(!type || type->kind != INFOTYPE_CLASS) {

1019

syntaxerror("Couldn't find class %s::%s (%s)", v->type->package, v->type->name, name);

1020

}

1021

v->type = type;

1022

}

1023

}

1024

}

1025

}

1026

}

1027

1028

1029

char*as3_globalclass=0;

1030

static void startclass(modifiers_t* mod, char*classname, classinfo_t*extends, classinfo_list_t*implements)

1031

{

1032

if(state->cls) {

1033

syntaxerror("inner classes now allowed");

1034

}

1035

1036

new_state();

1037

token_list_t*t=0;

1038

classinfo_list_t*mlist=0;

1039

1040

if(mod->flags&~(FLAG_PACKAGEINTERNAL|FLAG_PUBLIC|FLAG_FINAL|FLAG_DYNAMIC|FLAG_INTERFACE))

1041

syntaxerror("invalid modifier(s)");

1042

1043

if((mod->flags&(FLAG_PUBLIC|FLAG_PACKAGEINTERNAL)) == (FLAG_PUBLIC|FLAG_PACKAGEINTERNAL))

1044

syntaxerror("public and internal not supported at the same time.");

1045

1046

if((mod->flags&(FLAG_PROTECTED|FLAG_STATIC)) == (FLAG_PROTECTED|FLAG_STATIC))

1047

syntaxerror("protected and static not supported at the same time.");

1048

1049

//if(!(mod->flags&FLAG_INTERFACE) && !extends) {

1050

if(!(mod->flags&FLAG_INTERFACE) && !extends) {

1051

// all classes extend object

1052

extends = registry_getobjectclass();

1053

}

1054

1055

/* create the class name, together with the proper attributes */

1056

int access=0;

1057

char*package=0;

1058

1059

if(!(mod->flags&FLAG_PUBLIC) && state->package==internal_filename_package) {

1060

access = ACCESS_PRIVATE; package = internal_filename_package;

1061

} else if(!(mod->flags&FLAG_PUBLIC) && state->package!=internal_filename_package) {

1062

access = ACCESS_PACKAGEINTERNAL; package = state->package;

1063

} else if(state->package!=internal_filename_package) {

1064

access = ACCESS_PACKAGE; package = state->package;

1065

} else {

1066

syntaxerror("public classes only allowed inside a package");

1067

}

1068

1069

if(as3_pass==1) {

1070

state->cls = rfx_calloc(sizeof(classstate_t));

1071

state->cls->init = rfx_calloc(sizeof(methodstate_t));

1072

state->cls->static_init = rfx_calloc(sizeof(methodstate_t));

1073

state->cls->static_init->is_static=FLAG_STATIC;

1074

state->cls->static_init->variable_count=1;

1075

/* notice: we make no effort to initialize the top variable (local0) here,

1076

even though it has special meaning. We just rely on the fact

1077

that pass 1 won't do anything with variables */

1078

1079

dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->cls);

1080

1081

/* set current method to constructor- all code within the class-level (except

1082

static variable initializations) will be executed during construction time */

1083

state->method = state->cls->init;

1084

1085

if(registry_find(package, classname)) {

1086

syntaxerror("Package \"%s\" already contains a class called \"%s\"", package, classname);

1087

}

1088

/* build info struct */

1089

int num_interfaces = (list_length(implements));

1090

state->cls->info = classinfo_register(access, package, classname, num_interfaces);

1091

state->cls->info->flags |= mod->flags & (FLAG_DYNAMIC|FLAG_INTERFACE|FLAG_FINAL);

1092

state->cls->info->superclass = extends;

1093

1094

int pos = 0;

1095

classinfo_list_t*l = implements;

1096

for(l=implements;l;l=l->next) {

1097

state->cls->info->interfaces[pos++] = l->classinfo;

1098

}

1099

}

1100

1101

if(as3_pass == 2) {

1102

state->cls = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);

1103

1104

state->method = state->cls->init;

1105

parserassert(state->cls && state->cls->info);

1106

1107

function_initvars(state->cls->init, 0, 0, 0, 1);

1108

function_initvars(state->cls->static_init, 0, 0, 0, 0);

1109

1110

if(extends && (extends->flags & FLAG_FINAL))

1111

syntaxerror("Can't extend final class '%s'", extends->name);

1112

1113

int pos = 0;

1114

while(state->cls->info->interfaces[pos]) {

1115

if(!(state->cls->info->interfaces[pos]->flags & FLAG_INTERFACE))

1116

syntaxerror("'%s' is not an interface",

1117

state->cls->info->interfaces[pos]->name);

1118

pos++;

1119

}

1120

1121

/* generate the abc code for this class */

1122

MULTINAME(classname2,state->cls->info);

1123

multiname_t*extends2 = sig2mname(extends);

1124

1125

/* don't add the class to the class index just yet- that will be done later

1126

by initscript */

1127

state->cls->abc = abc_class_new(0, &classname2, extends2);

1128

state->cls->abc->file = global->file;

1129

1130

multiname_destroy(extends2);

1131

if(state->cls->info->flags&FLAG_FINAL) abc_class_final(state->cls->abc);

1132

if(!(state->cls->info->flags&FLAG_DYNAMIC)) abc_class_sealed(state->cls->abc);

1133

if(state->cls->info->flags&FLAG_INTERFACE) {

1134

abc_class_interface(state->cls->abc);

1135

}

1136

1137

for(mlist=implements;mlist;mlist=mlist->next) {

1138

MULTINAME(m, mlist->classinfo);

1139

abc_class_add_interface(state->cls->abc, &m);

1140

}

1141

1142

state->cls->dependencies = parsedclass_new(state->cls->info, state->cls->abc);

1143

list_append(global->classes, state->cls->dependencies);

1144

1145

/* flash.display.MovieClip handling */

1146

if(!as3_globalclass && (mod->flags&FLAG_PUBLIC) && slotinfo_equals((slotinfo_t*)registry_getMovieClip(),(slotinfo_t*)extends)) {

1147

if(state->package && state->package[0]) {

1148

as3_globalclass = concat3(state->package, ".", classname);

1149

} else {

1150

as3_globalclass = strdup(classname);

1151

}

1152

}

1153

}

1154

}

1155

1156

static void endclass()

1157

{

1158

if(as3_pass == 2) {

1159

if(!state->cls->has_constructor && !(state->cls->info->flags&FLAG_INTERFACE)) {

1160

code_t*c = 0;

1161

c = abc_getlocal_0(c);

1162

c = abc_constructsuper(c, 0);

1163

state->cls->init->header = code_append(state->cls->init->header, c);

1164

state->cls->has_constructor=1;

1165

}

1166

if(state->cls->init) {

1167

if(state->cls->info->flags&FLAG_INTERFACE) {

1168

if(state->cls->init->header)

1169

syntaxerror("interface can not have class-level code");

1170

} else {

1171

abc_method_t*m = abc_class_getconstructor(state->cls->abc, 0);

1172

code_t*c = method_header(state->cls->init);

1173

m->body->code = wrap_function(c, 0, m->body->code);

1174

}

1175

}

1176

if(state->cls->static_init) {

1177

abc_method_t*m = abc_class_getstaticconstructor(state->cls->abc, 0);

1178

code_t*c = method_header(state->cls->static_init);

1179

m->body->code = wrap_function(c, 0, m->body->code);

1180

}

1181

1182

trait_list_t*trait = state->cls->abc->traits;

1183

/* switch all protected members to the protected ns of this class */

1184

while(trait) {

1185

trait_t*t = trait->trait;

1186

if(t->name->ns->access == ACCESS_PROTECTED) {

1187

if(!state->cls->abc->protectedNS) {

1188

char*n = concat3(state->cls->info->package, ":", state->cls->info->name);

1189

state->cls->abc->protectedNS = namespace_new_protected(n);

1190

state->cls->abc->flags |= CLASS_PROTECTED_NS;

1191

}

1192

t->name->ns->name = strdup(state->cls->abc->protectedNS->name);

1193

}

1194

trait = trait->next;

1195

}

1196

}

1197

1198

old_state();

1199

}

1200

1201

void check_code_for_break(code_t*c)

1202

{

1203

while(c) {

1204

if(c->opcode == OPCODE___BREAK__) {

1205

char*name = string_cstr(c->data[0]);

1206

syntaxerror("Unresolved \"break %s\"", name);

1207

}

1208

if(c->opcode == OPCODE___CONTINUE__) {

1209

char*name = string_cstr(c->data[0]);

1210

syntaxerror("Unresolved \"continue %s\"", name);

1211

}

1212

if(c->opcode == OPCODE___RETHROW__) {

1213

syntaxerror("Unresolved \"rethrow\"");

1214

}

1215

if(c->opcode == OPCODE___FALLTHROUGH__) {

1216

syntaxerror("Unresolved \"fallthrough\"");

1217

}

1218

if(c->opcode == OPCODE___PUSHPACKAGE__) {

1219

char*name = string_cstr(c->data[0]);

1220

syntaxerror("Can't reference a package (%s) as such", name);

1221

}

1222

c=c->prev;

1223

}

1224

}

1225

1226

static void check_constant_against_type(classinfo_t*t, constant_t*c)

1227

{

1228

#define xassert(b) if(!(b)) syntaxerror("Invalid default value %s for type '%s'", constant_tostring(c), t->name)

1229

if(TYPE_IS_NUMBER(t)) {

1230

xassert(c->type == CONSTANT_FLOAT

1231

|| c->type == CONSTANT_INT

1232

|| c->type == CONSTANT_UINT);

1233

} else if(TYPE_IS_UINT(t)) {

1234

xassert(c->type == CONSTANT_UINT ||

1235

(c->type == CONSTANT_INT && c->i>=0));

1236

} else if(TYPE_IS_INT(t)) {

1237

xassert(c->type == CONSTANT_INT);

1238

} else if(TYPE_IS_BOOLEAN(t)) {

1239

xassert(c->type == CONSTANT_TRUE

1240

|| c->type == CONSTANT_FALSE);

1241

}

1242

}

1243

1244

static void check_override(memberinfo_t*m, int flags)

1245

{

1246

if(!m)

1247

return;

1248

if(m->parent == state->cls->info)

1249

syntaxerror("class '%s' already contains a method/slot '%s'", m->parent->name, m->name);

1250

if(!m->parent)

1251

syntaxerror("internal error: overriding method %s, which doesn't have parent", m->name);

1252

if(m->access==ACCESS_PRIVATE)

1253

return;

1254

if(m->flags & FLAG_FINAL)

1255

syntaxerror("can't override final member %s", m->name);

1256

1257

/* allow this. it's no issue.

1258

if((m->flags & FLAG_STATIC) && !(flags&FLAG_STATIC))

1259

syntaxerror("can't override static member %s", m->name);*/

1260

1261

if(!(m->flags & FLAG_STATIC) && (flags&FLAG_STATIC))

1262

syntaxerror("can't override non-static member %s with static declaration", m->name);

1263

1264

if(!(flags&FLAG_OVERRIDE) && !(flags&FLAG_STATIC) && !(m->flags&FLAG_STATIC)) {

1265

if(m->parent && !(m->parent->flags&FLAG_INTERFACE)) {

1266

if(m->kind == INFOTYPE_METHOD)

1267

syntaxerror("can't override without explicit 'override' declaration");

1268

else

1269

syntaxerror("can't override '%s'", m->name);

1270

}

1271

}

1272

}

1273

1274

static methodinfo_t*registerfunction(enum yytokentype getset, modifiers_t*mod, char*name, params_t*params, classinfo_t*return_type, int slot)

1275

{

1276

methodinfo_t*minfo = 0;

1277

namespace_t ns = modifiers2access(mod);

1278

if(!state->cls) {

1279

//package method

1280

minfo = methodinfo_register_global(ns.access, state->package, name);

1281

minfo->return_type = return_type;

1282

} else if(getset != KW_GET && getset != KW_SET) {

1283

//class method

1284

memberinfo_t* m = registry_findmember(state->cls->info, ns.name, name, 0);

1285

if(m) {

1286

syntaxerror("class already contains a %s '%s'", infotypename((slotinfo_t*)m), m->name);

1287

}

1288

minfo = methodinfo_register_onclass(state->cls->info, ns.access, ns.name, name);

1289

minfo->return_type = return_type;

1290

// getslot on a member slot only returns "undefined", so no need

1291

// to actually store these

1292

//state->minfo->slot = state->method->abc->method->trait->slot_id;

1293

} else {

1294

//class getter/setter

1295

int gs = getset==KW_GET?SUBTYPE_GET:SUBTYPE_SET;

1296

classinfo_t*type=0;

1297

if(getset == KW_GET) {

1298

type = return_type;

1299

} else if(params->list && params->list->param && !params->list->next) {

1300

type = params->list->param->type;

1301

} else

1302

syntaxerror("setter function needs to take exactly one argument");

1303

// not sure wether to look into superclasses here, too

1304

minfo = (methodinfo_t*)registry_findmember(state->cls->info, ns.name, name, 1);

1305

if(minfo) {

1306

if(minfo->kind!=INFOTYPE_VAR)

1307

syntaxerror("class already contains a method called '%s'", name);

1308

if(!(minfo->subtype & (SUBTYPE_GETSET)))

1309

syntaxerror("class already contains a field called '%s'", name);

1310

if(minfo->subtype & gs)

1311

syntaxerror("getter/setter for '%s' already defined", name);

1312

/* make a setter or getter into a getset */

1313

minfo->subtype |= gs;

1314

1315

/*

1316

FIXME: this check needs to be done in pass 2

1317

1318

if((!minfo->return_type != !type) ||

1319

(minfo->return_type && type &&

1320

!strcmp(minfo->return_type->name, type->name))) {

1321

syntaxerror("different type in getter and setter: %s and %s",

1322

minfo->return_type?minfo->return_type->name:"*",

1323

type?type->name:"*");

1324

}*/

1325

} else {

1326

minfo = methodinfo_register_onclass(state->cls->info, ns.access, ns.name, name);

1327

minfo->kind = INFOTYPE_VAR; //hack

1328

minfo->subtype = gs;

1329

minfo->return_type = type;

1330

}

1331

1332

/* can't assign a slot as getter and setter might have different slots */

1333

//minfo->slot = slot;

1334

}

1335

if(mod->flags&FLAG_FINAL) minfo->flags |= FLAG_FINAL;

1336

if(mod->flags&FLAG_STATIC) minfo->flags |= FLAG_STATIC;

1337

if(mod->flags&FLAG_OVERRIDE) minfo->flags |= FLAG_OVERRIDE;

1338

1339

return minfo;

1340

}

1341

1342

static void innerfunction(char*name, params_t*params, classinfo_t*return_type)

1343

{

1344

//parserassert(state->method && state->method->info);

1345

1346

methodstate_t*parent_method = state->method;

1347

1348

if(as3_pass==1) {

1349

return_type = 0; // not valid in pass 1

1350

}

1351

1352

new_state();

1353

state->new_vars = 1;

1354

state->allvars = dict_new();

1355

1356

if(as3_pass == 1) {

1357

state->method = rfx_calloc(sizeof(methodstate_t));

1358

state->method->inner = 1;

1359

state->method->is_static = parent_method->is_static;

1360

state->method->variable_count = 0;

1361

state->method->abc = rfx_calloc(sizeof(abc_method_t));

1362

1363

NEW(methodinfo_t,minfo);

1364

minfo->kind = INFOTYPE_METHOD;

1365

minfo->access = ACCESS_PACKAGEINTERNAL;

1366

minfo->name = name;

1367

state->method->info = minfo;

1368

1369

if(parent_method)

1370

list_append(parent_method->innerfunctions, state->method);

1371

1372

dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->method);

1373

1374

function_initvars(state->method, 1, params, 0, 1);

1375

}

1376

1377

if(as3_pass == 2) {

1378

state->method = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);

1379

state->method->variable_count = 0;

1380

parserassert(state->method);

1381

1382

state->method->info->return_type = return_type;

1383

function_initvars(state->method, 1, params, 0, 1);

1384

}

1385

}

1386

1387

static void startfunction(modifiers_t*mod, enum yytokentype getset, char*name,

1388

params_t*params, classinfo_t*return_type)

1389

{

1390

if(state->method && state->method->info) {

1391

syntaxerror("not able to start another method scope");

1392

}

1393

new_state();

1394

state->new_vars = 1;

1395

state->allvars = dict_new();

1396

1397

if(as3_pass == 1) {

1398

state->method = rfx_calloc(sizeof(methodstate_t));

1399

state->method->has_super = 0;

1400

state->method->is_static = mod->flags&FLAG_STATIC;

1401

1402

if(state->cls) {

1403

state->method->is_constructor = !strcmp(state->cls->info->name,name);

1404

} else {

1405

state->method->is_global = 1;

1406

state->method->late_binding = 1; // for global methods, always push local_0 on the scope stack

1407

}

1408

if(state->method->is_constructor)

1409

name = "__as3_constructor__";

1410

1411

state->method->info = registerfunction(getset, mod, name, params, return_type, 0);

1412

1413

function_initvars(state->method, 1, params, mod->flags, 1);

1414

1415

dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, state->method);

1416

}

1417

1418

if(as3_pass == 2) {

1419

state->method = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);

1420

state->method->variable_count = 0;

1421

parserassert(state->method);

1422

1423

if(state->cls) {

1424

memberinfo_t*m = registry_findmember(state->cls->info, mod->ns, name, 2);

1425

check_override(m, mod->flags);

1426

}

1427

1428

if(state->cls) {

1429

state->cls->has_constructor |= state->method->is_constructor;

1430

}

1431

1432

function_initvars(state->method, 1, params, mod->flags, 1);

1433

}

1434

}

1435

1436

static abc_method_t* endfunction(modifiers_t*mod, enum yytokentype getset, char*name,

1437

params_t*params, classinfo_t*return_type, code_t*body)

1438

{

1439

if(as3_pass==1) {

1440

innerfunctions2vars(state->method);

1441

1442

methodstate_list_t*ml = state->method->innerfunctions;

1443

1444

dict_t*xvars = dict_new();

1445

1446

if(state->method->unresolved_variables) {

1447

DICT_ITERATE_KEY(state->method->unresolved_variables, char*, vname) {

1448

if(dict_contains(state->allvars, vname)) {

1449

state->method->no_variable_scoping = 1;

1450

as3_warning("function %s uses forward or outer block variable references (%s): switching into compatiblity mode", name, vname);

1451

break;

1452

}

1453

}

1454

}

1455

1456

while(ml) {

1457

methodstate_t*m = ml->methodstate;

1458

parserassert(m->inner);

1459

if(m->unresolved_variables) {

1460

dict_t*d = m->unresolved_variables;

1461

int t;

1462

DICT_ITERATE_KEY(d, char*, id) {

1463

/* check parent method's variables */

1464

variable_t*v;

1465

if((v=find_variable(state, id))) {

1466

m->uses_parent_function = 1;

1467

state->method->uses_slots = 1;

1468

dict_put(xvars, id, 0);

1469

}

1470

}

1471

dict_destroy(m->unresolved_variables);

1472

m->unresolved_variables = 0;

1473

}

1474

ml = ml->next;

1475

}

1476

1477

if(state->method->uses_slots) {

1478

state->method->slots = dict_new();

1479

int i = 1;

1480

DICT_ITERATE_ITEMS(state->vars, char*, name, variable_t*, v) {

1481

if(!name) syntaxerror("internal error");

1482

if(v->index && dict_contains(xvars, name)) {

1483

v->init = v->kill = 0;

1484

v->index = i;

1485

if(v->is_inner_method) {

1486

v->is_inner_method->is_a_slot = i;

1487

}

1488

i++;

1489

dict_put(state->method->slots, name, v);

1490

}

1491

}

1492

state->method->uses_slots = i;

1493

dict_destroy(state->vars);state->vars = 0;

1494

parserassert(state->new_vars);

1495

dict_destroy(state->allvars);state->allvars = 0;

1496

}

1497

old_state();

1498

return 0;

1499

}

1500

1501

if(as3_pass==2) {

1502

/*if(state->method->uses_parent_function){

1503

syntaxerror("accessing variables of parent function from inner functions not supported yet");

1504

}*/

1505

1506

abc_method_t*f = 0;

1507

1508

multiname_t*type2 = sig2mname(return_type);

1509

int slot = 0;

1510

if(state->method->inner) {

1511

f = state->method->abc;

1512

abc_method_init(f, global->file, type2, 1);

1513

} else if(state->method->is_constructor) {

1514

f = abc_class_getconstructor(state->cls->abc, type2);

1515

} else if(!state->method->is_global) {

1516

namespace_t ns = modifiers2access(mod);

1517

multiname_t mname = {QNAME, &ns, 0, name};

1518

if(mod->flags&FLAG_STATIC)

1519

f = abc_class_staticmethod(state->cls->abc, type2, &mname);

1520

else

1521

f = abc_class_method(state->cls->abc, type2, &mname);

1522

slot = f->trait->slot_id;

1523

} else {

1524

namespace_t mname_ns = {state->method->info->access, state->package};

1525

multiname_t mname = {QNAME, &mname_ns, 0, name};

1526

1527

f = abc_method_new(global->file, type2, 1);

1528

if(!global->init) global->init = abc_initscript(global->file);

1529

trait_t*t = trait_new_method(&global->init->traits, multiname_clone(&mname), f);

1530

//abc_code_t*c = global->init->method->body->code;

1531

}

1532

//flash doesn't seem to allow us to access function slots

1533

//state->method->info->slot = slot;

1534

1535

if(mod && mod->flags&FLAG_OVERRIDE) f->trait->attributes |= TRAIT_ATTR_OVERRIDE;

1536

if(getset == KW_GET) f->trait->kind = TRAIT_GETTER;

1537

if(getset == KW_SET) f->trait->kind = TRAIT_SETTER;

1538

if(params->varargs) f->flags |= METHOD_NEED_REST;

1539

if(state->method->need_arguments) f->flags |= METHOD_NEED_ARGUMENTS;

1540

1541

char opt=0;

1542

param_list_t*p=0;

1543

for(p=params->list;p;p=p->next) {

1544

if(params->varargs && !p->next) {

1545

break; //varargs: omit last parameter in function signature

1546

}

1547

multiname_t*m = sig2mname(p->param->type);

1548

list_append(f->parameters, m);

1549

if(p->param->value) {

1550

check_constant_against_type(p->param->type, p->param->value);

1551

opt=1;list_append(f->optional_parameters, p->param->value);

1552

} else if(opt) {

1553

syntaxerror("function %s: non-optional parameter not allowed after optional parameters", name);

1554

}

1555

}

1556

if(state->method->slots) {

1557

DICT_ITERATE_ITEMS(state->method->slots, char*, name, variable_t*, v) {

1558

if(v->index) {

1559

multiname_t*mname = multiname_new(namespace_new(ACCESS_PACKAGE, ""), name);

1560

multiname_t*type = sig2mname(v->type);

1561

trait_t*t = trait_new_member(&f->body->traits, type, mname, 0);

1562

t->slot_id = v->index;

1563

}

1564

}

1565

}

1566

1567

check_code_for_break(body);

1568

1569

/* Seems this works now.

1570

if(state->method->exceptions && state->method->uses_slots) {

1571

as3_warning("try/catch and activation not supported yet within the same method");

1572

}*/

1573

1574

if(f->body) {

1575

f->body->code = body;

1576

f->body->exceptions = state->method->exceptions;

1577

} else { //interface

1578

if(body)

1579

syntaxerror("interface methods can't have a method body");

1580

}

1581

1582

old_state();

1583

return f;

1584

}

1585

1586

return 0;

1587

}

1588

1589

void breakjumpsto(code_t*c, char*name, code_t*jump)

1590

{

1591

while(c) {

1592

if(c->opcode == OPCODE___BREAK__) {

1593

string_t*name2 = c->data[0];

1594

if(!name2->len || !strncmp(name2->str, name, name2->len)) {

1595

c->opcode = OPCODE_JUMP;

1596

c->branch = jump;

1597

}

1598

}

1599

c=c->prev;

1600

}

1601

}

1602

void continuejumpsto(code_t*c, char*name, code_t*jump)

1603

{

1604

while(c) {

1605

if(c->opcode == OPCODE___CONTINUE__) {

1606

string_t*name2 = c->data[0];

1607

if(!name2->len || !strncmp(name2->str, name, name2->len)) {

1608

c->opcode = OPCODE_JUMP;

1609

c->branch = jump;

1610

}

1611

}

1612

c = c->prev;

1613

}

1614

}

1615

1616

code_t*converttype(code_t*c, classinfo_t*from, classinfo_t*to)

1617

{

1618

if(from==to)

1619

return c;

1620

if(!to) {

1621

return abc_coerce_a(c);

1622

}

1623

MULTINAME(m, to);

1624

if(!from) {

1625

// cast an "any" type to a specific type. subject to

1626

// runtime exceptions

1627

return abc_coerce2(c, &m);

1628

}

1629

1630

if((TYPE_IS_NUMBER(from) || TYPE_IS_UINT(from) || TYPE_IS_INT(from)) &&

1631

(TYPE_IS_NUMBER(to) || TYPE_IS_UINT(to) || TYPE_IS_INT(to))) {

1632

// allow conversion between number types

1633

if(TYPE_IS_UINT(to))

1634

return abc_convert_u(c);

1635

else if(TYPE_IS_INT(to))

1636

return abc_convert_i(c);

1637

else if(TYPE_IS_NUMBER(to))

1638

return abc_convert_d(c);

1639

return abc_coerce2(c, &m);

1640

}

1641

1642

if(TYPE_IS_XMLLIST(to) && TYPE_IS_XML(from))

1643

return c;

1644

1645

if(TYPE_IS_BOOLEAN(to))

1646

return abc_convert_b(c);

1647

if(TYPE_IS_STRING(to))

1648

return abc_convert_s(c);

1649

if(TYPE_IS_OBJECT(to))

1650

return abc_coerce2(c, &m);

1651

if(TYPE_IS_OBJECT(from) && TYPE_IS_XMLLIST(to))

1652

return abc_coerce2(c, &m);

1653

if(TYPE_IS_OBJECT(from) && TYPE_IS_ARRAY(to))

1654

return abc_coerce2(c, &m);

1655

1656

classinfo_t*supertype = from;

1657

while(supertype) {

1658

if(supertype == to) {

1659

/* target type is one of from's superclasses.

1660

(not sure we need this coerce - as far as the verifier

1661

is concerned, object==object (i think) */

1662

return abc_coerce2(c, &m);

1663

}

1664

int t=0;

1665

while(supertype->interfaces[t]) {

1666

if(supertype->interfaces[t]==to) {

1667

// target type is one of from's interfaces

1668

return abc_coerce2(c, &m);

1669

}

1670

t++;

1671

}

1672

supertype = supertype->superclass;

1673

}

1674

if(TYPE_IS_FUNCTION(from) && TYPE_IS_FUNCTION(to))

1675

return c;

1676

if(TYPE_IS_CLASS(from) && TYPE_IS_CLASS(to))

1677

return c;

1678

if(TYPE_IS_NULL(from) && !IS_NUMBER_OR_INT(to))

1679

return c;

1680

1681

as3_error("can't convert type %s%s%s to %s%s%s",

1682

from->package, from->package[0]?".":"", from->name,

1683

to->package, to->package[0]?".":"", to->name);

1684

1685

return c;

1686

}

1687

code_t* coerce_to_type(code_t*c, classinfo_t*t)

1688

{

1689

if(!t) {

1690

return abc_coerce_a(c);

1691

} else if(TYPE_IS_STRING(t)) {

1692

return abc_coerce_s(c);

1693

} else {

1694

MULTINAME(m, t);

1695

return abc_coerce2(c, &m);

1696

}

1697

}

1698

1699

char is_pushundefined(code_t*c)

1700

{

1701

return (c && !c->prev && !c->next && c->opcode == OPCODE_PUSHUNDEFINED);

1702

}

1703

1704

static const char* get_package_from_name(const char*name)

1705

{

1706

/* try explicit imports */

1707

dictentry_t* e = dict_get_slot(state->imports, name);

1708

while(e) {

1709

if(!strcmp(e->key, name)) {

1710

slotinfo_t*c = (slotinfo_t*)e->data;

1711

if(c) return c->package;

1712

}

1713

e = e->next;

1714

}

1715

return 0;

1716

}

1717

static namespace_list_t*get_current_imports()

1718

{

1719

namespace_list_t*searchlist = 0;

1720

1721

list_append(searchlist, namespace_new_package(state->package));

1722

1723

import_list_t*l = state->wildcard_imports;

1724

while(l) {

1725

namespace_t*ns = namespace_new_package(l->import->package);

1726

list_append(searchlist, ns);

1727

l = l->next;

1728

}

1729

list_append(searchlist, namespace_new_package(""));

1730

list_append(searchlist, namespace_new_package(internal_filename_package));

1731

return searchlist;

1732

}

1733

1734

static slotinfo_t* find_class(const char*name)

1735

{

1736

slotinfo_t*c=0;

1737

1738

c = registry_find(state->package, name);

1739

if(c) return c;

1740

1741

/* try explicit imports */

1742

dictentry_t* e = dict_get_slot(state->imports, name);

1743

if(c) return c;

1744

while(e) {

1745

if(!strcmp(e->key, name)) {

1746

c = (slotinfo_t*)e->data;

1747

if(c) return c;

1748

}

1749

e = e->next;

1750

}

1751

1752

/* try package.* imports */

1753

import_list_t*l = state->wildcard_imports;

1754

while(l) {

1755

//printf("does package %s contain a class %s?\n", l->import->package, name);

1756

c = registry_find(l->import->package, name);

1757

if(c) return c;

1758

l = l->next;

1759

}

1760

1761

/* try global package */

1762

c = registry_find("", name);

1763

if(c) return c;

1764

1765

/* try local "filename" package */

1766

c = registry_find(internal_filename_package, name);

1767

if(c) return c;

1768

1769

return 0;

1770

}

1771

typedcode_t push_class(slotinfo_t*a)

1772

{

1773

typedcode_t x;

1774

x.c = 0;

1775

x.t = 0;

1776

if(a->access == ACCESS_PACKAGEINTERNAL &&

1777

strcmp(a->package, state->package) &&

1778

strcmp(a->package, internal_filename_package)

1779

) {

1780

syntaxerror("Can't access internal %s %s in package '%s' from package '%s'",

1781

infotypename(a), a->name, a->package, state->package);

1782

}

1783

1784

1785

if(a->kind != INFOTYPE_CLASS) {

1786

MULTINAME(m, a);

1787

x.c = abc_findpropstrict2(x.c, &m);

1788

x.c = abc_getproperty2(x.c, &m);

1789

if(a->kind == INFOTYPE_METHOD) {

1790

methodinfo_t*f = (methodinfo_t*)a;

1791

x.t = TYPE_FUNCTION(f);

1792

} else {

1793

varinfo_t*v = (varinfo_t*)a;

1794

x.t = v->type;

1795

}

1796

return x;

1797

} else {

1798

if(state->cls && state->method == state->cls->static_init) {

1799

/* we're in the static initializer.

1800

record the fact that we're using this class here */

1801

parsedclass_add_dependency(state->cls->dependencies, (classinfo_t*)a);

1802

}

1803

classinfo_t*c = (classinfo_t*)a;

1804

//if(c->slot) {

1805

if(0) { //Error #1026: Slot 1 exceeds slotCount=0 of global

1806

x.c = abc_getglobalscope(x.c);

1807

x.c = abc_getslot(x.c, c->slot);

1808

} else {

1809

MULTINAME(m, c);

1810

x.c = abc_getlex2(x.c, &m);

1811

}

1812

x.t = TYPE_CLASS(c);

1813

}

1814

return x;

1815

}

1816

1817

1818

char is_break_or_jump(code_t*c)

1819

{

1820

if(!c)

1821

return 0;

1822

if(c->opcode == OPCODE_JUMP ||

1823

c->opcode == OPCODE___BREAK__ ||

1824

c->opcode == OPCODE___CONTINUE__ ||

1825

c->opcode == OPCODE_THROW ||

1826

c->opcode == OPCODE_RETURNVOID ||

1827

c->opcode == OPCODE_RETURNVALUE) {

1828

return 1;

1829

}

1830

return 0;

1831

}

1832

1833

#define IS_FINALLY_TARGET(op) \

1834

((op) == OPCODE___CONTINUE__ || \

1835

(op) == OPCODE___BREAK__ || \

1836

(op) == OPCODE_RETURNVOID || \

1837

(op) == OPCODE_RETURNVALUE || \

1838

(op) == OPCODE___RETHROW__)

1839

1840

static code_t* insert_finally_lookup(code_t*c, code_t*finally, int tempvar)

1841

{

1842

#define NEED_EXTRA_STACK_ARG

1843

code_t*finally_label = abc_nop(0);

1844

NEW(lookupswitch_t, l);

1845

//_lookupswitch

1846

1847

code_t*i = c;

1848

int count=0;

1849

while(i) {

1850

code_t*prev = i->prev;

1851

if(IS_FINALLY_TARGET(i->opcode)) {

1852

code_t*p = prev;

1853

char needvalue=0;

1854

if(i->opcode == OPCODE___RETHROW__ ||

1855

i->opcode == OPCODE_RETURNVALUE) {

1856

if(i->opcode == OPCODE___RETHROW__)

1857

i->opcode = OPCODE_THROW;

1858

needvalue=1;

1859

p = abc_coerce_a(p);

1860

p = abc_setlocal(p, tempvar);

1861

}

1862

p = abc_pushbyte(p, count++);

1863

p = abc_jump(p, finally_label);

1864

code_t*target = p = abc_label(p);

1865

#ifdef NEED_EXTRA_STACK_ARG

1866

p = abc_pop(p);

1867

#endif

1868

if(needvalue) {

1869

p = abc_getlocal(p, tempvar);

1870

}

1871

1872

p->next = i;i->prev = p;

1873

list_append(l->targets, target);

1874

}

1875

i = prev;

1876

}

1877

1878

code_t*j,*f;

1879

c = abc_pushbyte(c, -1);

1880

c = code_append(c, finally_label);

1881

c = code_append(c, finally);

1882

1883

#ifdef NEED_EXTRA_STACK_ARG

1884

c = abc_dup(c);

1885

#endif

1886

c = abc_lookupswitch(c, l);

1887

c = l->def = abc_label(c);

1888

#ifdef NEED_EXTRA_STACK_ARG

1889

c = abc_pop(c);

1890

#endif

1891

1892

return c;

1893

}

1894

1895

static code_t* insert_finally_simple(code_t*c, code_t*finally, int tempvar)

1896

{

1897

code_t*i = c;

1898

while(i) {

1899

code_t*prev = i->prev;

1900

if(IS_FINALLY_TARGET(i->opcode)) {

1901

if(i->opcode == OPCODE___RETHROW__)

1902

i->opcode = OPCODE_THROW;

1903

code_t*end = code_dup(finally);

1904

code_t*start = code_start(end);

1905

if(prev) prev->next = start;

1906

start->prev = prev;

1907

i->prev = end;

1908

end->next = i;

1909

}

1910

i = prev;

1911

}

1912

return code_append(c, finally);

1913

}

1914

1915

code_t* insert_finally(code_t*c, code_t*finally, int tempvar)

1916

{

1917

if(!finally)

1918

return c;

1919

code_t*i = c;

1920

char cantdup=0;

1921

int num_insertion_points=0;

1922

while(i) {

1923

if(IS_FINALLY_TARGET(i->opcode))

1924

num_insertion_points++;

1925

i = i->prev;

1926

}

1927

i = finally;

1928

int code_size=0;

1929

while(i) {

1930

code_size++;

1931

if(i->branch || i->opcode == OPCODE_LOOKUPSWITCH) {

1932

cantdup=1;

1933

}

1934

i = i->prev;

1935

}

1936

int simple_version_cost = (1+num_insertion_points)*code_size;

1937

int lookup_version_cost = 4*num_insertion_points + 5;

1938

1939

if(cantdup || simple_version_cost > lookup_version_cost) {

1940

//printf("(use lookup) simple=%d > lookup=%d\n", simple_version_cost, lookup_version_cost);

1941

return insert_finally_lookup(c, finally, tempvar);

1942

} else {

1943

//printf("(use simple) simple=%d < lookup=%d\n", simple_version_cost, lookup_version_cost);

1944

return insert_finally_simple(c, finally, tempvar);

1945

}

1946

}

1947

1948

#define PASS1 }} if(as3_pass == 1) {{

1949

#define PASS1END }} if(as3_pass == 2) {{

1950

#define PASS2 }} if(as3_pass == 2) {{

1951

#define PASS12 }} if(as3_pass == 1 || as3_pass == 2) {{

1952

#define PASS12END }} if(as3_pass == 2) {{

1953

#define PASS_ALWAYS }} {{

1954

1955

1956

1957

/* Line 273 of skeleton.m4 */

1958

#line 1959 "parser.tab.c"

1959

/* Unqualified %code blocks. */

1960

1961

/* Line 274 of skeleton.m4 */

1962

#line 2050 "parser.y"

1963

1964

char is_subtype_of(classinfo_t*type, classinfo_t*supertype)

1965

{

1966

return 1; // FIXME

1967

}

1968

char do_init_variable(char*name)

1969

{

1970

if(!state->method->no_variable_scoping)

1971

return 0;

1972

if(!state->new_vars)

1973

return 1;

1974

return 1;

1975

}

1976

1977

1978

/* Line 274 of skeleton.m4 */

1979

#line 2500 "parser.y"

1980

1981

static void state_has_imports()

1982

{

1983

state->wildcard_imports = list_clone(state->wildcard_imports);

1984

state->imports = dict_clone(state->imports);

1985

state->has_own_imports = 1;

1986

}

1987

static void import_toplevel(const char*package)

1988

{

1989

char* s = strdup(package);

1990

while(1) {

1991

dict_put(state->import_toplevel_packages, s, 0);

1992

char*x = strrchr(s, '.');

1993

if(!x)

1994

break;

1995

*x = 0;

1996

}

1997

free(s);

1998

}

1999

2000

2001

/* Line 274 of skeleton.m4 */

2002

#line 2639 "parser.y"

2003

2004

static int slotstate_varconst = 0;

2005

static modifiers_t*slotstate_flags = 0;

2006

static void setslotstate(modifiers_t* flags, int varconst)

2007

{

2008

slotstate_varconst = varconst;

2009

slotstate_flags = flags;

2010

if(state->cls) {

2011

if(flags) {

2012

if(flags->flags&FLAG_STATIC) {

2013

state->method = state->cls->static_init;

2014

} else {

2015

state->method = state->cls->init;

2016

}

2017

} else {

2018

// reset to "default" state (all in class code is static by default) */

2019

state->method = state->cls->static_init;

2020

}

2021

} else {

2022

parserassert(state->method);

2023

}

2024

}

2025

static trait_t* add_abc_slot(modifiers_t* modifiers, const char*name, multiname_t*m, code_t***c)

2026

{

2027

int flags = modifiers->flags;

2028

namespace_t ns = modifiers2access(modifiers);

2029

2030

/* slot name */

2031

multiname_t mname = {QNAME, &ns, 0, name};

2032

2033

trait_list_t**traits;

2034

code_t**code=0;

2035

if(!state->cls) {

2036

// global variable

2037

if(!global->init) global->init = abc_initscript(global->file);

2038

ns.name = state->package;

2039

traits = &global->init->traits;

2040

code = &global->init->method->body->code;

2041

} else if(flags&FLAG_STATIC) {

2042

// static variable

2043

traits = &state->cls->abc->static_traits;

2044

code = &state->cls->static_init->header;

2045

} else {

2046

// instance variable

2047

traits = &state->cls->abc->traits;

2048

code = &state->cls->init->header;

2049

2050

if(ns.access == ACCESS_PROTECTED) {

2051

ns.name = concat3(state->cls->info->package,":",state->cls->info->name);

2052

}

2053

}

2054

if(c)

2055

*c = code;

2056

if(m)

2057

*m = *multiname_clone(&mname);

2058

2059

return trait_new_member(traits, 0, multiname_clone(&mname), 0);

2060

}

2061

2062

2063

/* Line 274 of skeleton.m4 */

2064

#line 2819 "parser.y"

2065

2066

static int xml_level = 0;

2067

2068

2069

/* Line 274 of skeleton.m4 */

2070

#line 3624 "parser.y"

2071

2072

node_t* resolve_identifier(char*name)

2073

{

2074

typedcode_t o;

2075

o.t = 0;

2076

o.c = 0;

2077

2078

slotinfo_t*a = 0;

2079

memberinfo_t*f = 0;

2080

2081

variable_t*v;

2082

/* look at variables */

2083

if((v = find_variable(state, name))) {

2084

// name is a local variable

2085

o.c = abc_getlocal(o.c, v->index);

2086

o.t = v->type;

2087

return mkcodenode(o);

2088

}

2089

if((v = find_slot(state, name))) {

2090

o.c = abc_getscopeobject(o.c, 1);

2091

o.c = abc_getslot(o.c, v->index);

2092

o.t = v->type;

2093

return mkcodenode(o);

2094

}

2095

2096

int i_am_static = state->method->is_static;

2097

2098

/* look at current class' members */

2099

if(!state->method->inner &&

2100

!state->xmlfilter &&

2101

state->cls &&

2102

(f = findmember_nsset(state->cls->info, name, 1)))

2103

{

2104

// name is a member or attribute in this class

2105

int var_is_static = (f->flags&FLAG_STATIC);

2106

2107

if(f->kind == INFOTYPE_VAR && (f->flags&FLAG_CONST)) {

2108

/* if the variable is a constant (and we know what is evaluates to), we

2109

can just use the value itself */

2110

varinfo_t*v = (varinfo_t*)f;

2111

if(v->value) {

2112

return mkconstnode(v->value);

2113

}

2114

}

2115

2116

if(var_is_static >= i_am_static) {

2117

if(f->kind == INFOTYPE_METHOD) {

2118

o.t = TYPE_FUNCTION(f);

2119

} else {

2120

o.t = f->type;

2121

}

2122

2123

if(var_is_static && !i_am_static) {

2124

/* access to a static member from a non-static location.

2125

do this via findpropstrict:

2126

there doesn't seem to be any non-lookup way to access

2127

static properties of a class */

2128

state->method->late_binding = 1;

2129

o.t = f->type;

2130

namespace_t ns = {f->access, f->package};

2131

multiname_t m = {QNAME, &ns, 0, name};

2132

o.c = abc_findpropstrict2(o.c, &m);

2133

o.c = abc_getproperty2(o.c, &m);

2134

return mkcodenode(o);

2135

} else if(f->slot>0) {

2136

o.c = abc_getlocal_0(o.c);

2137

o.c = abc_getslot(o.c, f->slot);

2138

return mkcodenode(o);

2139

} else {

2140

MEMBER_MULTINAME(m, f, name);

2141

o.c = abc_getlocal_0(o.c);

2142

o.c = abc_getproperty2(o.c, &m);

2143

return mkcodenode(o);

2144

}

2145

}

2146

}

2147

2148

/* look at actual classes, in the current package and imported */

2149

if(!state->xmlfilter && (a = find_class(name))) {

2150

if(state->cls && state->cls->info == (classinfo_t*)a && i_am_static) {

2151

o.c = abc_getlocal_0(0);

2152

o.t = TYPE_CLASS((classinfo_t*)a);

2153

} else {

2154

o = push_class(a);

2155

}

2156

return mkcodenode(o);

2157

}

2158

2159

/* look through package prefixes */

2160

if(!state->xmlfilter &&

2161

(dict_contains(state->import_toplevel_packages, name) ||

2162

registry_ispackage(name))) {

2163

o.c = abc___pushpackage__(o.c, name);

2164

o.t = 0;

2165

return mkcodenode(o); //?

2166

}

2167

2168

/* unknown object, let the avm2 resolve it */

2169

if(1) {

2170

if(!state->method->inner && !state->xmlfilter) {

2171

/* we really should make inner functions aware of the class context */

2172

as3_warning("Couldn't resolve '%s', doing late binding", name);

2173

}

2174

state->method->late_binding = 1;

2175

2176

multiname_t m = {MULTINAME, 0, &nopackage_namespace_set, name};

2177

2178

o.t = 0;

2179

o.c = abc_findpropstrict2(o.c, &m);

2180

o.c = abc_getproperty2(o.c, &m);

2181

return mkcodenode(o);

2182

}

2183

}

2184

2185

2186

/* Line 274 of skeleton.m4 */

2187

#line 3764 "parser.y"

2188

2189

void add_active_url(const char*url)

2190

{

2191

NEW(namespace_t,n);

2192

n->name = url;

2193

list_append(state->active_namespace_urls, n);

2194

}

2195

2196

2197

2198

/* Line 274 of skeleton.m4 */

2199

#line 2200 "parser.tab.c"

2200

2201

#ifdef short

2202

# undef short

2203

#endif

2204

2205

#ifdef YYTYPE_UINT8

2206

typedef YYTYPE_UINT8 yytype_uint8;

2207

#else

2208

typedef unsigned char yytype_uint8;

2209

#endif

2210

2211

#ifdef YYTYPE_INT8

2212

typedef YYTYPE_INT8 yytype_int8;

2213

#elif (defined __STDC__ || defined __C99__FUNC__ \

2214

|| defined __cplusplus || defined _MSC_VER)

2215

typedef signed char yytype_int8;

2216

#else

2217

typedef short int yytype_int8;

2218

#endif

2219

2220

#ifdef YYTYPE_UINT16

2221

typedef YYTYPE_UINT16 yytype_uint16;

2222

#else

2223

typedef unsigned short int yytype_uint16;

2224

#endif

2225

2226

#ifdef YYTYPE_INT16

2227

typedef YYTYPE_INT16 yytype_int16;

2228

#else

2229

typedef short int yytype_int16;

2230

#endif

2231

2232

#ifndef YYSIZE_T

2233

# ifdef __SIZE_TYPE__

2234

# define YYSIZE_T __SIZE_TYPE__

2235

# elif defined size_t

2236

# define YYSIZE_T size_t

2237

# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \

2238

|| defined __cplusplus || defined _MSC_VER)

2239

# include <stddef.h> /* INFRINGES ON USER NAME SPACE */

2240

# define YYSIZE_T size_t

2241

# else

2242

# define YYSIZE_T unsigned int

2243

# endif

2244

#endif

2245

2246

#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)

2247

2248

#ifndef YY_

2249

# if YYENABLE_NLS

2250

# if ENABLE_NLS

2251

# include <libintl.h> /* INFRINGES ON USER NAME SPACE */

2252

# define YY_(msgid) dgettext ("bison-runtime", msgid)

2253

# endif

2254

# endif

2255

# ifndef YY_

2256

# define YY_(msgid) msgid

2257

# endif

2258

#endif

2259

2260

/* Suppress unused-variable warnings by "using" E. */

2261

#if ! defined lint || defined __GNUC__

2262

# define YYUSE(e) ((void) (e))

2263

#else

2264

# define YYUSE(e) /* empty */

2265

#endif

2266

2267

/* Identity function, used to suppress warnings about constant conditions. */

2268

#ifndef lint

2269

# define YYID(n) (n)

2270

#else

2271

#if (defined __STDC__ || defined __C99__FUNC__ \

2272

|| defined __cplusplus || defined _MSC_VER)

2273

static int

2274

YYID (int yyi)

2275

#else

2276

static int

2277

YYID (yyi)

2278

int yyi;

2279

#endif

2280

{

2281

return yyi;

2282

}

2283

#endif

2284

2285

#if ! defined yyoverflow || YYERROR_VERBOSE

2286

2287

/* The parser invokes alloca or malloc; define the necessary symbols. */

2288

2289

# ifdef YYSTACK_USE_ALLOCA

2290

# if YYSTACK_USE_ALLOCA

2291

# ifdef __GNUC__

2292

# define YYSTACK_ALLOC __builtin_alloca

2293

# elif defined __BUILTIN_VA_ARG_INCR

2294

# include <alloca.h> /* INFRINGES ON USER NAME SPACE */

2295

# elif defined _AIX

2296

# define YYSTACK_ALLOC __alloca

2297

# elif defined _MSC_VER

2298

# include <malloc.h> /* INFRINGES ON USER NAME SPACE */

2299

# define alloca _alloca

2300

# else

2301

# define YYSTACK_ALLOC alloca

2302

# if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \

2303

|| defined __cplusplus || defined _MSC_VER)

2304

# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */

2305

# ifndef _STDLIB_H

2306

# define _STDLIB_H 1

2307

# endif

2308

# endif

2309

# endif

2310

# endif

2311

# endif

2312

2313

# ifdef YYSTACK_ALLOC

2314

/* Pacify GCC's `empty if-body' warning. */

2315

# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))

2316

# ifndef YYSTACK_ALLOC_MAXIMUM

2317

/* The OS might guarantee only one guard page at the bottom of the stack,

2318

and a page size can be as small as 4096 bytes. So we cannot safely

2319

invoke alloca (N) if N exceeds 4096. Use a slightly smaller number

2320

to allow for a few compiler-allocated temporary stack slots. */

2321

# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */

2322

# endif

2323

# else

2324

# define YYSTACK_ALLOC YYMALLOC

2325

# define YYSTACK_FREE YYFREE

2326

# ifndef YYSTACK_ALLOC_MAXIMUM

2327

# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM

2328

# endif

2329

# if (defined __cplusplus && ! defined _STDLIB_H \

2330

&& ! ((defined YYMALLOC || defined malloc) \

2331

&& (defined YYFREE || defined free)))

2332

# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */

2333

# ifndef _STDLIB_H

2334

# define _STDLIB_H 1

2335

# endif

2336

# endif

2337

# ifndef YYMALLOC

2338

# define YYMALLOC malloc

2339

# if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \

2340

|| defined __cplusplus || defined _MSC_VER)

2341

void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */

2342

# endif

2343

# endif

2344

# ifndef YYFREE

2345

# define YYFREE free

2346

# if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \

2347

|| defined __cplusplus || defined _MSC_VER)

2348

void free (void *); /* INFRINGES ON USER NAME SPACE */

2349

# endif

2350

# endif

2351

# endif

2352

#endif /* ! defined yyoverflow || YYERROR_VERBOSE */

2353

2354

2355

#if (! defined yyoverflow \

2356

&& (! defined __cplusplus \

2357

|| (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))

2358

2359

/* A type that is properly aligned for any stack member. */

2360

union yyalloc

2361

{

2362

yytype_int16 yyss_alloc;

2363

YYSTYPE yyvs_alloc;

2364

};

2365

2366

/* The size of the maximum gap between one aligned stack and the next. */

2367

# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)

2368

2369

/* The size of an array large to enough to hold all stacks, each with

2370

N elements. */

2371

# define YYSTACK_BYTES(N) \

2372

((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \

2373

+ YYSTACK_GAP_MAXIMUM)

2374

2375

/* Copy COUNT objects from FROM to TO. The source and destination do

2376

not overlap. */

2377

# ifndef YYCOPY

2378

# if defined __GNUC__ && 1 < __GNUC__

2379

# define YYCOPY(To, From, Count) \

2380

__builtin_memcpy (To, From, (Count) * sizeof (*(From)))

2381

# else

2382

# define YYCOPY(To, From, Count) \

2383

do \

2384

{ \

2385

YYSIZE_T yyi; \

2386

for (yyi = 0; yyi < (Count); yyi++) \

2387

(To)[yyi] = (From)[yyi]; \

2388

} \

2389

while (YYID (0))

2390

# endif

2391

# endif

2392

2393

/* Relocate STACK from its old location to the new one. The

2394

local variables YYSIZE and YYSTACKSIZE give the old and new number of

2395

elements in the stack, and YYPTR gives the new location of the

2396

stack. Advance YYPTR to a properly aligned location for the next

2397

stack. */

2398

# define YYSTACK_RELOCATE(Stack_alloc, Stack) \

2399

do \

2400

{ \

2401

YYSIZE_T yynewbytes; \

2402

YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \

2403

Stack = &yyptr->Stack_alloc; \

2404

yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \

2405

yyptr += yynewbytes / sizeof (*yyptr); \

2406

} \

2407

while (YYID (0))

2408

2409

#endif

2410

2411

/* YYFINAL -- State number of the termination state. */

2412

#define YYFINAL 164

2413

/* YYLAST -- Last index in YYTABLE. */

2414

#define YYLAST 3411

2415

2416

/* YYNTOKENS -- Number of terminals. */

2417

#define YYNTOKENS 136

2418

/* YYNNTS -- Number of nonterminals. */

2419

#define YYNNTS 135

2420

/* YYNRULES -- Number of rules. */

2421

#define YYNRULES 354

2422

/* YYNRULES -- Number of states. */

2423

#define YYNSTATES 601

2424

2425

/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */

2426

#define YYUNDEFTOK 2

2427

#define YYMAXUTOK 365

2428

2429

#define YYTRANSLATE(YYX) \

2430

((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)

2431

2432

/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */

2433

static const yytype_uint8 yytranslate[] =

2434

{

2435

0, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2436

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2437

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2438

2, 2, 2, 120, 2, 2, 2, 118, 109, 2,

2439

124, 135, 117, 115, 102, 114, 129, 116, 2, 2,

2440

2, 2, 2, 2, 2, 2, 2, 2, 106, 101,

2441

111, 104, 112, 105, 130, 2, 2, 2, 2, 2,

2442

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2443

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2444

2, 126, 2, 127, 108, 2, 2, 2, 2, 2,

2445

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2446

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2447

2, 2, 2, 128, 107, 134, 119, 2, 2, 2,

2448

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2449

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2450

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2451

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2452

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2453

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2454

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2455

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2456

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2457

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2458

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2459

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2460

2, 2, 2, 2, 2, 2, 1, 2, 3, 4,

2461

5, 6, 7, 8, 9, 10, 11, 12, 13, 14,

2462

15, 16, 17, 18, 19, 20, 21, 22, 23, 24,

2463

25, 26, 27, 28, 29, 30, 31, 32, 33, 34,

2464

35, 36, 37, 38, 39, 40, 41, 42, 43, 44,

2465

45, 46, 47, 48, 49, 50, 51, 52, 53, 54,

2466

55, 56, 57, 58, 59, 60, 61, 62, 63, 64,

2467

65, 66, 67, 68, 69, 70, 71, 72, 73, 74,

2468

75, 76, 77, 78, 79, 80, 81, 82, 83, 84,

2469

85, 86, 87, 88, 89, 90, 91, 92, 93, 94,

2470

95, 96, 97, 98, 99, 100, 103, 110, 113, 121,

2471

122, 123, 125, 131, 132, 133

2472

};

2473

2474

#if YYDEBUG

2475

/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in

2476

YYRHS. */

2477

static const yytype_uint16 yyprhs[] =

2478

{

2479

0, 0, 3, 5, 6, 8, 10, 13, 15, 17,

2480

19, 21, 23, 25, 30, 32, 33, 35, 37, 40,

2481

42, 44, 46, 48, 50, 55, 60, 62, 64, 65,

2482

68, 70, 72, 74, 76, 78, 80, 82, 84, 86,

2483

88, 90, 92, 94, 96, 100, 103, 105, 107, 109,

2484

111, 113, 115, 117, 122, 125, 127, 129, 130, 134,

2485

137, 138, 141, 144, 146, 150, 154, 155, 158, 159,

2486

162, 169, 170, 172, 174, 178, 180, 183, 187, 196,

2487

203, 209, 216, 218, 221, 223, 226, 227, 229, 231,

2488

234, 236, 239, 244, 248, 249, 258, 259, 269, 270,

2489

276, 278, 281, 283, 286, 288, 289, 296, 299, 301,

2490

306, 309, 311, 313, 315, 317, 319, 323, 325, 326,

2491

333, 334, 340, 343, 346, 351, 352, 354, 356, 359,

2492

361, 363, 365, 367, 369, 371, 373, 375, 377, 379,

2493

380, 383, 384, 387, 388, 391, 392, 402, 403, 412,

2494

413, 415, 417, 420, 422, 427, 429, 431, 433, 434,

2495

436, 438, 441, 443, 446, 455, 457, 459, 460, 465,

2496

467, 471, 475, 476, 479, 481, 483, 485, 487, 489,

2497

491, 493, 495, 497, 499, 501, 503, 504, 505, 510,

2498

511, 516, 517, 520, 523, 526, 529, 533, 535, 537,

2499

538, 540, 547, 558, 570, 572, 575, 577, 581, 585,

2500

589, 593, 594, 596, 599, 604, 608, 610, 615, 618,

2501

620, 622, 623, 624, 637, 639, 640, 641, 652, 654,

2502

658, 660, 662, 664, 668, 670, 672, 674, 677, 678,

2503

679, 683, 684, 686, 688, 690, 693, 696, 697, 702,

2504

707, 712, 715, 717, 720, 722, 724, 726, 730, 732,

2505

736, 737, 739, 741, 743, 745, 747, 749, 753, 759,

2506

761, 763, 765, 767, 769, 771, 773, 775, 777, 779,

2507

783, 787, 791, 795, 799, 803, 807, 811, 815, 819,

2508

823, 827, 830, 833, 837, 841, 845, 849, 853, 857,

2509

861, 865, 869, 873, 877, 881, 885, 889, 893, 896,

2510

899, 901, 905, 908, 913, 917, 921, 925, 929, 933,

2511

937, 941, 945, 949, 953, 957, 961, 967, 970, 973,

2512

976, 979, 983, 986, 987, 994, 996, 998, 1000, 1002,

2513

1004, 1010, 1014, 1020, 1025, 1030, 1037, 1044, 1048, 1050,

2514

1053, 1058, 1063, 1066, 1071

2515

};

2516

2517

/* YYRHS -- A `-1'-separated list of the rules' RHS. */

2518

static const yytype_int16 yyrhs[] =

2519

{

2520

137, 0, -1, 138, -1, -1, 139, -1, 140, -1,

2521

139, 140, -1, 188, -1, 200, -1, 198, -1, 234,

2522

-1, 209, -1, 149, -1, 151, 128, 138, 134, -1,

2523

101, -1, -1, 142, -1, 143, -1, 142, 143, -1,

2524

200, -1, 198, -1, 234, -1, 209, -1, 149, -1,

2525

151, 128, 141, 134, -1, 126, 150, 261, 127, -1,

2526

101, -1, 145, -1, -1, 145, 147, -1, 147, -1,

2527

269, -1, 191, -1, 163, -1, 164, -1, 165, -1,

2528

166, -1, 173, -1, 159, -1, 185, -1, 181, -1,

2529

257, -1, 270, -1, 268, -1, 128, 145, 134, -1,

2530

128, 134, -1, 101, -1, 146, -1, 153, -1, 167,

2531

-1, 168, -1, 253, -1, 183, -1, 151, 128, 145,

2532

134, -1, 147, 101, -1, 147, -1, 146, -1, -1,

2533

3, 91, 3, -1, 104, 261, -1, -1, 46, 154,

2534

-1, 32, 154, -1, 155, -1, 154, 102, 155, -1,

2535

3, 244, 152, -1, -1, 157, 148, -1, -1, 66,

2536

156, -1, 65, 124, 255, 135, 156, 158, -1, -1,

2537

153, -1, 257, -1, 46, 3, 244, -1, 3, -1,

2538

11, 124, -1, 11, 50, 124, -1, 162, 160, 101,

2539

255, 101, 257, 135, 156, -1, 162, 161, 69, 255,

2540

135, 156, -1, 12, 124, 255, 135, 156, -1, 13,

2541

156, 12, 124, 255, 135, -1, 67, -1, 67, 3,

2542

-1, 30, -1, 30, 3, -1, -1, 170, -1, 172,

2543

-1, 170, 172, -1, 171, -1, 170, 171, -1, 34,

2544

261, 106, 144, -1, 62, 106, 144, -1, -1, 14,

2545

124, 174, 261, 135, 128, 169, 134, -1, -1, 33,

2546

124, 3, 244, 135, 176, 128, 144, 134, -1, -1,

2547

27, 128, 178, 144, 134, -1, 175, -1, 179, 175,

2548

-1, 179, -1, 179, 177, -1, 177, -1, -1, 52,

2549

128, 182, 144, 134, 180, -1, 37, 255, -1, 37,

2550

-1, 39, 124, 255, 135, -1, 184, 148, -1, 3,

2551

-1, 17, -1, 16, -1, 29, -1, 4, -1, 187,

2552

129, 186, -1, 186, -1, -1, 17, 187, 128, 189,

2553

141, 134, -1, -1, 17, 128, 190, 141, 134, -1,

2554

41, 3, -1, 41, 240, -1, 41, 187, 129, 117,

2555

-1, -1, 193, -1, 194, -1, 193, 194, -1, 20,

2556

-1, 21, -1, 18, -1, 38, -1, 47, -1, 49,

2557

-1, 48, -1, 25, -1, 23, -1, 4, -1, -1,

2558

54, 241, -1, -1, 54, 242, -1, -1, 15, 242,

2559

-1, -1, 192, 31, 3, 195, 197, 128, 199, 202,

2560

134, -1, -1, 192, 44, 3, 196, 128, 201, 205,

2561

134, -1, -1, 203, -1, 204, -1, 203, 204, -1,

2562

101, -1, 151, 128, 202, 134, -1, 209, -1, 234,

2563

-1, 146, -1, -1, 206, -1, 207, -1, 206, 207,

2564

-1, 101, -1, 46, 3, -1, 192, 26, 233, 3,

2565

124, 230, 135, 244, -1, 46, -1, 32, -1, -1,

2566

192, 208, 210, 211, -1, 212, -1, 211, 102, 212,

2567

-1, 3, 244, 152, -1, -1, 104, 261, -1, 8,

2568

-1, 9, -1, 10, -1, 5, -1, 56, -1, 55,

2569

-1, 45, -1, 28, -1, 29, -1, 227, -1, 111,

2570

-1, 112, -1, -1, -1, 128, 261, 220, 134, -1,

2571

-1, 128, 261, 222, 134, -1, -1, 223, 219, -1,

2572

223, 5, -1, 223, 112, -1, 227, 223, -1, 224,

2573

227, 223, -1, 3, -1, 221, -1, -1, 228, -1,

2574

216, 225, 226, 116, 218, 112, -1, 216, 225, 226,

2575

217, 223, 111, 116, 225, 218, 112, -1, 216, 225,

2576

226, 217, 223, 224, 111, 116, 225, 218, 112, -1,

2577

229, -1, 228, 229, -1, 221, -1, 221, 104, 5,

2578

-1, 221, 104, 221, -1, 3, 104, 221, -1, 3,

2579

104, 5, -1, -1, 231, -1, 95, 232, -1, 231,

2580

102, 95, 232, -1, 231, 102, 232, -1, 232, -1,

2581

3, 106, 243, 213, -1, 3, 213, -1, 51, -1,

2582

35, -1, -1, -1, 192, 26, 233, 3, 124, 230,

2583

135, 244, 128, 235, 144, 134, -1, 3, -1, -1,

2584

-1, 26, 236, 124, 230, 135, 244, 128, 238, 144,

2585

134, -1, 186, -1, 187, 129, 186, -1, 240, -1,

2586

239, -1, 241, -1, 242, 102, 241, -1, 241, -1,

2587

117, -1, 36, -1, 106, 243, -1, -1, -1, 124,

2588

246, 135, -1, -1, 247, -1, 248, -1, 254, -1,

2589

247, 102, -1, 248, 254, -1, -1, 24, 261, 249,

2590

245, -1, 261, 124, 246, 135, -1, 53, 124, 246,

2591

135, -1, 64, 261, -1, 42, -1, 42, 255, -1,

2592

261, -1, 256, -1, 261, -1, 256, 102, 261, -1,

2593

261, -1, 257, 102, 261, -1, -1, 260, -1, 3,

2594

-1, 5, -1, 8, -1, 9, -1, 10, -1, 259,

2595

106, 254, -1, 260, 102, 259, 106, 254, -1, 237,

2596

-1, 265, -1, 250, -1, 252, -1, 251, -1, 266,

2597

-1, 214, -1, 215, -1, 6, -1, 19, -1, 126,

2598

246, 127, -1, 71, 258, 134, -1, 261, 111, 261,

2599

-1, 261, 112, 261, -1, 261, 76, 261, -1, 261,

2600

77, 261, -1, 261, 72, 261, -1, 261, 73, 261,

2601

-1, 261, 75, 261, -1, 261, 74, 261, -1, 261,

2602

89, 261, -1, 261, 90, 261, -1, 120, 261, -1,

2603

119, 261, -1, 261, 109, 261, -1, 261, 108, 261,

2604

-1, 261, 107, 261, -1, 261, 98, 261, -1, 261,

2605

97, 261, -1, 261, 96, 261, -1, 261, 116, 261,

2606

-1, 261, 118, 261, -1, 261, 115, 261, -1, 261,

2607

114, 261, -1, 261, 117, 261, -1, 261, 69, 261,

2608

-1, 261, 70, 261, -1, 261, 40, 261, -1, 261,

2609

68, 261, -1, 43, 261, -1, 36, 261, -1, 36,

2610

-1, 124, 256, 135, -1, 114, 261, -1, 261, 126,

2611

261, 127, -1, 261, 81, 261, -1, 261, 80, 261,

2612

-1, 261, 87, 261, -1, 261, 86, 261, -1, 261,

2613

88, 261, -1, 261, 79, 261, -1, 261, 78, 261,

2614

-1, 261, 85, 261, -1, 261, 82, 261, -1, 261,

2615

83, 261, -1, 261, 84, 261, -1, 261, 104, 261,

2616

-1, 261, 105, 261, 106, 261, -1, 261, 93, -1,

2617

261, 92, -1, 93, 261, -1, 92, 261, -1, 53,

2618

129, 3, -1, 130, 3, -1, -1, 261, 129, 124,

2619

262, 261, 135, -1, 3, -1, 117, -1, 4, -1,

2620

186, -1, 117, -1, 261, 129, 263, 91, 264, -1,

2621

261, 94, 264, -1, 261, 129, 126, 261, 127, -1,

2622

261, 129, 130, 264, -1, 261, 94, 130, 264, -1,

2623

261, 129, 130, 126, 261, 127, -1, 261, 94, 130,

2624

126, 261, 127, -1, 261, 129, 264, -1, 3, -1,

2625

16, 3, -1, 16, 3, 104, 3, -1, 16, 3,

2626

104, 5, -1, 192, 267, -1, 63, 16, 104, 261,

2627

-1, 22, 16, 241, -1

2628

};

2629

2630

/* YYRLINE[YYN] -- source line where rule number YYN was defined. */

2631

static const yytype_uint16 yyrline[] =

2632

{

2633

0, 1941, 1941, 1943, 1943, 1944, 1945, 1947, 1948, 1949,

2634

1950, 1951, 1952, 1953, 1954, 1956, 1956, 1957, 1958, 1960,

2635

1961, 1962, 1963, 1964, 1965, 1966, 1967, 1969, 1970, 1972,

2636

1975, 1978, 1979, 1980, 1981, 1982, 1983, 1984, 1985, 1986,

2637

1987, 1988, 1989, 1990, 1991, 1992, 1995, 1996, 1997, 1998,

2638

1999, 2000, 2001, 2002, 2014, 2015, 2019, 2030, 2038, 2065,

2639

2066, 2068, 2069, 2071, 2072, 2074, 2135, 2135, 2139, 2140,

2640

2143, 2159, 2160, 2161, 2166, 2170, 2175, 2176, 2178, 2198,

2641

2241, 2257, 2269, 2272, 2275, 2278, 2282, 2283, 2284, 2285,

2642

2286, 2287, 2289, 2300, 2303, 2303, 2334, 2334, 2359, 2359,

2643

2375, 2376, 2377, 2378, 2386, 2395, 2395, 2444, 2448, 2459,

2644

2469, 2486, 2487, 2488, 2489, 2490, 2492, 2493, 2495, 2495,

2645

2497, 2497, 2521, 2529, 2540, 2556, 2557, 2558, 2559, 2566,

2646

2567, 2568, 2569, 2570, 2571, 2572, 2573, 2574, 2575, 2579,

2647

2580, 2582, 2583, 2585, 2586, 2590, 2588, 2596, 2594, 2603,

2648

2604, 2605, 2606, 2607, 2608, 2609, 2610, 2612, 2618, 2619,

2649

2620, 2621, 2622, 2623, 2626, 2699, 2699, 2701, 2701, 2703,

2650

2704, 2706, 2790, 2791, 2800, 2801, 2804, 2805, 2806, 2807,

2651

2808, 2809, 2810, 2823, 2834, 2835, 2836, 2838, 2838, 2841,

2652

2841, 2844, 2845, 2848, 2853, 2856, 2859, 2862, 2865, 2869,

2653

2872, 2876, 2880, 2885, 2891, 2894, 2897, 2900, 2905, 2908,

2654

2911, 2921, 2925, 2931, 2937, 2945, 2950, 2956, 2964, 2972,

2655

2973, 2974, 2977, 2976, 2993, 2994, 2996, 2995, 3019, 3038,

2656

3052, 3053, 3055, 3056, 3058, 3059, 3060, 3069, 3070, 3074,

2657

3075, 3077, 3078, 3079, 3081, 3085, 3086, 3091, 3092, 3136,

2658

3186, 3207, 3229, 3232, 3239, 3242, 3245, 3248, 3251, 3254,

2659

3259, 3260, 3262, 3263, 3264, 3265, 3266, 3268, 3274, 3283,

2660

3284, 3285, 3286, 3287, 3288, 3290, 3294, 3299, 3317, 3328,

2661

3338, 3347, 3348, 3349, 3350, 3351, 3352, 3353, 3354, 3355,

2662

3356, 3357, 3358, 3359, 3360, 3361, 3362, 3363, 3364, 3365,

2663

3366, 3367, 3368, 3369, 3370, 3371, 3372, 3373, 3374, 3375,

2664

3376, 3377, 3378, 3379, 3380, 3381, 3382, 3383, 3384, 3385,

2665

3386, 3387, 3388, 3389, 3390, 3391, 3392, 3394, 3395, 3396,

2666

3397, 3399, 3414, 3422, 3422, 3476, 3477, 3478, 3479, 3480,

2667

3488, 3506, 3513, 3524, 3531, 3538, 3548, 3559, 3739, 3773,

2668

3780, 3787, 3794, 3816, 3822

2669

};

2670

#endif

2671

2672

#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE

2673

/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.

2674

First, the terminals, then, starting at YYNTOKENS, nonterminals. */

2675

static const char *const yytname[] =

2676

{

2677

"$end", "error", "$undefined", "T_IDENTIFIER", "T_NAMESPACE",

2678

"T_STRING", "T_REGEXP", "T_EMPTY", "T_INT", "T_UINT", "T_FLOAT",

2679

"\"for\"", "\"while\"", "\"do\"", "\"switch\"", "\"implements\"",

2680

"\"namespace\"", "\"package\"", "\"protected\"", "\"arguments\"",

2681

"\"public\"", "\"private\"", "\"use\"", "\"internal\"", "\"new\"",

2682

"\"native\"", "\"function\"", "\"finally\"", "\"undefined\"", "\"NaN\"",

2683

"\"continue\"", "\"class\"", "\"const\"", "\"catch\"", "\"case\"",

2684

"\"set\"", "\"void\"", "\"throw\"", "\"static\"", "\"with\"",

2685

"\"instanceof\"", "\"import\"", "\"return\"", "\"typeof\"",

2686

"\"interface\"", "\"null\"", "\"var\"", "\"dynamic\"", "\"override\"",

2687

"\"final\"", "\"each\"", "\"get\"", "\"try\"", "\"super\"",

2688

"\"extends\"", "\"false\"", "\"true\"", "\"Boolean\"", "\"uint\"",

2689

"\"int\"", "\"Number\"", "\"String\"", "\"default\"", "\"default xml\"",

2690

"\"delete\"", "\"if\"", "\"else\"", "\"break\"", "\"is\"", "\"in\"",

2691

"\"as\"", "\"{ (dictionary)\"", "\"==\"", "\"===\"", "\"!=\"", "\"!==\"",

2692

"\"<=\"", "\">=\"", "\"|=\"", "\"/=\"", "\"%=\"", "\"*=\"", "\"&=\"",

2693

"\"+=\"", "\"-=\"", "\"^=\"", "\">>=\"", "\"<<=\"", "\">>>=\"", "\"||\"",

2694

"\"&&\"", "\"::\"", "\"--\"", "\"++\"", "\"..\"", "\"...\"", "\"<<\"",

2695

"\">>>\"", "\">>\"", "prec_none", "below_semicolon", "';'", "','",

2696

"below_assignment", "'='", "'?'", "':'", "'|'", "'^'", "'&'", "below_lt",

2697

"'<'", "'>'", "below_minus", "'-'", "'+'", "'/'", "'*'", "'%'", "'~'",

2698

"'!'", "minusminus_prefix", "plusplus_prefix", "below_curly", "'('",

2699

"new2", "'['", "']'", "'{'", "'.'", "'@'", "above_identifier",

2700

"below_else", "above_function", "'}'", "')'", "$accept", "PROGRAM",

2701

"MAYBE_PROGRAM_CODE_LIST", "PROGRAM_CODE_LIST", "PROGRAM_CODE",

2702

"MAYBE_INPACKAGE_CODE_LIST", "INPACKAGE_CODE_LIST", "INPACKAGE_CODE",

2703

"MAYBECODE", "CODE", "CODE_STATEMENT", "CODEPIECE", "CODEBLOCK",

2704

"PACKAGE_INITCODE", "EMBED_START", "CONDITIONAL_COMPILATION",

2705

"MAYBEEXPRESSION", "VARIABLE_DECLARATION", "VARIABLE_LIST",

2706

"ONE_VARIABLE", "IF_CODEBLOCK", "$@1", "MAYBEELSE", "IF", "FOR_INIT",

2707

"FOR_IN_INIT", "FOR_START", "FOR", "FOR_IN", "WHILE", "DO_WHILE",

2708

"BREAK", "CONTINUE", "MAYBE_CASE_LIST", "CASE_LIST", "CASE", "DEFAULT",

2709

"SWITCH", "$@2", "CATCH", "$@3", "FINALLY", "$@4", "CATCH_LIST",

2710

"CATCH_FINALLY_LIST", "TRY", "$@5", "THROW", "WITH_HEAD", "WITH",

2711

"X_IDENTIFIER", "PACKAGE", "PACKAGE_DECLARATION", "$@6", "$@7", "IMPORT",

2712

"MAYBE_MODIFIERS", "MODIFIER_LIST", "MODIFIER", "EXTENDS",

2713

"EXTENDS_LIST", "IMPLEMENTS_LIST", "CLASS_DECLARATION", "$@8",

2714

"INTERFACE_DECLARATION", "$@9", "MAYBE_CLASS_BODY", "CLASS_BODY",

2715

"CLASS_BODY_ITEM", "MAYBE_INTERFACE_BODY", "INTERFACE_BODY",

2716

"IDECLARATION", "VARCONST", "SLOT_DECLARATION", "$@10", "SLOT_LIST",

2717

"ONE_SLOT", "MAYBECONSTANT", "CONSTANT", "XML", "OPEN", "CLOSE",

2718

"CLOSE2", "XMLEXPR1", "$@11", "XMLEXPR2", "$@12", "XMLTEXT", "XML2",

2719

"XML_ID_OR_EXPR", "MAYBE_XMLATTRIBUTES", "XMLNODE", "XMLATTRIBUTES",

2720

"XMLATTRIBUTE", "MAYBE_PARAM_LIST", "PARAM_LIST", "PARAM", "GETSET",

2721

"FUNCTION_DECLARATION", "$@13", "MAYBE_IDENTIFIER", "INNERFUNCTION",

2722

"$@14", "CLASS", "PACKAGEANDCLASS", "CLASS_SPEC", "CLASS_SPEC_LIST",

2723

"TYPE", "MAYBETYPE", "MAYBE_PARAM_VALUES", "MAYBE_EXPRESSION_LIST",

2724

"EXPRESSION_LIST", "EXPRESSION_LIST_AND_COMMA", "XX", "NEW",

2725

"FUNCTIONCALL", "DELETE", "RETURN", "NONCOMMAEXPRESSION", "EXPRESSION",

2726

"COMMA_EXPRESSION", "VOIDEXPRESSION", "MAYBE_DICT_EXPRPAIR_LIST",

2727

"DICTLH", "DICT_EXPRPAIR_LIST", "E", "$@15", "ID_OR_NS", "SUBNODE",

2728

"MEMBER", "VAR_READ", "NAMESPACE_ID", "NAMESPACE_DECLARATION",

2729

"DEFAULT_NAMESPACE", "USE_NAMESPACE", 0

2730

};

2731

#endif

2732

2733

# ifdef YYPRINT

2734

/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to

2735

token YYLEX-NUM. */

2736

static const yytype_uint16 yytoknum[] =

2737

{

2738

0, 256, 257, 258, 259, 260, 261, 262, 263, 264,

2739

265, 266, 267, 268, 269, 270, 271, 272, 273, 274,

2740

275, 276, 277, 278, 279, 280, 281, 282, 283, 284,

2741

285, 286, 287, 288, 289, 290, 291, 292, 293, 294,

2742

295, 296, 297, 298, 299, 300, 301, 302, 303, 304,

2743

305, 306, 307, 308, 309, 310, 311, 312, 313, 314,

2744

315, 316, 317, 318, 319, 320, 321, 322, 323, 324,

2745

325, 326, 327, 328, 329, 330, 331, 332, 333, 334,

2746

335, 336, 337, 338, 339, 340, 341, 342, 343, 344,

2747

345, 346, 347, 348, 349, 350, 351, 352, 353, 354,

2748

355, 59, 44, 356, 61, 63, 58, 124, 94, 38,

2749

357, 60, 62, 358, 45, 43, 47, 42, 37, 126,

2750

33, 359, 360, 361, 40, 362, 91, 93, 123, 46,

2751

64, 363, 364, 365, 125, 41

2752

};

2753

# endif

2754

2755

/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */

2756

static const yytype_uint16 yyr1[] =

2757

{

2758

0, 136, 137, 138, 138, 139, 139, 140, 140, 140,

2759

140, 140, 140, 140, 140, 141, 141, 142, 142, 143,

2760

143, 143, 143, 143, 143, 143, 143, 144, 144, 145,

2761

145, 146, 146, 146, 146, 146, 146, 146, 146, 146,

2762

146, 146, 146, 146, 146, 146, 147, 147, 147, 147,

2763

147, 147, 147, 147, 148, 148, 149, 150, 151, 152,

2764

152, 153, 153, 154, 154, 155, 157, 156, 158, 158,

2765

159, 160, 160, 160, 161, 161, 162, 162, 163, 164,

2766

165, 166, 167, 167, 168, 168, 169, 169, 169, 169,

2767

170, 170, 171, 172, 174, 173, 176, 175, 178, 177,

2768

179, 179, 180, 180, 180, 182, 181, 183, 183, 184,

2769

185, 186, 186, 186, 186, 186, 187, 187, 189, 188,

2770

190, 188, 191, 191, 191, 192, 192, 193, 193, 194,

2771

194, 194, 194, 194, 194, 194, 194, 194, 194, 195,

2772

195, 196, 196, 197, 197, 199, 198, 201, 200, 202,

2773

202, 203, 203, 204, 204, 204, 204, 204, 205, 205,

2774

206, 206, 207, 207, 207, 208, 208, 210, 209, 211,

2775

211, 212, 213, 213, 214, 214, 214, 214, 214, 214,

2776

214, 214, 214, 215, 216, 217, 218, 220, 219, 222,

2777

221, 223, 223, 223, 223, 224, 224, 225, 225, 226,

2778

226, 227, 227, 227, 228, 228, 229, 229, 229, 229,

2779

229, 230, 230, 230, 230, 231, 231, 232, 232, 233,

2780

233, 233, 235, 234, 236, 236, 238, 237, 239, 240,

2781

241, 241, 242, 242, 243, 243, 243, 244, 244, 245,

2782

245, 246, 246, 246, 247, 248, 247, 249, 250, 251,

2783

251, 252, 253, 253, 254, 255, 256, 256, 257, 257,

2784

258, 258, 259, 259, 259, 259, 259, 260, 260, 261,

2785

261, 261, 261, 261, 261, 261, 261, 261, 261, 261,

2786

261, 261, 261, 261, 261, 261, 261, 261, 261, 261,

2787

261, 261, 261, 261, 261, 261, 261, 261, 261, 261,

2788

261, 261, 261, 261, 261, 261, 261, 261, 261, 261,

2789

261, 261, 261, 261, 261, 261, 261, 261, 261, 261,

2790

261, 261, 261, 261, 261, 261, 261, 261, 261, 261,

2791

261, 261, 261, 262, 261, 263, 263, 263, 264, 264,

2792

261, 261, 261, 261, 261, 261, 261, 265, 266, 267,

2793

267, 267, 268, 269, 270

2794

};

2795

2796

/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */

2797

static const yytype_uint8 yyr2[] =

2798

{

2799

0, 2, 1, 0, 1, 1, 2, 1, 1, 1,

2800

1, 1, 1, 4, 1, 0, 1, 1, 2, 1,

2801

1, 1, 1, 1, 4, 4, 1, 1, 0, 2,

2802

1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

2803

1, 1, 1, 1, 3, 2, 1, 1, 1, 1,

2804

1, 1, 1, 4, 2, 1, 1, 0, 3, 2,

2805

0, 2, 2, 1, 3, 3, 0, 2, 0, 2,

2806

6, 0, 1, 1, 3, 1, 2, 3, 8, 6,

2807

5, 6, 1, 2, 1, 2, 0, 1, 1, 2,

2808

1, 2, 4, 3, 0, 8, 0, 9, 0, 5,

2809

1, 2, 1, 2, 1, 0, 6, 2, 1, 4,

2810

2, 1, 1, 1, 1, 1, 3, 1, 0, 6,

2811

0, 5, 2, 2, 4, 0, 1, 1, 2, 1,

2812

1, 1, 1, 1, 1, 1, 1, 1, 1, 0,

2813

2, 0, 2, 0, 2, 0, 9, 0, 8, 0,

2814

1, 1, 2, 1, 4, 1, 1, 1, 0, 1,

2815

1, 2, 1, 2, 8, 1, 1, 0, 4, 1,

2816

3, 3, 0, 2, 1, 1, 1, 1, 1, 1,

2817

1, 1, 1, 1, 1, 1, 0, 0, 4, 0,

2818

4, 0, 2, 2, 2, 2, 3, 1, 1, 0,

2819

1, 6, 10, 11, 1, 2, 1, 3, 3, 3,

2820

3, 0, 1, 2, 4, 3, 1, 4, 2, 1,

2821

1, 0, 0, 12, 1, 0, 0, 10, 1, 3,

2822

1, 1, 1, 3, 1, 1, 1, 2, 0, 0,

2823

3, 0, 1, 1, 1, 2, 2, 0, 4, 4,

2824

4, 2, 1, 2, 1, 1, 1, 3, 1, 3,

2825

0, 1, 1, 1, 1, 1, 1, 3, 5, 1,

2826

1, 1, 1, 1, 1, 1, 1, 1, 1, 3,

2827

3, 3, 3, 3, 3, 3, 3, 3, 3, 3,

2828

3, 2, 2, 3, 3, 3, 3, 3, 3, 3,

2829

3, 3, 3, 3, 3, 3, 3, 3, 2, 2,

2830

1, 3, 2, 4, 3, 3, 3, 3, 3, 3,

2831

3, 3, 3, 3, 3, 3, 5, 2, 2, 2,

2832

2, 3, 2, 0, 6, 1, 1, 1, 1, 1,

2833

5, 3, 5, 4, 4, 6, 6, 3, 1, 2,

2834

4, 4, 2, 4, 3

2835

};

2836

2837

/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state

2838

STATE-NUM when YYTABLE doesn't specify something else to do. Zero

2839

means the default is an error. */

2840

static const yytype_uint16 yydefact[] =

2841

{

2842

125, 348, 138, 177, 277, 174, 175, 176, 0, 0,

2843

66, 0, 0, 131, 278, 129, 130, 0, 137, 0,

2844

136, 225, 181, 182, 310, 132, 0, 0, 0, 180,

2845

133, 135, 134, 0, 0, 179, 178, 0, 0, 0,

2846

260, 0, 0, 14, 184, 0, 0, 0, 0, 241,

2847

125, 0, 0, 2, 125, 5, 56, 12, 0, 38,

2848

71, 33, 34, 35, 36, 37, 40, 125, 39, 7,

2849

32, 0, 126, 127, 9, 8, 11, 275, 276, 0,

2850

183, 10, 269, 271, 273, 272, 41, 258, 270, 274,

2851

43, 31, 42, 0, 0, 76, 0, 0, 125, 94,

2852

111, 115, 113, 112, 114, 120, 117, 0, 0, 348,

2853

247, 224, 0, 309, 0, 122, 0, 123, 308, 105,

2854

241, 0, 0, 251, 0, 262, 263, 264, 265, 266,

2855

0, 0, 261, 330, 329, 312, 292, 291, 0, 256,

2856

0, 242, 243, 244, 254, 84, 0, 108, 252, 0,

2857

82, 46, 45, 125, 47, 30, 0, 48, 49, 50,

2858

52, 0, 51, 332, 1, 6, 125, 348, 0, 72,

2859

0, 0, 73, 55, 110, 0, 221, 0, 166, 0,

2860

165, 167, 352, 128, 197, 0, 198, 199, 0, 0,

2861

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

2862

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

2863

0, 0, 328, 327, 0, 0, 0, 0, 0, 0,

2864

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

2865

241, 0, 0, 58, 77, 0, 255, 0, 67, 0,

2866

125, 118, 0, 228, 0, 231, 230, 354, 239, 211,

2867

0, 0, 28, 0, 331, 0, 0, 280, 0, 0,

2868

0, 311, 279, 245, 246, 85, 238, 62, 63, 107,

2869

253, 61, 83, 44, 29, 125, 0, 238, 0, 0,

2870

54, 349, 220, 219, 0, 139, 141, 0, 189, 0,

2871

206, 0, 200, 204, 259, 306, 307, 304, 305, 285,

2872

286, 288, 287, 283, 284, 320, 319, 315, 314, 322,

2873

323, 324, 321, 317, 316, 318, 289, 290, 339, 0,

2874

338, 341, 298, 297, 296, 325, 0, 295, 294, 293,

2875

281, 282, 302, 301, 299, 303, 300, 0, 0, 111,

2876

115, 339, 333, 0, 0, 0, 347, 66, 0, 0,

2877

26, 57, 0, 125, 17, 23, 0, 20, 19, 22,

2878

21, 125, 116, 0, 241, 248, 172, 0, 0, 212,

2879

216, 109, 124, 229, 0, 27, 250, 353, 66, 267,

2880

0, 257, 0, 60, 0, 125, 13, 60, 0, 0,

2881

0, 0, 0, 143, 0, 0, 238, 168, 169, 0,

2882

0, 0, 185, 186, 191, 205, 0, 344, 0, 249,

2883

313, 0, 0, 0, 343, 0, 80, 0, 0, 0,

2884

121, 18, 125, 0, 0, 0, 0, 218, 213, 238,

2885

0, 0, 68, 0, 236, 235, 234, 237, 0, 65,

2886

64, 53, 0, 66, 350, 351, 211, 140, 0, 0,

2887

232, 142, 147, 60, 0, 190, 210, 209, 207, 208,

2888

0, 0, 0, 326, 0, 342, 0, 340, 81, 86,

2889

0, 0, 119, 240, 173, 172, 0, 0, 215, 0,

2890

0, 100, 104, 102, 106, 66, 70, 268, 59, 0,

2891

79, 0, 144, 145, 0, 125, 171, 170, 201, 193,

2892

184, 194, 0, 192, 0, 191, 346, 334, 345, 0,

2893

0, 0, 87, 90, 88, 25, 24, 217, 226, 214,

2894

98, 0, 101, 103, 69, 66, 238, 125, 233, 0,

2895

162, 0, 0, 125, 160, 0, 187, 184, 191, 195,

2896

0, 28, 95, 91, 89, 28, 28, 238, 78, 0,

2897

153, 157, 0, 0, 0, 125, 151, 155, 156, 163,

2898

221, 148, 161, 186, 0, 0, 196, 28, 93, 0,

2899

0, 0, 222, 125, 146, 152, 0, 0, 188, 186,

2900

92, 227, 99, 96, 28, 0, 0, 202, 0, 0,

2901

0, 154, 211, 203, 28, 223, 0, 0, 238, 97,

2902

164

2903

};

2904

2905

/* YYDEFGOTO[NTERM-NUM]. */

2906

static const yytype_int16 yydefgoto[] =

2907

{

2908

-1, 52, 53, 54, 55, 352, 353, 354, 374, 375,

2909

154, 155, 174, 355, 419, 156, 439, 157, 271, 268,

2910

97, 98, 486, 59, 170, 171, 60, 61, 62, 63,

2911

64, 158, 159, 511, 512, 513, 514, 65, 239, 481,

2912

589, 482, 546, 483, 484, 66, 252, 160, 67, 68,

2913

243, 244, 69, 361, 240, 70, 161, 72, 73, 393,

2914

395, 449, 357, 527, 358, 495, 554, 555, 556, 532,

2915

533, 534, 181, 359, 287, 397, 398, 427, 77, 78,

2916

79, 404, 460, 503, 564, 186, 399, 461, 504, 187,

2917

291, 80, 292, 293, 368, 369, 370, 284, 360, 584,

2918

112, 82, 545, 245, 246, 436, 451, 437, 383, 365,

2919

140, 141, 142, 248, 83, 84, 85, 162, 143, 235,

2920

236, 86, 130, 131, 132, 87, 411, 345, 321, 88,

2921

89, 182, 90, 91, 92

2922

};

2923

2924

/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing

2925

STATE-NUM. */

2926

#define YYPACT_NINF -515

2927

static const yytype_int16 yypact[] =

2928

{

2929

1766, 12, -515, -515, -515, -515, -515, -515, -28, -6,

2930

-515, 16, 94, -515, -515, -515, -515, 108, -515, 2220,

2931

-515, 122, -515, -515, 2277, -515, 17, 363, 2220, -515,

2932

-515, -515, -515, 24, 27, -515, -515, 112, 2220, 29,

2933

332, 2220, 2220, -515, -515, 2220, 2220, 2220, 2220, 2220,

2934

710, 158, 165, -515, 578, -515, -515, -515, 44, -515,

2935

2148, -515, -515, -515, -515, -515, -515, 2022, -515, -515,

2936

-515, 288, 766, -515, -515, -515, -515, -515, -515, 11,

2937

-515, -515, -515, -515, -515, -515, 118, 2972, -515, -515,

2938

-515, -515, -515, 218, 101, -515, 2220, 221, 2022, -515,

2939

-515, -515, -515, -515, -515, -515, -515, -83, 373, -515,

2940

-50, -515, 111, -51, 2220, 110, 124, -515, -51, -515,

2941

2220, 253, 155, -51, 2220, -515, -515, -515, -515, -515,

2942

127, 159, 162, -51, -51, 702, -51, -51, -52, 2910,

2943

141, 168, 2220, -515, 2910, 268, 272, 2220, 2220, 272,

2944

273, -515, -515, 842, -515, -515, 149, -515, -515, -515,

2945

-515, 266, -515, -515, -515, -515, 1106, 214, 282, -515,

2946

191, 225, 118, 202, -515, 302, 54, 304, -515, 305,

2947

-515, -515, -515, -515, -515, 2220, -515, 20, 2220, 2220,

2948

2220, 2220, 2220, 2220, 2220, 2220, 2220, 2220, 2220, 2220,

2949

2220, 2220, 2220, 2220, 2220, 2220, 2220, 2220, 2220, 2220,

2950

2220, 2220, -515, -515, 130, 2220, 2220, 2220, 2220, 2220,

2951

2220, 2220, 2220, 2220, 2220, 2220, 2220, 2220, 2220, 2220,

2952

2220, 2220, 128, -515, -515, 174, 209, 188, -515, 2220,

2953

1238, -515, 373, 184, 187, -515, -515, -515, 194, 21,

2954

186, 84, 1894, 193, -515, 2220, 198, -515, 2220, 332,

2955

2220, -515, -515, -515, -515, -515, 216, 236, -515, -515,

2956

-515, 236, -515, -515, -515, 2022, 226, 216, 2220, 2220,

2957

-515, 239, -515, -515, 345, 311, 314, 366, 2910, 278,

2958

280, -49, 20, -515, 2910, 408, 570, 570, 570, 3282,

2959

3282, 3282, 3282, 408, 408, 2910, 2910, 2910, 2910, 2910,

2960

2910, 2910, 2910, 2910, 2910, 2910, 365, 3034, -515, 146,

2961

-515, -515, 424, 424, 424, 2910, 2476, 3096, 3158, 3220,

2962

408, 408, 702, 702, -51, -51, -51, 250, 2538, 295,

2963

306, 307, -515, 2220, 233, 312, -515, -515, 2220, 2336,

2964

-515, 279, 259, 1370, -515, -515, 267, -515, -515, -515,

2965

-515, 1238, -515, 373, 2220, -515, 126, 401, 274, 308,

2966

-515, -515, -515, 283, 281, 1894, -515, 2910, -515, -515,

2967

310, 2910, 270, 313, 272, 974, -515, -30, 317, 284,

2968

104, 290, 373, 393, 373, 292, 216, 323, -515, 294,

2969

14, 15, -515, -515, -515, -515, 2220, -515, 2220, -515,

2970

-515, 2220, 2600, 2220, -515, 354, -515, 296, 301, 2220,

2971

-515, -515, 1238, 298, 309, 2220, 270, -515, -515, 216,

2972

22, 39, 364, 2220, -515, -515, -515, -515, 2220, -515,

2973

-515, -515, 2220, -515, -515, -515, 21, -515, 373, 315,

2974

-515, 334, -515, 313, 366, -515, -515, -515, -515, -515,

2975

333, 43, 2662, 2910, 2406, -515, 2724, -515, -515, 28,

2976

2786, 316, -515, -515, 2910, 342, 319, 401, -515, 321,

2977

327, -515, -515, 39, -515, -515, -515, -515, 2910, -41,

2978

-515, 318, 334, -515, 373, 277, -515, -515, -515, -515,

2979

338, -515, 2220, -515, 353, -515, -515, -515, -515, 2220,

2980

350, 331, 28, -515, -515, -515, -515, -515, -515, -515,

2981

-515, 463, -515, -515, -515, -515, 216, 1502, -515, 464,

2982

-515, 442, 335, 326, -515, 11, 2910, 359, -515, 46,

2983

2848, 1894, -515, -515, -515, 1894, 1894, 216, -515, 358,

2984

-515, -515, 360, 264, 336, 1634, -515, -515, -515, -515,

2985

54, -515, -515, -515, 344, 11, 46, 1894, -515, 362,

2986

369, 352, -515, 1502, -515, -515, 489, 381, -515, -515,

2987

-515, -515, -515, -515, 1894, 374, 375, -515, 386, 379,

2988

376, -515, 21, -515, 1894, -515, 377, 380, 216, -515,

2989

-515

2990

};

2991

2992

/* YYPGOTO[NTERM-NUM]. */

2993

static const yytype_int16 yypgoto[] =

2994

{

2995

-515, -515, 343, -515, 457, -340, -515, 160, -514, -37,

2996

1, -58, 417, 60, -515, 2, 82, 461, 390, 161,

2997

-241, -515, -515, -515, -515, -515, -515, -515, -515, -515,

2998

-515, -515, -515, -515, -515, 31, 32, -515, -515, 63,

2999

-515, 64, -515, -515, -515, -515, -515, -515, -515, -515,

3000

37, 59, -515, -515, -515, -515, 0, -515, 477, -515,

3001

-515, -515, 65, -515, 68, -515, -22, -515, -3, -515,

3002

-515, 30, -515, 3, -515, -515, 100, 85, -515, -515,

3003

-515, -515, -464, -515, -515, -172, -515, -453, -515, -488,

3004

-515, -423, -515, 269, -428, -515, -339, 5, 4, -515,

3005

-515, -515, -515, -515, 535, -103, 116, 140, -269, -515,

3006

-109, -515, -515, -515, -515, -515, -515, -515, -132, -55,

3007

519, -54, -515, 320, -515, -12, -515, -515, -215, -515,

3008

-515, -515, -515, -515, -515

3009

};

3010

3011

/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If

3012

positive, shift that token. If negative, reduce the rule which

3013

number is the opposite. If zero, do what YYDEFACT says.

3014

If YYTABLE_NINF, syntax error. */

3015

#define YYTABLE_NINF -338

3016

static const yytype_int16 yytable[] =

3017

{

3018

71, 56, 58, 76, 81, 247, 172, 110, 387, 173,

3019

264, 253, 113, 153, 184, 290, 118, 346, 491, 456,

3020

458, 423, 94, 289, 366, 366, 123, 568, 428, 133,

3021

134, 569, 570, 135, 136, 137, 139, 144, 505, -74,

3022

173, 212, 213, 214, 214, 241, 242, 563, 499, 106,

3023

260, 499, 539, 580, 71, 56, 58, 76, 81, 250,

3024

57, 188, 509, 402, 106, 74, 479, 403, 75, 256,

3025

590, 107, 480, 230, 438, 231, 231, 579, 232, 232,

3026

597, 538, 471, 261, 139, 566, 116, 100, 101, 282,

3027

510, 478, 269, 270, 525, 274, 95, 100, 101, 577,

3028

102, 103, 139, 93, 407, 283, 416, 444, 144, 445,

3029

102, 103, 139, 104, 57, 588, 367, 477, 96, 74,

3030

290, 337, 75, 104, 108, 111, 379, 453, 122, 414,

3031

144, 339, 340, 100, 101, 139, 139, 432, 519, 185,

3032

99, 114, 185, 185, 102, 103, 102, 103, 185, 100,

3033

101, 120, 119, 124, 500, 501, 121, 104, 501, 104,

3034

476, 163, 102, 103, 596, 164, 71, 56, 58, 76,

3035

81, 502, 166, 288, 502, 104, 294, 295, 296, 297,

3036

298, 299, 300, 301, 302, 303, 304, 305, 306, 307,

3037

308, 309, 310, 311, 312, 313, 314, 315, 316, 317,

3038

467, 372, 490, 322, 323, 324, 325, 326, 327, 328,

3039

329, 330, 331, 332, 333, 334, 335, 336, 144, 338,

3040

188, 233, 105, 388, 389, 234, 57, 349, 457, 459,

3041

425, 74, 426, 237, 75, 249, 100, 101, 385, -111,

3042

71, 56, 356, 377, 524, 341, 144, 318, 381, 102,

3043

103, 320, 342, 251, 343, 424, 254, 549, 344, 255,

3044

319, 257, 104, 318, 259, 258, 139, 139, 262, 320,

3045

263, 265, 406, 100, 101, 266, 272, 275, 571, 362,

3046

175, 2, 175, -75, 548, 277, 102, 103, 373, 447,

3047

176, 450, 278, 417, 279, 13, 178, 15, 16, 104,

3048

18, 487, 20, 280, 175, 281, 434, 285, 286, 347,

3049

180, 260, 348, -117, 176, 25, 363, 274, 364, 177,

3050

178, 371, 382, 529, 30, 31, 32, 274, 376, 600,

3051

2, 412, 179, 378, 180, 125, 139, 126, 384, 144,

3052

127, 128, 129, 390, 13, 450, 15, 16, 391, 18,

3053

318, 20, 144, 71, 56, 356, 320, 100, 101, 413,

3054

386, 71, 56, 356, 25, 392, 115, 101, 394, 396,

3055

102, 103, 529, 30, 31, 32, 100, 101, 530, 102,

3056

103, 320, 400, 104, 401, 409, -335, 435, 489, 102,

3057

103, 528, 104, 420, 462, 422, 463, -337, -336, 464,

3058

373, 466, 104, 415, 366, 189, -241, 470, 448, 429,

3059

430, -158, -116, 474, 446, 431, 433, 438, 442, 443,

3060

452, 144, 71, 56, 356, 454, 488, 530, 455, 469,

3061

485, 468, 472, 190, 191, 192, 494, 193, 194, 195,

3062

196, 197, 198, 493, 473, 498, 425, 518, -338, 520,

3063

516, 521, 320, 526, 535, 211, 541, 212, 213, 214,

3064

-159, 215, 216, 217, 537, 542, 547, 559, 560, 561,

3065

574, 318, 220, 221, 222, 565, 223, 224, 578, 225,

3066

226, 227, 228, 229, -338, -338, 572, 583, 573, 230,

3067

536, 231, 586, 587, 232, 531, 581, 540, 593, 592,

3068

212, 213, 214, 582, 215, 216, 217, 594, 591, 276,

3069

595, 165, 598, 421, 599, 238, 212, 213, 214, -338,

3070

-338, 169, 225, 226, 227, 228, 229, 553, 551, 552,

3071

557, 558, 230, 531, 231, 496, 267, 232, 225, 226,

3072

227, 228, 229, 543, 544, 440, 522, 523, 230, 183,

3073

231, 585, 575, 232, 497, 553, 551, 552, 557, 558,

3074

517, 405, 117, 562, 492, 576, 475, 138, 0, 0,

3075

0, 0, 0, 553, 551, 552, 557, 558, -4, 380,

3076

0, 1, 2, 3, 4, 0, 5, 6, 7, 8,

3077

9, 10, 11, 0, 0, 12, 13, 14, 15, 16,

3078

17, 18, 19, 20, 0, 0, 22, 23, 0, 0,

3079

189, 0, 0, 0, 24, 0, 25, 26, 0, 27,

3080

0, 28, 0, 29, 0, 30, 31, 32, 0, 0,

3081

33, 34, 0, 35, 36, 0, 0, 0, -338, -338,

3082

-338, 37, 38, 39, 0, 0, 197, 198, 0, 40,

3083

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

3084

0, 0, 212, 213, 214, 0, 215, 216, 217, 0,

3085

41, 42, 0, 0, 0, 0, 0, 0, 0, 43,

3086

0, 223, 224, 0, 225, 226, 227, 228, 229, 44,

3087

0, 0, 45, 0, 230, 0, 231, 46, 47, 232,

3088

0, 0, 48, 0, 49, 0, 50, 0, 51, 0,

3089

0, 0, -4, 1, 2, 3, 4, 0, 5, 6,

3090

7, 8, 9, 10, 11, 0, 0, 0, 13, 14,

3091

15, 16, 17, 18, 19, 20, 21, 0, 22, 23,

3092

145, 0, 146, 0, 0, 0, 24, 147, 25, 26,

3093

0, 27, 148, 28, 0, 29, 149, 30, 31, 32,

3094

0, 0, 33, 34, 0, 35, 36, 0, 0, 0,

3095

2, 0, 0, 37, 38, 39, 0, 150, 0, 0,

3096

0, 40, 0, 0, 13, 0, 15, 16, 0, 18,

3097

0, 20, 0, 0, 212, 213, 214, 0, 0, 0,

3098

0, 0, 41, 42, 25, 0, 0, 0, 0, 0,

3099

0, 151, 0, 30, 31, 32, 0, 0, 227, 228,

3100

229, 44, 0, 0, 45, 0, 230, 0, 231, 46,

3101

47, 232, 0, 0, 48, 0, 49, 0, 50, 0,

3102

51, 0, 0, 0, 152, 1, 2, 3, 4, 0,

3103

5, 6, 7, 8, 9, 10, 11, 0, 0, 0,

3104

13, 14, 15, 16, 17, 18, 19, 20, 21, 0,

3105

22, 23, 145, 0, 146, 0, 0, 0, 24, 147,

3106

25, 26, 0, 27, 148, 28, 0, 29, 149, 30,

3107

31, 32, 0, 0, 33, 34, 0, 35, 36, 0,

3108

0, 0, 0, 0, 0, 37, 38, 39, 0, 150,

3109

0, 0, 0, 40, 0, 0, 0, 0, 0, 0,

3110

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

3111

0, 0, 0, 0, 41, 42, 0, 0, 0, 0,

3112

0, 0, 0, 151, 0, 0, 0, 0, 0, 0,

3113

0, 0, 0, 44, 0, 0, 45, 0, 0, 0,

3114

0, 46, 47, 0, 0, 0, 48, 0, 49, 0,

3115

50, 0, 51, 0, 0, 0, 273, 1, 2, 3,

3116

4, 0, 5, 6, 7, 8, 9, 10, 11, 0,

3117

0, 0, 13, 14, 15, 16, 17, 18, 19, 20,

3118

21, 0, 22, 23, 145, 0, 146, 0, 0, 0,

3119

24, 147, 25, 26, 0, 27, 148, 28, 0, 29,

3120

149, 30, 31, 32, 0, 0, 33, 34, 0, 35,

3121

36, 0, 0, 0, 0, 0, 0, 37, 38, 39,

3122

0, 150, 0, 0, 0, 40, 0, 0, 0, 0,

3123

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

3124

0, 0, 0, 0, 0, 0, 41, 42, 0, 0,

3125

0, 0, 0, 0, 0, 151, 0, 0, 0, 0,

3126

0, 0, 0, 0, 0, 44, 0, 0, 45, 0,

3127

0, 0, 0, 46, 47, 0, 0, 0, 48, 0,

3128

49, 0, 50, 0, 51, 0, 0, 0, 441, 1,

3129

2, 3, 4, 0, 5, 6, 7, 8, 9, 10,

3130

11, 0, 0, 12, 13, 14, 15, 16, 17, 18,

3131

19, 20, 0, 0, 22, 23, 0, 0, 0, 0,

3132

0, 0, 24, 0, 25, 26, 0, 27, 0, 28,

3133

0, 29, 0, 30, 31, 32, 0, 0, 33, 34,

3134

0, 35, 36, 0, 0, 0, 0, 0, 0, 37,

3135

38, 39, 0, 0, 0, 0, 0, 40, 0, 0,

3136

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

3137

0, 0, 0, 0, 0, 0, 0, 0, 41, 42,

3138

0, 0, 0, 0, 0, 0, 0, 43, 0, 0,

3139

0, 0, 0, 0, 0, 0, 0, 44, 0, 0,

3140

45, 0, 0, 0, 0, 46, 47, 0, 0, 0,

3141

48, 0, 49, 0, 50, 0, 51, 0, 0, 0,

3142

-3, 1, 2, 3, 4, 0, 5, 6, 7, 8,

3143

9, 10, 11, 0, 0, 0, 13, 14, 15, 16,

3144

17, 18, 19, 20, 0, 0, 22, 23, 0, 0,

3145

0, 0, 0, 0, 24, 0, 25, 26, 0, 27,

3146

0, 28, 0, 29, 0, 30, 31, 32, 0, 0,

3147

33, 34, 0, 35, 36, 0, 0, 0, 0, 0,

3148

0, 37, 38, 39, 0, 0, 0, 0, 0, 40,

3149

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

3150

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

3151

41, 42, 0, 0, 0, 0, 0, 0, 0, 350,

3152

0, 0, 0, 0, 0, 0, 0, 0, 0, 44,

3153

0, 0, 45, 0, 0, 0, 0, 46, 47, 0,

3154

0, 0, 48, 0, 351, 0, 50, 0, 51, 0,

3155

0, 0, -15, 1, 2, 3, 4, 0, 5, 6,

3156

7, 8, 9, 10, 11, 0, 0, 0, 13, 14,

3157

15, 16, 17, 18, 19, 20, 0, 0, 22, 23,

3158

0, 0, 0, 0, 0, 0, 24, 0, 25, 26,

3159

0, 27, 0, 28, 0, 29, 0, 30, 31, 32,

3160

0, 0, 33, 34, 0, 35, 36, 0, 0, 0,

3161

0, 0, 0, 37, 38, 39, 0, 0, 0, 0,

3162

0, 40, 0, 0, 0, 0, 0, 0, 0, 0,

3163

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

3164

0, 0, 41, 42, 0, 0, 0, 0, 0, 0,

3165

0, 350, 0, 0, 0, 0, 0, 0, 0, 0,

3166

0, 44, 0, 0, 45, 0, 0, 0, 0, 46,

3167

47, 0, 0, 0, 48, 0, 351, 0, 50, 0,

3168

51, 0, 0, 0, -16, 1, 2, 3, 4, 0,

3169

5, 6, 7, 8, 9, 10, 11, 0, 0, 0,

3170

13, 14, 15, 16, 17, 18, 19, 20, 0, 0,

3171

22, 23, 0, 0, 0, 0, 0, 0, 24, 0,

3172

25, 26, 0, 27, 0, 28, 0, 29, 0, 30,

3173

31, 32, 0, 0, 33, 34, 0, 35, 36, 0,

3174

0, 0, 0, 0, 0, 37, 38, 39, 0, 0,

3175

0, 0, 0, 40, 0, 0, 0, 0, 0, 0,

3176

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

3177

0, 0, 0, 0, 41, 42, 0, 0, 0, 0,

3178

0, 0, 0, 550, 0, 0, 0, 0, 0, 0,

3179

0, 0, 0, 44, 0, 0, 45, 0, 0, 0,

3180

0, 46, 47, 0, 0, 0, 48, 0, 49, 0,

3181

50, 0, 51, 0, 0, 0, -149, 1, 2, 3,

3182

4, 0, 5, 6, 7, 8, 9, 10, 11, 0,

3183

0, 0, 13, 14, 15, 16, 17, 18, 19, 20,

3184

0, 0, 22, 23, 0, 0, 0, 0, 0, 0,

3185

24, 0, 25, 26, 0, 27, 0, 28, 0, 29,

3186

0, 30, 31, 32, 0, 0, 33, 34, 0, 35,

3187

36, 0, 0, 0, 0, 0, 0, 37, 38, 39,

3188

0, 0, 0, 0, 0, 40, 0, 0, 0, 0,

3189

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

3190

0, 0, 0, 0, 0, 0, 41, 42, 0, 0,

3191

0, 0, 0, 0, 0, 550, 0, 0, 0, 0,

3192

0, 0, 0, 0, 0, 44, 0, 0, 45, 0,

3193

0, 0, 0, 46, 47, 0, 0, 0, 48, 0,

3194

49, 0, 50, 0, 51, 0, -3, 0, -150, 1,

3195

2, 3, 4, 0, 5, 6, 7, 8, 9, 10,

3196

11, 0, 0, 12, 13, 14, 15, 16, 17, 18,

3197

19, 20, 0, 0, 22, 23, 0, 0, 0, 0,

3198

0, 0, 24, 0, 25, 26, 0, 27, 0, 28,

3199

0, 29, 0, 30, 31, 32, 0, 0, 33, 34,

3200

0, 35, 36, 0, 0, 0, 0, 0, 0, 37,

3201

38, 39, 0, 0, 0, 0, 0, 40, 0, 0,

3202

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

3203

0, 0, 0, 0, 0, 0, 0, 0, 41, 42,

3204

0, 0, 0, 0, 0, 0, 0, 43, 0, 0,

3205

0, 0, 0, 0, 0, 0, 0, 44, 0, 0,

3206

45, 0, 0, 0, 0, 46, 47, 0, 0, 0,

3207

48, 0, 49, 0, 50, 0, 51, 1, 2, 3,

3208

4, 0, 5, 6, 7, 8, 9, 10, 11, 0,

3209

-125, 0, 13, 14, 15, 16, 17, 18, 19, 20,

3210

21, 0, 22, 23, 145, 0, 146, 0, 0, 0,

3211

24, 147, 25, 26, 0, 27, 148, 28, 0, 29,

3212

149, 30, 31, 32, 0, 0, 33, 34, 0, 35,

3213

36, 0, 0, 0, 0, 0, 0, 37, 38, 39,

3214

0, 150, 0, 0, 0, 40, 0, 0, 0, 0,

3215

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

3216

0, 0, 0, 0, 0, 0, 41, 42, 0, 0,

3217

0, 0, 0, 0, 0, 151, 0, 0, 0, 0,

3218

0, 0, 0, 0, 0, 44, 0, 0, 45, 0,

3219

0, 0, 0, 46, 47, 0, 0, 0, 48, 0,

3220

49, 0, 50, 0, 51, 1, 2, 3, 4, 0,

3221

5, 6, 7, 8, 9, 10, 11, 0, 0, 0,

3222

13, 14, 15, 16, 17, 18, 19, 20, 21, 0,

3223

22, 23, 145, 0, 146, 0, 0, 0, 24, 147,

3224

25, 26, 0, 27, 148, 28, 0, 29, 149, 30,

3225

31, 32, 0, 0, 33, 34, 0, 35, 36, 0,

3226

0, 0, 0, 0, 0, 37, 38, 39, 0, 150,

3227

0, 0, 0, 40, 0, 0, 0, 0, 0, 0,

3228

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

3229

0, 0, 0, 0, 41, 42, 0, 0, 0, 0,

3230

0, 0, 0, 151, 0, 0, 0, 0, 0, 0,

3231

0, 0, 0, 44, 0, 0, 45, 0, 0, 0,

3232

0, 46, 47, 0, 0, 0, 48, 0, 49, 0,

3233

50, 167, 51, 3, 4, 0, 5, 6, 7, 0,

3234

0, 0, 0, 0, 0, 0, 0, 14, 0, 0,

3235

0, 0, 19, 0, 21, 0, 22, 23, 0, 0,

3236

146, 0, 0, 0, 24, 0, 0, 0, 0, 0,

3237

0, 28, 0, 29, 168, 0, 0, 0, 0, 0,

3238

0, 34, 0, 35, 36, 0, 0, 0, 0, 0,

3239

0, 0, 38, 0, 0, 0, 0, 0, 0, 40,

3240

0, 0, 0, 109, 0, 3, 4, 0, 5, 6,

3241

7, 0, 0, 0, 0, 0, 0, 0, 0, 14,

3242

41, 42, 0, 0, 19, 0, 21, 0, 22, 23,

3243

0, 0, 0, 0, 0, 0, 24, 0, 0, 44,

3244

0, 0, 45, 28, 0, 29, 0, 46, 47, 0,

3245

0, 0, 48, 34, 49, 35, 36, 0, 51, 0,

3246

109, 0, 3, 4, 38, 5, 6, 7, 0, 0,

3247

0, 40, 0, 0, 0, 0, 14, 0, 0, 0,

3248

0, 19, 0, 21, 0, 22, 23, 0, 0, 0,

3249

0, 0, 41, 42, 0, 0, 0, 0, 0, 0,

3250

0, 0, 29, 0, 0, 0, 0, 0, 0, 0,

3251

34, 44, 35, 36, 45, 0, 0, 0, 0, 46,

3252

47, 0, 0, 0, 48, 0, 49, 0, 40, 0,

3253

51, 0, 0, 0, 0, 0, 0, 0, 0, 0,

3254

0, 0, 0, 0, 0, 0, 0, 0, 0, 41,

3255

42, 0, 0, 0, 0, 0, 189, 0, 0, 0,

3256

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

3257

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

3258

0, 48, 0, 49, 190, 191, 192, 51, 193, 194,

3259

195, 196, 197, 198, 199, 200, 201, 202, 203, 204,

3260

205, 206, 207, 208, 209, 210, 211, 0, 212, 213,

3261

214, 0, 215, 216, 217, 0, 0, 0, 0, 0,

3262

218, 219, 0, 220, 221, 222, 189, 223, 224, 0,

3263

225, 226, 227, 228, 229, 0, 0, 0, 0, 0,

3264

230, 0, 231, 0, 0, 232, 0, 0, 0, 0,

3265

0, 418, 0, 0, 190, 191, 192, 0, 193, 194,

3266

195, 196, 197, 198, 199, 200, 201, 202, 203, 204,

3267

205, 206, 207, 208, 209, 210, 211, 0, 212, 213,

3268

214, 0, 215, 216, 217, 0, 0, 0, 0, 0,

3269

218, 219, 0, 220, 221, 222, 189, 223, 224, 0,

3270

225, 226, 227, 228, 229, 0, 0, 0, 0, 0,

3271

230, 0, 231, 0, 0, 232, 0, 0, 0, 0,

3272

0, 507, 0, 0, 190, 191, 192, 0, 193, 194,

3273

195, 196, 197, 198, 199, 200, 201, 202, 203, 204,

3274

205, 206, 207, 208, 209, 210, 211, 0, 212, 213,

3275

214, 0, 215, 216, 217, 0, 0, 0, 189, 0,

3276

218, 219, 408, 220, 221, 222, 0, 223, 224, 0,

3277

225, 226, 227, 228, 229, 0, 0, 0, 0, 0,

3278

230, 0, 231, 0, 0, 232, 190, 191, 192, 0,

3279

193, 194, 195, 196, 197, 198, 199, 200, 201, 202,

3280

203, 204, 205, 206, 207, 208, 209, 210, 211, 0,

3281

212, 213, 214, 0, 215, 216, 217, 0, 0, 0,

3282

189, 0, 218, 219, 0, 220, 221, 222, 0, 223,

3283

224, 0, 225, 226, 227, 228, 229, 0, 0, 0,

3284

0, 0, 230, 0, 231, 410, 0, 232, 190, 191,

3285

192, 0, 193, 194, 195, 196, 197, 198, 199, 200,

3286

201, 202, 203, 204, 205, 206, 207, 208, 209, 210,

3287

211, 0, 212, 213, 214, 0, 215, 216, 217, 0,

3288

0, 0, 189, 0, 218, 219, 0, 220, 221, 222,

3289

0, 223, 224, 0, 225, 226, 227, 228, 229, 0,

3290

0, 0, 0, 0, 230, 0, 231, 465, 0, 232,

3291

190, 191, 192, 0, 193, 194, 195, 196, 197, 198,

3292

199, 200, 201, 202, 203, 204, 205, 206, 207, 208,

3293

209, 210, 211, 0, 212, 213, 214, 0, 215, 216,

3294

217, 0, 0, 0, 189, 0, 218, 219, 0, 220,

3295

221, 222, 0, 223, 224, 0, 225, 226, 227, 228,

3296

229, 0, 0, 0, 0, 0, 230, 0, 231, 506,

3297

0, 232, 190, 191, 192, 0, 193, 194, 195, 196,

3298

197, 198, 199, 200, 201, 202, 203, 204, 205, 206,

3299

207, 208, 209, 210, 211, 0, 212, 213, 214, 0,

3300

215, 216, 217, 0, 0, 0, 189, 0, 218, 219,

3301

0, 220, 221, 222, 0, 223, 224, 0, 225, 226,

3302

227, 228, 229, 0, 0, 0, 0, 0, 230, 0,

3303

231, 508, 0, 232, 190, 191, 192, 0, 193, 194,

3304

195, 196, 197, 198, 199, 200, 201, 202, 203, 204,

3305

205, 206, 207, 208, 209, 210, 211, 0, 212, 213,

3306

214, 0, 215, 216, 217, 0, 0, 0, 189, 0,

3307

218, 219, 0, 220, 221, 222, 0, 223, 224, 0,

3308

225, 226, 227, 228, 229, 0, 0, 0, 0, 0,

3309

230, 0, 231, 515, 0, 232, 190, 191, 192, 0,

3310

193, 194, 195, 196, 197, 198, 199, 200, 201, 202,

3311

203, 204, 205, 206, 207, 208, 209, 210, 211, 0,

3312

212, 213, 214, 0, 215, 216, 217, 0, 0, 0,

3313

189, 0, 218, 219, 567, 220, 221, 222, 0, 223,

3314

224, 0, 225, 226, 227, 228, 229, 0, 0, 0,

3315

0, 0, 230, 0, 231, 0, 0, 232, 190, 191,

3316

192, 0, 193, 194, 195, 196, 197, 198, 199, 200,

3317

201, 202, 203, 204, 205, 206, 207, 208, 209, 210,

3318

211, 0, 212, 213, 214, 0, 215, 216, 217, 0,

3319

0, 0, 189, 0, 218, 219, 0, 220, 221, 222,

3320

0, 223, 224, 0, 225, 226, 227, 228, 229, 0,

3321

0, 0, 0, 0, 230, 0, 231, 0, 0, 232,

3322

190, 191, 192, 0, 193, 194, 195, 196, 197, 198,

3323

199, 200, 201, 202, 203, 204, 205, 206, 207, 208,

3324

209, 210, 211, 0, 212, 213, 214, 0, 215, 216,

3325

217, 0, 0, 0, 189, 0, 218, 219, 0, 220,

3326

221, 222, 0, 0, 224, 0, 225, 226, 227, 228,

3327

229, 0, 0, 0, 0, 0, 230, 0, 231, 0,

3328

0, 232, 190, 191, 192, 0, 193, 194, 195, 196,

3329

197, 198, 0, 0, 0, 0, 0, 0, 0, 0,

3330

0, 0, 0, 0, 0, 0, 212, 213, 214, 0,

3331

215, 216, 217, 0, 0, 0, 189, 0, 0, 0,

3332

0, 220, 221, 222, 0, 223, 224, 0, 225, 226,

3333

227, 228, 229, 0, 0, 0, 0, 0, 230, 0,

3334

231, 0, 0, 232, 190, 191, 192, 0, 193, 194,

3335

195, 196, 197, 198, 0, 0, 0, 0, 0, 0,

3336

0, 0, 0, 0, 0, 0, 0, 0, 212, 213,

3337

214, 0, 215, 216, 217, 0, 0, 0, 189, 0,

3338

0, 0, 0, 0, 221, 222, 0, 223, 224, 0,

3339

225, 226, 227, 228, 229, 0, 0, 0, 0, 0,

3340

230, 0, 231, 0, 0, 232, 190, 191, 192, 0,

3341

193, 194, 195, 196, 197, 198, 0, 0, 0, 0,

3342

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

3343

212, 213, 214, 0, 215, 216, 217, 0, 0, 0,

3344

189, 0, 0, 0, 0, 0, 0, 222, 0, 223,

3345

224, 0, 225, 226, 227, 228, 229, 0, 0, 0,

3346

0, 0, 230, 0, 231, 0, 0, 232, 190, 191,

3347

192, 0, 193, 194, 195, 196, 197, 198, 0, 0,

3348

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

3349

0, 0, 212, 213, 214, 0, 215, 216, 217, 0,

3350

0, 0, 189, 0, 0, 0, 0, 0, 0, -338,

3351

0, 223, 224, 0, 225, 226, 227, 228, 229, 0,

3352

0, 0, 0, 0, 230, 0, 231, 0, 0, 232,

3353

190, 191, 192, 0, -338, -338, -338, -338, 197, 198,

3354

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

3355

0, 0, 0, 0, 212, 213, 214, 0, 215, 216,

3356

217, 0, 0, 0, 0, 0, 0, 0, 0, 0,

3357

0, 0, 0, 223, 224, 0, 225, 226, 227, 228,

3358

229, 0, 0, 0, 0, 0, 230, 0, 231, 0,

3359

0, 232

3360

};

3361

3362

static const yytype_int16 yycheck[] =

3363

{

3364

0, 0, 0, 0, 0, 108, 60, 19, 277, 67,

3365

142, 120, 24, 50, 3, 187, 28, 232, 446, 5,

3366

5, 361, 50, 3, 3, 3, 38, 541, 367, 41,

3367

42, 545, 546, 45, 46, 47, 48, 49, 461, 69,

3368

98, 92, 93, 94, 94, 128, 129, 535, 5, 12,

3369

102, 5, 505, 567, 54, 54, 54, 54, 54, 114,

3370

0, 102, 34, 112, 27, 0, 27, 116, 0, 124,

3371

584, 12, 33, 124, 104, 126, 126, 565, 129, 129,

3372

594, 504, 422, 135, 96, 538, 27, 3, 4, 35,

3373

62, 430, 147, 148, 135, 153, 124, 3, 4, 563,

3374

16, 17, 114, 91, 319, 51, 347, 3, 120, 5,

3375

16, 17, 124, 29, 54, 579, 95, 95, 124, 54,

3376

292, 230, 54, 29, 16, 3, 258, 396, 16, 344,

3377

142, 3, 4, 3, 4, 147, 148, 378, 477, 128,

3378

124, 124, 128, 128, 16, 17, 16, 17, 128, 3,

3379

4, 124, 128, 124, 111, 112, 129, 29, 112, 29,

3380

429, 3, 16, 17, 592, 0, 166, 166, 166, 166,

3381

166, 128, 128, 185, 128, 29, 188, 189, 190, 191,

3382

192, 193, 194, 195, 196, 197, 198, 199, 200, 201,

3383

202, 203, 204, 205, 206, 207, 208, 209, 210, 211,

3384

415, 117, 443, 215, 216, 217, 218, 219, 220, 221,

3385

222, 223, 224, 225, 226, 227, 228, 229, 230, 231,

3386

102, 3, 128, 278, 279, 124, 166, 239, 400, 401,

3387

104, 166, 106, 12, 166, 124, 3, 4, 275, 129,

3388

240, 240, 240, 255, 485, 117, 258, 117, 260, 16,

3389

17, 214, 124, 129, 126, 364, 3, 526, 130, 104,

3390

130, 134, 29, 117, 102, 106, 278, 279, 127, 232,

3391

102, 3, 126, 3, 4, 3, 3, 128, 547, 242,

3392

16, 4, 16, 69, 525, 3, 16, 17, 251, 392,

3393

26, 394, 101, 348, 69, 18, 32, 20, 21, 29,

3394

23, 433, 25, 101, 16, 3, 36, 3, 3, 135,

3395

46, 102, 124, 129, 26, 38, 129, 375, 124, 31,

3396

32, 135, 106, 46, 47, 48, 49, 385, 135, 598,

3397

4, 343, 44, 135, 46, 3, 348, 5, 102, 351,

3398

8, 9, 10, 104, 18, 448, 20, 21, 3, 23,

3399

117, 25, 364, 353, 353, 353, 319, 3, 4, 126,

3400

134, 361, 361, 361, 38, 54, 3, 4, 54, 3,

3401

16, 17, 46, 47, 48, 49, 3, 4, 101, 16,

3402

17, 344, 104, 29, 104, 135, 91, 117, 442, 16,

3403

17, 494, 29, 134, 406, 128, 408, 91, 91, 411,

3404

363, 413, 29, 91, 3, 40, 127, 419, 15, 135,

3405

102, 134, 129, 425, 124, 134, 106, 104, 101, 135,

3406

128, 433, 422, 422, 422, 102, 438, 101, 134, 128,

3407

66, 135, 134, 68, 69, 70, 102, 72, 73, 74,

3408

75, 76, 77, 128, 135, 112, 104, 128, 40, 128,

3409

134, 124, 415, 135, 116, 90, 106, 92, 93, 94,

3410

134, 96, 97, 98, 111, 134, 3, 3, 26, 134,

3411

134, 117, 107, 108, 109, 116, 111, 112, 134, 114,

3412

115, 116, 117, 118, 76, 77, 128, 135, 128, 124,

3413

502, 126, 3, 112, 129, 495, 134, 509, 112, 124,

3414

92, 93, 94, 134, 96, 97, 98, 128, 134, 166,

3415

134, 54, 135, 353, 134, 98, 92, 93, 94, 111,

3416

112, 60, 114, 115, 116, 117, 118, 527, 527, 527,

3417

527, 527, 124, 533, 126, 453, 146, 129, 114, 115,

3418

116, 117, 118, 512, 512, 384, 483, 483, 124, 72,

3419

126, 573, 555, 129, 454, 555, 555, 555, 555, 555,

3420

475, 292, 27, 533, 448, 560, 426, 48, -1, -1,

3421

-1, -1, -1, 573, 573, 573, 573, 573, 0, 259,

3422

-1, 3, 4, 5, 6, -1, 8, 9, 10, 11,

3423

12, 13, 14, -1, -1, 17, 18, 19, 20, 21,

3424

22, 23, 24, 25, -1, -1, 28, 29, -1, -1,

3425

40, -1, -1, -1, 36, -1, 38, 39, -1, 41,

3426

-1, 43, -1, 45, -1, 47, 48, 49, -1, -1,

3427

52, 53, -1, 55, 56, -1, -1, -1, 68, 69,

3428

70, 63, 64, 65, -1, -1, 76, 77, -1, 71,

3429

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

3430

-1, -1, 92, 93, 94, -1, 96, 97, 98, -1,

3431

92, 93, -1, -1, -1, -1, -1, -1, -1, 101,

3432

-1, 111, 112, -1, 114, 115, 116, 117, 118, 111,

3433

-1, -1, 114, -1, 124, -1, 126, 119, 120, 129,

3434

-1, -1, 124, -1, 126, -1, 128, -1, 130, -1,

3435

-1, -1, 134, 3, 4, 5, 6, -1, 8, 9,

3436

10, 11, 12, 13, 14, -1, -1, -1, 18, 19,

3437

20, 21, 22, 23, 24, 25, 26, -1, 28, 29,

3438

30, -1, 32, -1, -1, -1, 36, 37, 38, 39,

3439

-1, 41, 42, 43, -1, 45, 46, 47, 48, 49,

3440

-1, -1, 52, 53, -1, 55, 56, -1, -1, -1,

3441

4, -1, -1, 63, 64, 65, -1, 67, -1, -1,

3442

-1, 71, -1, -1, 18, -1, 20, 21, -1, 23,

3443

-1, 25, -1, -1, 92, 93, 94, -1, -1, -1,

3444

-1, -1, 92, 93, 38, -1, -1, -1, -1, -1,

3445

-1, 101, -1, 47, 48, 49, -1, -1, 116, 117,

3446

118, 111, -1, -1, 114, -1, 124, -1, 126, 119,

3447

120, 129, -1, -1, 124, -1, 126, -1, 128, -1,

3448

130, -1, -1, -1, 134, 3, 4, 5, 6, -1,

3449

8, 9, 10, 11, 12, 13, 14, -1, -1, -1,

3450

18, 19, 20, 21, 22, 23, 24, 25, 26, -1,

3451

28, 29, 30, -1, 32, -1, -1, -1, 36, 37,

3452

38, 39, -1, 41, 42, 43, -1, 45, 46, 47,

3453

48, 49, -1, -1, 52, 53, -1, 55, 56, -1,

3454

-1, -1, -1, -1, -1, 63, 64, 65, -1, 67,

3455

-1, -1, -1, 71, -1, -1, -1, -1, -1, -1,

3456

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

3457

-1, -1, -1, -1, 92, 93, -1, -1, -1, -1,

3458

-1, -1, -1, 101, -1, -1, -1, -1, -1, -1,

3459

-1, -1, -1, 111, -1, -1, 114, -1, -1, -1,

3460

-1, 119, 120, -1, -1, -1, 124, -1, 126, -1,

3461

128, -1, 130, -1, -1, -1, 134, 3, 4, 5,

3462

6, -1, 8, 9, 10, 11, 12, 13, 14, -1,

3463

-1, -1, 18, 19, 20, 21, 22, 23, 24, 25,

3464

26, -1, 28, 29, 30, -1, 32, -1, -1, -1,

3465

36, 37, 38, 39, -1, 41, 42, 43, -1, 45,

3466

46, 47, 48, 49, -1, -1, 52, 53, -1, 55,

3467

56, -1, -1, -1, -1, -1, -1, 63, 64, 65,

3468

-1, 67, -1, -1, -1, 71, -1, -1, -1, -1,

3469

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

3470

-1, -1, -1, -1, -1, -1, 92, 93, -1, -1,

3471

-1, -1, -1, -1, -1, 101, -1, -1, -1, -1,

3472

-1, -1, -1, -1, -1, 111, -1, -1, 114, -1,

3473

-1, -1, -1, 119, 120, -1, -1, -1, 124, -1,

3474

126, -1, 128, -1, 130, -1, -1, -1, 134, 3,

3475

4, 5, 6, -1, 8, 9, 10, 11, 12, 13,

3476

14, -1, -1, 17, 18, 19, 20, 21, 22, 23,

3477

24, 25, -1, -1, 28, 29, -1, -1, -1, -1,

3478

-1, -1, 36, -1, 38, 39, -1, 41, -1, 43,

3479

-1, 45, -1, 47, 48, 49, -1, -1, 52, 53,

3480

-1, 55, 56, -1, -1, -1, -1, -1, -1, 63,

3481

64, 65, -1, -1, -1, -1, -1, 71, -1, -1,

3482

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

3483

-1, -1, -1, -1, -1, -1, -1, -1, 92, 93,

3484

-1, -1, -1, -1, -1, -1, -1, 101, -1, -1,

3485

-1, -1, -1, -1, -1, -1, -1, 111, -1, -1,

3486

114, -1, -1, -1, -1, 119, 120, -1, -1, -1,

3487

124, -1, 126, -1, 128, -1, 130, -1, -1, -1,

3488

134, 3, 4, 5, 6, -1, 8, 9, 10, 11,

3489

12, 13, 14, -1, -1, -1, 18, 19, 20, 21,

3490

22, 23, 24, 25, -1, -1, 28, 29, -1, -1,

3491

-1, -1, -1, -1, 36, -1, 38, 39, -1, 41,

3492

-1, 43, -1, 45, -1, 47, 48, 49, -1, -1,

3493

52, 53, -1, 55, 56, -1, -1, -1, -1, -1,

3494

-1, 63, 64, 65, -1, -1, -1, -1, -1, 71,

3495

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

3496

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

3497

92, 93, -1, -1, -1, -1, -1, -1, -1, 101,

3498

-1, -1, -1, -1, -1, -1, -1, -1, -1, 111,

3499

-1, -1, 114, -1, -1, -1, -1, 119, 120, -1,

3500

-1, -1, 124, -1, 126, -1, 128, -1, 130, -1,

3501

-1, -1, 134, 3, 4, 5, 6, -1, 8, 9,

3502

10, 11, 12, 13, 14, -1, -1, -1, 18, 19,

3503

20, 21, 22, 23, 24, 25, -1, -1, 28, 29,

3504

-1, -1, -1, -1, -1, -1, 36, -1, 38, 39,

3505

-1, 41, -1, 43, -1, 45, -1, 47, 48, 49,

3506

-1, -1, 52, 53, -1, 55, 56, -1, -1, -1,

3507

-1, -1, -1, 63, 64, 65, -1, -1, -1, -1,

3508

-1, 71, -1, -1, -1, -1, -1, -1, -1, -1,

3509

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

3510

-1, -1, 92, 93, -1, -1, -1, -1, -1, -1,

3511

-1, 101, -1, -1, -1, -1, -1, -1, -1, -1,

3512

-1, 111, -1, -1, 114, -1, -1, -1, -1, 119,

3513

120, -1, -1, -1, 124, -1, 126, -1, 128, -1,

3514

130, -1, -1, -1, 134, 3, 4, 5, 6, -1,

3515

8, 9, 10, 11, 12, 13, 14, -1, -1, -1,

3516

18, 19, 20, 21, 22, 23, 24, 25, -1, -1,

3517

28, 29, -1, -1, -1, -1, -1, -1, 36, -1,

3518

38, 39, -1, 41, -1, 43, -1, 45, -1, 47,

3519

48, 49, -1, -1, 52, 53, -1, 55, 56, -1,

3520

-1, -1, -1, -1, -1, 63, 64, 65, -1, -1,

3521

-1, -1, -1, 71, -1, -1, -1, -1, -1, -1,

3522

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

3523

-1, -1, -1, -1, 92, 93, -1, -1, -1, -1,

3524

-1, -1, -1, 101, -1, -1, -1, -1, -1, -1,

3525

-1, -1, -1, 111, -1, -1, 114, -1, -1, -1,

3526

-1, 119, 120, -1, -1, -1, 124, -1, 126, -1,

3527

128, -1, 130, -1, -1, -1, 134, 3, 4, 5,

3528

6, -1, 8, 9, 10, 11, 12, 13, 14, -1,

3529

-1, -1, 18, 19, 20, 21, 22, 23, 24, 25,

3530

-1, -1, 28, 29, -1, -1, -1, -1, -1, -1,

3531

36, -1, 38, 39, -1, 41, -1, 43, -1, 45,

3532

-1, 47, 48, 49, -1, -1, 52, 53, -1, 55,

3533

56, -1, -1, -1, -1, -1, -1, 63, 64, 65,

3534

-1, -1, -1, -1, -1, 71, -1, -1, -1, -1,

3535

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

3536

-1, -1, -1, -1, -1, -1, 92, 93, -1, -1,

3537

-1, -1, -1, -1, -1, 101, -1, -1, -1, -1,

3538

-1, -1, -1, -1, -1, 111, -1, -1, 114, -1,

3539

-1, -1, -1, 119, 120, -1, -1, -1, 124, -1,

3540

126, -1, 128, -1, 130, -1, 0, -1, 134, 3,

3541

4, 5, 6, -1, 8, 9, 10, 11, 12, 13,

3542

14, -1, -1, 17, 18, 19, 20, 21, 22, 23,

3543

24, 25, -1, -1, 28, 29, -1, -1, -1, -1,

3544

-1, -1, 36, -1, 38, 39, -1, 41, -1, 43,

3545

-1, 45, -1, 47, 48, 49, -1, -1, 52, 53,

3546

-1, 55, 56, -1, -1, -1, -1, -1, -1, 63,

3547

64, 65, -1, -1, -1, -1, -1, 71, -1, -1,

3548

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

3549

-1, -1, -1, -1, -1, -1, -1, -1, 92, 93,

3550

-1, -1, -1, -1, -1, -1, -1, 101, -1, -1,

3551

-1, -1, -1, -1, -1, -1, -1, 111, -1, -1,

3552

114, -1, -1, -1, -1, 119, 120, -1, -1, -1,

3553

124, -1, 126, -1, 128, -1, 130, 3, 4, 5,

3554

6, -1, 8, 9, 10, 11, 12, 13, 14, -1,

3555

16, -1, 18, 19, 20, 21, 22, 23, 24, 25,

3556

26, -1, 28, 29, 30, -1, 32, -1, -1, -1,

3557

36, 37, 38, 39, -1, 41, 42, 43, -1, 45,

3558

46, 47, 48, 49, -1, -1, 52, 53, -1, 55,

3559

56, -1, -1, -1, -1, -1, -1, 63, 64, 65,

3560

-1, 67, -1, -1, -1, 71, -1, -1, -1, -1,

3561

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

3562

-1, -1, -1, -1, -1, -1, 92, 93, -1, -1,

3563

-1, -1, -1, -1, -1, 101, -1, -1, -1, -1,

3564

-1, -1, -1, -1, -1, 111, -1, -1, 114, -1,

3565

-1, -1, -1, 119, 120, -1, -1, -1, 124, -1,

3566

126, -1, 128, -1, 130, 3, 4, 5, 6, -1,

3567

8, 9, 10, 11, 12, 13, 14, -1, -1, -1,

3568

18, 19, 20, 21, 22, 23, 24, 25, 26, -1,

3569

28, 29, 30, -1, 32, -1, -1, -1, 36, 37,

3570

38, 39, -1, 41, 42, 43, -1, 45, 46, 47,

3571

48, 49, -1, -1, 52, 53, -1, 55, 56, -1,

3572

-1, -1, -1, -1, -1, 63, 64, 65, -1, 67,

3573

-1, -1, -1, 71, -1, -1, -1, -1, -1, -1,

3574

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

3575

-1, -1, -1, -1, 92, 93, -1, -1, -1, -1,

3576

-1, -1, -1, 101, -1, -1, -1, -1, -1, -1,

3577

-1, -1, -1, 111, -1, -1, 114, -1, -1, -1,

3578

-1, 119, 120, -1, -1, -1, 124, -1, 126, -1,

3579

128, 3, 130, 5, 6, -1, 8, 9, 10, -1,

3580

-1, -1, -1, -1, -1, -1, -1, 19, -1, -1,

3581

-1, -1, 24, -1, 26, -1, 28, 29, -1, -1,

3582

32, -1, -1, -1, 36, -1, -1, -1, -1, -1,

3583

-1, 43, -1, 45, 46, -1, -1, -1, -1, -1,

3584

-1, 53, -1, 55, 56, -1, -1, -1, -1, -1,

3585

-1, -1, 64, -1, -1, -1, -1, -1, -1, 71,

3586

-1, -1, -1, 3, -1, 5, 6, -1, 8, 9,

3587

10, -1, -1, -1, -1, -1, -1, -1, -1, 19,

3588

92, 93, -1, -1, 24, -1, 26, -1, 28, 29,

3589

-1, -1, -1, -1, -1, -1, 36, -1, -1, 111,

3590

-1, -1, 114, 43, -1, 45, -1, 119, 120, -1,

3591

-1, -1, 124, 53, 126, 55, 56, -1, 130, -1,

3592

3, -1, 5, 6, 64, 8, 9, 10, -1, -1,

3593

-1, 71, -1, -1, -1, -1, 19, -1, -1, -1,

3594

-1, 24, -1, 26, -1, 28, 29, -1, -1, -1,

3595

-1, -1, 92, 93, -1, -1, -1, -1, -1, -1,

3596

-1, -1, 45, -1, -1, -1, -1, -1, -1, -1,

3597

53, 111, 55, 56, 114, -1, -1, -1, -1, 119,

3598

120, -1, -1, -1, 124, -1, 126, -1, 71, -1,

3599

130, -1, -1, -1, -1, -1, -1, -1, -1, -1,

3600

-1, -1, -1, -1, -1, -1, -1, -1, -1, 92,

3601

93, -1, -1, -1, -1, -1, 40, -1, -1, -1,

3602

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

3603

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

3604

-1, 124, -1, 126, 68, 69, 70, 130, 72, 73,

3605

74, 75, 76, 77, 78, 79, 80, 81, 82, 83,

3606

84, 85, 86, 87, 88, 89, 90, -1, 92, 93,

3607

94, -1, 96, 97, 98, -1, -1, -1, -1, -1,

3608

104, 105, -1, 107, 108, 109, 40, 111, 112, -1,

3609

114, 115, 116, 117, 118, -1, -1, -1, -1, -1,

3610

124, -1, 126, -1, -1, 129, -1, -1, -1, -1,

3611

-1, 135, -1, -1, 68, 69, 70, -1, 72, 73,

3612

74, 75, 76, 77, 78, 79, 80, 81, 82, 83,

3613

84, 85, 86, 87, 88, 89, 90, -1, 92, 93,

3614

94, -1, 96, 97, 98, -1, -1, -1, -1, -1,

3615

104, 105, -1, 107, 108, 109, 40, 111, 112, -1,

3616

114, 115, 116, 117, 118, -1, -1, -1, -1, -1,

3617

124, -1, 126, -1, -1, 129, -1, -1, -1, -1,

3618

-1, 135, -1, -1, 68, 69, 70, -1, 72, 73,

3619

74, 75, 76, 77, 78, 79, 80, 81, 82, 83,

3620

84, 85, 86, 87, 88, 89, 90, -1, 92, 93,

3621

94, -1, 96, 97, 98, -1, -1, -1, 40, -1,

3622

104, 105, 106, 107, 108, 109, -1, 111, 112, -1,

3623

114, 115, 116, 117, 118, -1, -1, -1, -1, -1,

3624

124, -1, 126, -1, -1, 129, 68, 69, 70, -1,

3625

72, 73, 74, 75, 76, 77, 78, 79, 80, 81,

3626

82, 83, 84, 85, 86, 87, 88, 89, 90, -1,

3627

92, 93, 94, -1, 96, 97, 98, -1, -1, -1,

3628

40, -1, 104, 105, -1, 107, 108, 109, -1, 111,

3629

112, -1, 114, 115, 116, 117, 118, -1, -1, -1,

3630

-1, -1, 124, -1, 126, 127, -1, 129, 68, 69,

3631

70, -1, 72, 73, 74, 75, 76, 77, 78, 79,

3632

80, 81, 82, 83, 84, 85, 86, 87, 88, 89,

3633

90, -1, 92, 93, 94, -1, 96, 97, 98, -1,

3634

-1, -1, 40, -1, 104, 105, -1, 107, 108, 109,

3635

-1, 111, 112, -1, 114, 115, 116, 117, 118, -1,

3636

-1, -1, -1, -1, 124, -1, 126, 127, -1, 129,

3637

68, 69, 70, -1, 72, 73, 74, 75, 76, 77,

3638

78, 79, 80, 81, 82, 83, 84, 85, 86, 87,

3639

88, 89, 90, -1, 92, 93, 94, -1, 96, 97,

3640

98, -1, -1, -1, 40, -1, 104, 105, -1, 107,

3641

108, 109, -1, 111, 112, -1, 114, 115, 116, 117,

3642

118, -1, -1, -1, -1, -1, 124, -1, 126, 127,

3643

-1, 129, 68, 69, 70, -1, 72, 73, 74, 75,

3644

76, 77, 78, 79, 80, 81, 82, 83, 84, 85,

3645

86, 87, 88, 89, 90, -1, 92, 93, 94, -1,

3646

96, 97, 98, -1, -1, -1, 40, -1, 104, 105,

3647

-1, 107, 108, 109, -1, 111, 112, -1, 114, 115,

3648

116, 117, 118, -1, -1, -1, -1, -1, 124, -1,

3649

126, 127, -1, 129, 68, 69, 70, -1, 72, 73,

3650

74, 75, 76, 77, 78, 79, 80, 81, 82, 83,

3651

84, 85, 86, 87, 88, 89, 90, -1, 92, 93,

3652

94, -1, 96, 97, 98, -1, -1, -1, 40, -1,

3653

104, 105, -1, 107, 108, 109, -1, 111, 112, -1,

3654

114, 115, 116, 117, 118, -1, -1, -1, -1, -1,

3655

124, -1, 126, 127, -1, 129, 68, 69, 70, -1,

3656

72, 73, 74, 75, 76, 77, 78, 79, 80, 81,

3657

82, 83, 84, 85, 86, 87, 88, 89, 90, -1,

3658

92, 93, 94, -1, 96, 97, 98, -1, -1, -1,

3659

40, -1, 104, 105, 106, 107, 108, 109, -1, 111,

3660

112, -1, 114, 115, 116, 117, 118, -1, -1, -1,

3661

-1, -1, 124, -1, 126, -1, -1, 129, 68, 69,

3662

70, -1, 72, 73, 74, 75, 76, 77, 78, 79,

3663

80, 81, 82, 83, 84, 85, 86, 87, 88, 89,

3664

90, -1, 92, 93, 94, -1, 96, 97, 98, -1,

3665

-1, -1, 40, -1, 104, 105, -1, 107, 108, 109,

3666

-1, 111, 112, -1, 114, 115, 116, 117, 118, -1,

3667

-1, -1, -1, -1, 124, -1, 126, -1, -1, 129,

3668

68, 69, 70, -1, 72, 73, 74, 75, 76, 77,

3669

78, 79, 80, 81, 82, 83, 84, 85, 86, 87,

3670

88, 89, 90, -1, 92, 93, 94, -1, 96, 97,

3671

98, -1, -1, -1, 40, -1, 104, 105, -1, 107,

3672

108, 109, -1, -1, 112, -1, 114, 115, 116, 117,

3673

118, -1, -1, -1, -1, -1, 124, -1, 126, -1,

3674

-1, 129, 68, 69, 70, -1, 72, 73, 74, 75,

3675

76, 77, -1, -1, -1, -1, -1, -1, -1, -1,

3676

-1, -1, -1, -1, -1, -1, 92, 93, 94, -1,

3677

96, 97, 98, -1, -1, -1, 40, -1, -1, -1,

3678

-1, 107, 108, 109, -1, 111, 112, -1, 114, 115,

3679

116, 117, 118, -1, -1, -1, -1, -1, 124, -1,

3680

126, -1, -1, 129, 68, 69, 70, -1, 72, 73,

3681

74, 75, 76, 77, -1, -1, -1, -1, -1, -1,

3682

-1, -1, -1, -1, -1, -1, -1, -1, 92, 93,

3683

94, -1, 96, 97, 98, -1, -1, -1, 40, -1,

3684

-1, -1, -1, -1, 108, 109, -1, 111, 112, -1,

3685

114, 115, 116, 117, 118, -1, -1, -1, -1, -1,

3686

124, -1, 126, -1, -1, 129, 68, 69, 70, -1,

3687

72, 73, 74, 75, 76, 77, -1, -1, -1, -1,

3688

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

3689

92, 93, 94, -1, 96, 97, 98, -1, -1, -1,

3690

40, -1, -1, -1, -1, -1, -1, 109, -1, 111,

3691

112, -1, 114, 115, 116, 117, 118, -1, -1, -1,

3692

-1, -1, 124, -1, 126, -1, -1, 129, 68, 69,

3693

70, -1, 72, 73, 74, 75, 76, 77, -1, -1,

3694

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

3695

-1, -1, 92, 93, 94, -1, 96, 97, 98, -1,

3696

-1, -1, 40, -1, -1, -1, -1, -1, -1, 109,

3697

-1, 111, 112, -1, 114, 115, 116, 117, 118, -1,

3698

-1, -1, -1, -1, 124, -1, 126, -1, -1, 129,

3699

68, 69, 70, -1, 72, 73, 74, 75, 76, 77,

3700

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

3701

-1, -1, -1, -1, 92, 93, 94, -1, 96, 97,

3702

98, -1, -1, -1, -1, -1, -1, -1, -1, -1,

3703

-1, -1, -1, 111, 112, -1, 114, 115, 116, 117,

3704

118, -1, -1, -1, -1, -1, 124, -1, 126, -1,

3705

-1, 129

3706

};

3707

3708

/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing

3709

symbol of state STATE-NUM. */

3710

static const yytype_uint16 yystos[] =

3711

{

3712

0, 3, 4, 5, 6, 8, 9, 10, 11, 12,

3713

13, 14, 17, 18, 19, 20, 21, 22, 23, 24,

3714

25, 26, 28, 29, 36, 38, 39, 41, 43, 45,

3715

47, 48, 49, 52, 53, 55, 56, 63, 64, 65,

3716

71, 92, 93, 101, 111, 114, 119, 120, 124, 126,

3717

128, 130, 137, 138, 139, 140, 146, 149, 151, 159,

3718

162, 163, 164, 165, 166, 173, 181, 184, 185, 188,

3719

191, 192, 193, 194, 198, 200, 209, 214, 215, 216,

3720

227, 234, 237, 250, 251, 252, 257, 261, 265, 266,

3721

268, 269, 270, 91, 50, 124, 124, 156, 157, 124,

3722

3, 4, 16, 17, 29, 128, 186, 187, 16, 3,

3723

261, 3, 236, 261, 124, 3, 187, 240, 261, 128,

3724

124, 129, 16, 261, 124, 3, 5, 8, 9, 10,

3725

258, 259, 260, 261, 261, 261, 261, 261, 256, 261,

3726

246, 247, 248, 254, 261, 30, 32, 37, 42, 46,

3727

67, 101, 134, 145, 146, 147, 151, 153, 167, 168,

3728

183, 192, 253, 3, 0, 140, 128, 3, 46, 153,

3729

160, 161, 257, 147, 148, 16, 26, 31, 32, 44,

3730

46, 208, 267, 194, 3, 128, 221, 225, 102, 40,

3731

68, 69, 70, 72, 73, 74, 75, 76, 77, 78,

3732

79, 80, 81, 82, 83, 84, 85, 86, 87, 88,

3733

89, 90, 92, 93, 94, 96, 97, 98, 104, 105,

3734

107, 108, 109, 111, 112, 114, 115, 116, 117, 118,

3735

124, 126, 129, 3, 124, 255, 256, 12, 148, 174,

3736

190, 128, 129, 186, 187, 239, 240, 241, 249, 124,

3737

255, 129, 182, 246, 3, 104, 255, 134, 106, 102,

3738

102, 135, 127, 102, 254, 3, 3, 154, 155, 255,

3739

255, 154, 3, 134, 147, 128, 138, 3, 101, 69,

3740

101, 3, 35, 51, 233, 3, 3, 210, 261, 3,

3741

221, 226, 228, 229, 261, 261, 261, 261, 261, 261,

3742

261, 261, 261, 261, 261, 261, 261, 261, 261, 261,

3743

261, 261, 261, 261, 261, 261, 261, 261, 117, 130,

3744

186, 264, 261, 261, 261, 261, 261, 261, 261, 261,

3745

261, 261, 261, 261, 261, 261, 261, 246, 261, 3,

3746

4, 117, 124, 126, 130, 263, 264, 135, 124, 261,

3747

101, 126, 141, 142, 143, 149, 151, 198, 200, 209,

3748

234, 189, 186, 129, 124, 245, 3, 95, 230, 231,

3749

232, 135, 117, 186, 144, 145, 135, 261, 135, 254,

3750

259, 261, 106, 244, 102, 145, 134, 244, 255, 255,

3751

104, 3, 54, 195, 54, 196, 3, 211, 212, 222,

3752

104, 104, 112, 116, 217, 229, 126, 264, 106, 135,

3753

127, 262, 261, 126, 264, 91, 156, 255, 135, 150,

3754

134, 143, 128, 141, 246, 104, 106, 213, 232, 135,

3755

102, 134, 156, 106, 36, 117, 241, 243, 104, 152,

3756

155, 134, 101, 135, 3, 5, 124, 241, 15, 197,

3757

241, 242, 128, 244, 102, 134, 5, 221, 5, 221,

3758

218, 223, 261, 261, 261, 127, 261, 264, 135, 128,

3759

261, 141, 134, 135, 261, 243, 244, 95, 232, 27,

3760

33, 175, 177, 179, 180, 66, 158, 254, 261, 257,

3761

156, 230, 242, 128, 102, 201, 152, 212, 112, 5,

3762

111, 112, 128, 219, 224, 227, 127, 135, 127, 34,

3763

62, 169, 170, 171, 172, 127, 134, 213, 128, 232,

3764

128, 124, 175, 177, 156, 135, 135, 199, 241, 46,

3765

101, 192, 205, 206, 207, 116, 261, 111, 227, 223,

3766

261, 106, 134, 171, 172, 238, 178, 3, 156, 244,

3767

101, 146, 151, 192, 202, 203, 204, 209, 234, 3,

3768

26, 134, 207, 225, 220, 116, 223, 106, 144, 144,

3769

144, 244, 128, 128, 134, 204, 233, 218, 134, 225,

3770

144, 134, 134, 135, 235, 202, 3, 112, 218, 176,

3771

144, 134, 124, 112, 128, 134, 230, 144, 135, 134,

3772

244

3773

};

3774

3775

#define yyerrok (yyerrstatus = 0)

3776

#define yyclearin (yychar = YYEMPTY)

3777

#define YYEMPTY (-2)

3778

#define YYEOF 0

3779

3780

#define YYACCEPT goto yyacceptlab

3781

#define YYABORT goto yyabortlab

3782

#define YYERROR goto yyerrorlab

3783

3784

3785

/* Like YYERROR except do call yyerror. This remains here temporarily

3786

to ease the transition to the new meaning of YYERROR, for GCC.

3787

Once GCC version 2 has supplanted version 1, this can go. */

3788

3789

#define YYFAIL goto yyerrlab

3790

3791

#define YYRECOVERING() (!!yyerrstatus)

3792

3793

#define YYBACKUP(Token, Value) \

3794

do \

3795

if (yychar == YYEMPTY && yylen == 1) \

3796

{ \

3797

yychar = (Token); \

3798

yylval = (Value); \

3799

yytoken = YYTRANSLATE (yychar); \

3800

YYPOPSTACK (1); \

3801

goto yybackup; \

3802

} \

3803

else \

3804

{ \

3805

yyerror (YY_("syntax error: cannot back up")); \

3806

YYERROR; \

3807

} \

3808

while (YYID (0))

3809

3810

3811

#define YYTERROR 1

3812

#define YYERRCODE 256

3813

3814

3815

/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].

3816

If N is 0, then set CURRENT to the empty location which ends

3817

the previous symbol: RHS[0] (always defined). */

3818

3819

#define YYRHSLOC(Rhs, K) ((Rhs)[K])

3820

#ifndef YYLLOC_DEFAULT

3821

# define YYLLOC_DEFAULT(Current, Rhs, N) \

3822

do \

3823

if (YYID (N)) \

3824

{ \

3825

(Current).first_line = YYRHSLOC (Rhs, 1).first_line; \

3826

(Current).first_column = YYRHSLOC (Rhs, 1).first_column; \

3827

(Current).last_line = YYRHSLOC (Rhs, N).last_line; \

3828

(Current).last_column = YYRHSLOC (Rhs, N).last_column; \

3829

} \

3830

else \

3831

{ \

3832

(Current).first_line = (Current).last_line = \

3833

YYRHSLOC (Rhs, 0).last_line; \

3834

(Current).first_column = (Current).last_column = \

3835

YYRHSLOC (Rhs, 0).last_column; \

3836

} \

3837

while (YYID (0))

3838

#endif

3839

3840

3841

/* YY_LOCATION_PRINT -- Print the location on the stream.

3842

This macro was not mandated originally: define only if we know

3843

we won't break user code: when these are the locations we know. */

3844

3845

#ifndef YY_LOCATION_PRINT

3846

# if YYLTYPE_IS_TRIVIAL

3847

# define YY_LOCATION_PRINT(File, Loc) \

3848

fprintf (File, "%d.%d-%d.%d", \

3849

(Loc).first_line, (Loc).first_column, \

3850

(Loc).last_line, (Loc).last_column)

3851

# else

3852

# define YY_LOCATION_PRINT(File, Loc) ((void) 0)

3853

# endif

3854

#endif

3855

3856

3857

/* YYLEX -- calling `yylex' with the right arguments. */

3858

3859

#ifdef YYLEX_PARAM

3860

# define YYLEX yylex (YYLEX_PARAM)

3861

#else

3862

# define YYLEX yylex ()

3863

#endif

3864

3865

/* Enable debugging if requested. */

3866

#if YYDEBUG

3867

3868

# ifndef YYFPRINTF

3869

# include <stdio.h> /* INFRINGES ON USER NAME SPACE */

3870

# define YYFPRINTF fprintf

3871

# endif

3872

3873

# define YYDPRINTF(Args) \

3874

do { \

3875

if (yydebug) \

3876

YYFPRINTF Args; \

3877

} while (YYID (0))

3878

3879

# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \

3880

do { \

3881

if (yydebug) \

3882

{ \

3883

YYFPRINTF (stderr, "%s ", Title); \

3884

yy_symbol_print (stderr, \

3885

Type, Value); \

3886

YYFPRINTF (stderr, "\n"); \

3887

} \

3888

} while (YYID (0))

3889

3890

3891

/*--------------------------------.

3892

| Print this symbol on YYOUTPUT. |

3893

`--------------------------------*/

3894

3895

/*ARGSUSED*/

3896

#if (defined __STDC__ || defined __C99__FUNC__ \

3897

|| defined __cplusplus || defined _MSC_VER)

3898

static void

3899

yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)

3900

#else

3901

static void

3902

yy_symbol_value_print (yyoutput, yytype, yyvaluep)

3903

FILE *yyoutput;

3904

int yytype;

3905

YYSTYPE const * const yyvaluep;

3906

#endif

3907

{

3908

if (!yyvaluep)

3909

return;

3910

# ifdef YYPRINT

3911

if (yytype < YYNTOKENS)

3912

YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);

3913

# else

3914

YYUSE (yyoutput);

3915

# endif

3916

switch (yytype)

3917

{

3918

default:

3919

break;

3920

}

3921

}

3922

3923

3924

/*--------------------------------.

3925

| Print this symbol on YYOUTPUT. |

3926

`--------------------------------*/

3927

3928

#if (defined __STDC__ || defined __C99__FUNC__ \

3929

|| defined __cplusplus || defined _MSC_VER)

3930

static void

3931

yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)

3932

#else

3933

static void

3934

yy_symbol_print (yyoutput, yytype, yyvaluep)

3935

FILE *yyoutput;

3936

int yytype;

3937

YYSTYPE const * const yyvaluep;

3938

#endif

3939

{

3940

if (yytype < YYNTOKENS)

3941

YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);

3942

else

3943

YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);

3944

3945

yy_symbol_value_print (yyoutput, yytype, yyvaluep);

3946

YYFPRINTF (yyoutput, ")");

3947

}

3948

3949

/*------------------------------------------------------------------.

3950

| yy_stack_print -- Print the state stack from its BOTTOM up to its |

3951

| TOP (included). |

3952

`------------------------------------------------------------------*/

3953

3954

#if (defined __STDC__ || defined __C99__FUNC__ \

3955

|| defined __cplusplus || defined _MSC_VER)

3956

static void

3957

yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)

3958

#else

3959

static void

3960

yy_stack_print (yybottom, yytop)

3961

yytype_int16 *yybottom;

3962

yytype_int16 *yytop;

3963

#endif

3964

{

3965

YYFPRINTF (stderr, "Stack now");

3966

for (; yybottom <= yytop; yybottom++)

3967

{

3968

int yybot = *yybottom;

3969

YYFPRINTF (stderr, " %d", yybot);

3970

}

3971

YYFPRINTF (stderr, "\n");

3972

}

3973

3974

# define YY_STACK_PRINT(Bottom, Top) \

3975

do { \

3976

if (yydebug) \

3977

yy_stack_print ((Bottom), (Top)); \

3978

} while (YYID (0))

3979

3980

3981

/*------------------------------------------------.

3982

| Report that the YYRULE is going to be reduced. |

3983

`------------------------------------------------*/

3984

3985

#if (defined __STDC__ || defined __C99__FUNC__ \

3986

|| defined __cplusplus || defined _MSC_VER)

3987

static void

3988

yy_reduce_print (YYSTYPE *yyvsp, int yyrule)

3989

#else

3990

static void

3991

yy_reduce_print (yyvsp, yyrule)

3992

YYSTYPE *yyvsp;

3993

int yyrule;

3994

#endif

3995

{

3996

int yynrhs = yyr2[yyrule];

3997

int yyi;

3998

unsigned long int yylno = yyrline[yyrule];

3999

YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",

4000

yyrule - 1, yylno);

4001

/* The symbols being reduced. */

4002

for (yyi = 0; yyi < yynrhs; yyi++)

4003

{

4004

YYFPRINTF (stderr, " $%d = ", yyi + 1);

4005

yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],

4006

&(yyvsp[(yyi + 1) - (yynrhs)])

4007

);

4008

YYFPRINTF (stderr, "\n");

4009

}

4010

}

4011

4012

# define YY_REDUCE_PRINT(Rule) \

4013

do { \

4014

if (yydebug) \

4015

yy_reduce_print (yyvsp, Rule); \

4016

} while (YYID (0))

4017

4018

/* Nonzero means print parse trace. It is left uninitialized so that

4019

multiple parsers can coexist. */

4020

int yydebug;

4021

#else /* !YYDEBUG */

4022

# define YYDPRINTF(Args)

4023

# define YY_SYMBOL_PRINT(Title, Type, Value, Location)

4024

# define YY_STACK_PRINT(Bottom, Top)

4025

# define YY_REDUCE_PRINT(Rule)

4026

#endif /* !YYDEBUG */

4027

4028

4029

/* YYINITDEPTH -- initial size of the parser's stacks. */

4030

#ifndef YYINITDEPTH

4031

# define YYINITDEPTH 200

4032

#endif

4033

4034

/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only

4035

if the built-in stack extension method is used).

4036

4037

Do not make this value too large; the results are undefined if

4038

YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)

4039

evaluated with infinite-precision integer arithmetic. */

4040

4041

#ifndef YYMAXDEPTH

4042

# define YYMAXDEPTH 10000

4043

#endif

4044

4045

4046

4047

#if YYERROR_VERBOSE

4048

4049

# ifndef yystrlen

4050

# if defined __GLIBC__ && defined _STRING_H

4051

# define yystrlen strlen

4052

# else

4053

/* Return the length of YYSTR. */

4054

#if (defined __STDC__ || defined __C99__FUNC__ \

4055

|| defined __cplusplus || defined _MSC_VER)

4056

static YYSIZE_T

4057

yystrlen (const char *yystr)

4058

#else

4059

static YYSIZE_T

4060

yystrlen (yystr)

4061

const char *yystr;

4062

#endif

4063

{

4064

YYSIZE_T yylen;

4065

for (yylen = 0; yystr[yylen]; yylen++)

4066

continue;

4067

return yylen;

4068

}

4069

# endif

4070

# endif

4071

4072

# ifndef yystpcpy

4073

# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE

4074

# define yystpcpy stpcpy

4075

# else

4076

/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in

4077

YYDEST. */

4078

#if (defined __STDC__ || defined __C99__FUNC__ \

4079

|| defined __cplusplus || defined _MSC_VER)

4080

static char *

4081

yystpcpy (char *yydest, const char *yysrc)

4082

#else

4083

static char *

4084

yystpcpy (yydest, yysrc)

4085

char *yydest;

4086

const char *yysrc;

4087

#endif

4088

{

4089

char *yyd = yydest;

4090

const char *yys = yysrc;

4091

4092

while ((*yyd++ = *yys++) != '\0')

4093

continue;

4094

4095

return yyd - 1;

4096

}

4097

# endif

4098

# endif

4099

4100

# ifndef yytnamerr

4101

/* Copy to YYRES the contents of YYSTR after stripping away unnecessary

4102

quotes and backslashes, so that it's suitable for yyerror. The

4103

heuristic is that double-quoting is unnecessary unless the string

4104

contains an apostrophe, a comma, or backslash (other than

4105

backslash-backslash). YYSTR is taken from yytname. If YYRES is

4106

null, do not copy; instead, return the length of what the result

4107

would have been. */

4108

static YYSIZE_T

4109

yytnamerr (char *yyres, const char *yystr)

4110

{

4111

if (*yystr == '"')

4112

{

4113

YYSIZE_T yyn = 0;

4114

char const *yyp = yystr;

4115

4116

for (;;)

4117

switch (*++yyp)

4118

{

4119

case '\'':

4120

case ',':

4121

goto do_not_strip_quotes;

4122

4123

case '\\':

4124

if (*++yyp != '\\')

4125

goto do_not_strip_quotes;

4126

/* Fall through. */

4127

default:

4128

if (yyres)

4129

yyres[yyn] = *yyp;

4130

yyn++;

4131

break;

4132

4133

case '"':

4134

if (yyres)

4135

yyres[yyn] = '\0';

4136

return yyn;

4137

}

4138

do_not_strip_quotes: ;

4139

}

4140

4141

if (! yyres)

4142

return yystrlen (yystr);

4143

4144

return yystpcpy (yyres, yystr) - yyres;

4145

}

4146

# endif

4147

4148

/* Copy into YYRESULT an error message about the unexpected token

4149

YYCHAR while in state YYSTATE. Return the number of bytes copied,

4150

including the terminating null byte. If YYRESULT is null, do not

4151

copy anything; just return the number of bytes that would be

4152

copied. As a special case, return 0 if an ordinary "syntax error"

4153

message will do. Return YYSIZE_MAXIMUM if overflow occurs during

4154

size calculation. */

4155

static YYSIZE_T

4156

yysyntax_error (char *yyresult, int yystate, int yychar)

4157

{

4158

int yyn = yypact[yystate];

4159

4160

if (! (YYPACT_NINF < yyn && yyn <= YYLAST))

4161

return 0;

4162

else

4163

{

4164

int yytype = YYTRANSLATE (yychar);

4165

YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);

4166

YYSIZE_T yysize = yysize0;

4167

YYSIZE_T yysize1;

4168

int yysize_overflow = 0;

4169

enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };

4170

char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];

4171

int yyx;

4172

4173

# if 0

4174

/* This is so xgettext sees the translatable formats that are

4175

constructed on the fly. */

4176

YY_("syntax error, unexpected %s");

4177

YY_("syntax error, unexpected %s, expecting %s");

4178

YY_("syntax error, unexpected %s, expecting %s or %s");

4179

YY_("syntax error, unexpected %s, expecting %s or %s or %s");

4180

YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");

4181

# endif

4182

char *yyfmt;

4183

char const *yyf;

4184

static char const yyunexpected[] = "syntax error, unexpected %s";

4185

static char const yyexpecting[] = ", expecting %s";

4186

static char const yyor[] = " or %s";

4187

char yyformat[sizeof yyunexpected

4188

+ sizeof yyexpecting - 1

4189

+ ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)

4190

* (sizeof yyor - 1))];

4191

char const *yyprefix = yyexpecting;

4192

4193

/* Start YYX at -YYN if negative to avoid negative indexes in

4194

YYCHECK. */

4195

int yyxbegin = yyn < 0 ? -yyn : 0;

4196

4197

/* Stay within bounds of both yycheck and yytname. */

4198

int yychecklim = YYLAST - yyn + 1;

4199

int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;

4200

int yycount = 1;

4201

4202

yyarg[0] = yytname[yytype];

4203

yyfmt = yystpcpy (yyformat, yyunexpected);

4204

4205

for (yyx = yyxbegin; yyx < yyxend; ++yyx)

4206

if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)

4207

{

4208

if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)

4209

{

4210

yycount = 1;

4211

yysize = yysize0;

4212

yyformat[sizeof yyunexpected - 1] = '\0';

4213

break;

4214

}

4215

yyarg[yycount++] = yytname[yyx];

4216

yysize1 = yysize + yytnamerr (0, yytname[yyx]);

4217

yysize_overflow |= (yysize1 < yysize);

4218

yysize = yysize1;

4219

yyfmt = yystpcpy (yyfmt, yyprefix);

4220

yyprefix = yyor;

4221

}

4222

4223

yyf = YY_(yyformat);

4224

yysize1 = yysize + yystrlen (yyf);

4225

yysize_overflow |= (yysize1 < yysize);

4226

yysize = yysize1;

4227

4228

if (yysize_overflow)

4229

return YYSIZE_MAXIMUM;

4230

4231

if (yyresult)

4232

{

4233

/* Avoid sprintf, as that infringes on the user's name space.

4234

Don't have undefined behavior even if the translation

4235

produced a string with the wrong number of "%s"s. */

4236

char *yyp = yyresult;

4237

int yyi = 0;

4238

while ((*yyp = *yyf) != '\0')

4239

{

4240

if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)

4241

{

4242

yyp += yytnamerr (yyp, yyarg[yyi++]);

4243

yyf += 2;

4244

}

4245

else

4246

{

4247

yyp++;

4248

yyf++;

4249

}

4250

}

4251

}

4252

return yysize;

4253

}

4254

}

4255

#endif /* YYERROR_VERBOSE */

4256

4257

4258

/*-----------------------------------------------.

4259

| Release the memory associated to this symbol. |

4260

`-----------------------------------------------*/

4261

4262

/*ARGSUSED*/

4263

#if (defined __STDC__ || defined __C99__FUNC__ \

4264

|| defined __cplusplus || defined _MSC_VER)

4265

static void

4266

yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)

4267

#else

4268

static void

4269

yydestruct (yymsg, yytype, yyvaluep)

4270

const char *yymsg;

4271

int yytype;

4272

YYSTYPE *yyvaluep;

4273

#endif

4274

{

4275

YYUSE (yyvaluep);

4276

4277

if (!yymsg)

4278

yymsg = "Deleting";

4279

YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);

4280

4281

switch (yytype)

4282

{

4283

4284

default:

4285

break;

4286

}

4287

}

4288

4289

/* Prevent warnings from -Wmissing-prototypes. */

4290

#ifdef YYPARSE_PARAM

4291

#if defined __STDC__ || defined __cplusplus

4292

int yyparse (void *YYPARSE_PARAM);

4293

#else

4294

int yyparse ();

4295

#endif

4296

#else /* ! YYPARSE_PARAM */

4297

#if defined __STDC__ || defined __cplusplus

4298

int yyparse (void);

4299

#else

4300

int yyparse ();

4301

#endif

4302

#endif /* ! YYPARSE_PARAM */

4303

4304

4305

/* The lookahead symbol. */

4306

int yychar;

4307

4308

/* The semantic value of the lookahead symbol. */

4309

YYSTYPE yylval;

4310

4311

/* Number of syntax errors so far. */

4312

int yynerrs;

4313

4314

4315

4316

/*-------------------------.

4317

| yyparse or yypush_parse. |

4318

`-------------------------*/

4319

4320

#ifdef YYPARSE_PARAM

4321

#if (defined __STDC__ || defined __C99__FUNC__ \

4322

|| defined __cplusplus || defined _MSC_VER)

4323

int

4324

yyparse (void *YYPARSE_PARAM)

4325

#else

4326

int

4327

yyparse (YYPARSE_PARAM)

4328

void *YYPARSE_PARAM;

4329

#endif

4330

#else /* ! YYPARSE_PARAM */

4331

#if (defined __STDC__ || defined __C99__FUNC__ \

4332

|| defined __cplusplus || defined _MSC_VER)

4333

int

4334

yyparse (void)

4335

#else

4336

int

4337

yyparse ()

4338

4339

#endif

4340

#endif

4341

{

4342

4343

4344

int yystate;

4345

/* Number of tokens to shift before error messages enabled. */

4346

int yyerrstatus;

4347

4348

/* The stacks and their tools:

4349

`yyss': related to states.

4350

`yyvs': related to semantic values.

4351

4352

Refer to the stacks thru separate pointers, to allow yyoverflow

4353

to reallocate them elsewhere. */

4354

4355

/* The state stack. */

4356

yytype_int16 yyssa[YYINITDEPTH];

4357

yytype_int16 *yyss;

4358

yytype_int16 *yyssp;

4359

4360

/* The semantic value stack. */

4361

YYSTYPE yyvsa[YYINITDEPTH];

4362

YYSTYPE *yyvs;

4363

YYSTYPE *yyvsp;

4364

4365

YYSIZE_T yystacksize;

4366

4367

int yyn;

4368

int yyresult;

4369

/* Lookahead token as an internal (translated) token number. */

4370

int yytoken;

4371

/* The variables used to return semantic value and location from the

4372

action routines. */

4373

YYSTYPE yyval;

4374

4375

#if YYERROR_VERBOSE

4376

/* Buffer for error messages, and its allocated size. */

4377

char yymsgbuf[128];

4378

char *yymsg = yymsgbuf;

4379

YYSIZE_T yymsg_alloc = sizeof yymsgbuf;

4380

#endif

4381

4382

#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))

4383

4384

/* The number of symbols on the RHS of the reduced rule.

4385

Keep to zero when no symbol should be popped. */

4386

int yylen = 0;

4387

4388

yytoken = 0;

4389

yyss = yyssa;

4390

yyvs = yyvsa;

4391

yystacksize = YYINITDEPTH;

4392

4393

YYDPRINTF ((stderr, "Starting parse\n"));

4394

4395

yystate = 0;

4396

yyerrstatus = 0;

4397

yynerrs = 0;

4398

yychar = YYEMPTY; /* Cause a token to be read. */

4399

4400

/* Initialize stack pointers.

4401

Waste one element of value and location stack

4402

so that they stay on the same level as the state stack.

4403

The wasted elements are never initialized. */

4404

yyssp = yyss;

4405

yyvsp = yyvs;

4406

4407

goto yysetstate;

4408

4409

/*------------------------------------------------------------.

4410

| yynewstate -- Push a new state, which is found in yystate. |

4411

`------------------------------------------------------------*/

4412

yynewstate:

4413

/* In all cases, when you get here, the value and location stacks

4414

have just been pushed. So pushing a state here evens the stacks. */

4415

yyssp++;

4416

4417

yysetstate:

4418

*yyssp = yystate;

4419

4420

if (yyss + yystacksize - 1 <= yyssp)

4421

{

4422

/* Get the current used size of the three stacks, in elements. */

4423

YYSIZE_T yysize = yyssp - yyss + 1;

4424

4425

#ifdef yyoverflow

4426

{

4427

/* Give user a chance to reallocate the stack. Use copies of

4428

these so that the &'s don't force the real ones into

4429

memory. */

4430

YYSTYPE *yyvs1 = yyvs;

4431

yytype_int16 *yyss1 = yyss;

4432

4433

/* Each stack pointer address is followed by the size of the

4434

data in use in that stack, in bytes. This used to be a

4435

conditional around just the two extra args, but that might

4436

be undefined if yyoverflow is a macro. */

4437

yyoverflow (YY_("memory exhausted"),

4438

&yyss1, yysize * sizeof (*yyssp),

4439

&yyvs1, yysize * sizeof (*yyvsp),

4440

&yystacksize);

4441

4442

yyss = yyss1;

4443

yyvs = yyvs1;

4444

}

4445

#else /* no yyoverflow */

4446

# ifndef YYSTACK_RELOCATE

4447

goto yyexhaustedlab;

4448

# else

4449

/* Extend the stack our own way. */

4450

if (YYMAXDEPTH <= yystacksize)

4451

goto yyexhaustedlab;

4452

yystacksize *= 2;

4453

if (YYMAXDEPTH < yystacksize)

4454

yystacksize = YYMAXDEPTH;

4455

4456

{

4457

yytype_int16 *yyss1 = yyss;

4458

union yyalloc *yyptr =

4459

(union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));

4460

if (! yyptr)

4461

goto yyexhaustedlab;

4462

YYSTACK_RELOCATE (yyss_alloc, yyss);

4463

YYSTACK_RELOCATE (yyvs_alloc, yyvs);

4464

# undef YYSTACK_RELOCATE

4465

if (yyss1 != yyssa)

4466

YYSTACK_FREE (yyss1);

4467

}

4468

# endif

4469

#endif /* no yyoverflow */

4470

4471

yyssp = yyss + yysize - 1;

4472

yyvsp = yyvs + yysize - 1;

4473

4474

YYDPRINTF ((stderr, "Stack size increased to %lu\n",

4475

(unsigned long int) yystacksize));

4476

4477

if (yyss + yystacksize - 1 <= yyssp)

4478

YYABORT;

4479

}

4480

4481

YYDPRINTF ((stderr, "Entering state %d\n", yystate));

4482

4483

if (yystate == YYFINAL)

4484

YYACCEPT;

4485

4486

goto yybackup;

4487

4488

/*-----------.

4489

| yybackup. |

4490

`-----------*/

4491

yybackup:

4492

4493

/* Do appropriate processing given the current state. Read a

4494

lookahead token if we need one and don't already have one. */

4495

4496

/* First try to decide what to do without reference to lookahead token. */

4497

yyn = yypact[yystate];

4498

if (yyn == YYPACT_NINF)

4499

goto yydefault;

4500

4501

/* Not known => get a lookahead token if don't already have one. */

4502

4503

/* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */

4504

if (yychar == YYEMPTY)

4505

{

4506

YYDPRINTF ((stderr, "Reading a token: "));

4507

yychar = YYLEX;

4508

}

4509

4510

if (yychar <= YYEOF)

4511

{

4512

yychar = yytoken = YYEOF;

4513

YYDPRINTF ((stderr, "Now at end of input.\n"));

4514

}

4515

else

4516

{

4517

yytoken = YYTRANSLATE (yychar);

4518

YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);

4519

}

4520

4521

/* If the proper action on seeing token YYTOKEN is to reduce or to

4522

detect an error, take that action. */

4523

yyn += yytoken;

4524

if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)

4525

goto yydefault;

4526

yyn = yytable[yyn];

4527

if (yyn <= 0)

4528

{

4529

if (yyn == 0 || yyn == YYTABLE_NINF)

4530

goto yyerrlab;

4531

yyn = -yyn;

4532

goto yyreduce;

4533

}

4534

4535

/* Count tokens shifted since error; after three, turn off error

4536

status. */

4537

if (yyerrstatus)

4538

yyerrstatus--;

4539

4540

/* Shift the lookahead token. */

4541

YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);

4542

4543

/* Discard the shifted token. */

4544

yychar = YYEMPTY;

4545

4546

yystate = yyn;

4547

*++yyvsp = yylval;

4548

4549

goto yynewstate;

4550

4551

4552

/*-----------------------------------------------------------.

4553

| yydefault -- do the default action for the current state. |

4554

`-----------------------------------------------------------*/

4555

yydefault:

4556

yyn = yydefact[yystate];

4557

if (yyn == 0)

4558

goto yyerrlab;

4559

goto yyreduce;

4560

4561

4562

/*-----------------------------.

4563

| yyreduce -- Do a reduction. |

4564

`-----------------------------*/

4565

yyreduce:

4566

/* yyn is the number of a rule to reduce with. */

4567

yylen = yyr2[yyn];

4568

4569

/* If YYLEN is nonzero, implement the default value of the action:

4570

`$$ = $1'.

4571

4572

Otherwise, the following line sets YYVAL to garbage.

4573

This behavior is undocumented and Bison

4574

users should not rely upon it. Assigning to YYVAL

4575

unconditionally makes the parser a bit smaller, and it avoids a

4576

GCC warning that YYVAL may be used uninitialized. */

4577

yyval = yyvsp[1-yylen];

4578

4579

4580

YY_REDUCE_PRINT (yyn);

4581

switch (yyn)

4582

{

4583

4584

case 13:

4585

if(as3_pass==2) {

4586

4587

/* Line 1464 of skeleton.m4 */

4588

#line 1953 "parser.y"

4589

{PASS_ALWAYS as3_pass=(yyvsp[(1) - (4)].number_int);}

4590

}

4591

break;

4592

4593

4594

4595

case 24:

4596

if(as3_pass==2) {

4597

4598

/* Line 1464 of skeleton.m4 */

4599

#line 1965 "parser.y"

4600

{PASS_ALWAYS as3_pass=(yyvsp[(1) - (4)].number_int);}

4601

}

4602

break;

4603

4604

4605

4606

case 25:

4607

if(as3_pass==2) {

4608

4609

/* Line 1464 of skeleton.m4 */

4610

#line 1966 "parser.y"

4611

{PASS_ALWAYS as3_pass=(yyvsp[(2) - (4)].number_int);PASS1 as3_warning("embed command ignored");}

4612

}

4613

break;

4614

4615

4616

4617

case 27:

4618

if(as3_pass==2) {

4619

4620

/* Line 1464 of skeleton.m4 */

4621

#line 1969 "parser.y"

4622

{(yyval.code)=(yyvsp[(1) - (1)].code);}

4623

}

4624

break;

4625

4626

4627

4628

case 28:

4629

if(as3_pass==2) {

4630

4631

/* Line 1464 of skeleton.m4 */

4632

#line 1970 "parser.y"

4633

{(yyval.code)=code_new();}

4634

}

4635

break;

4636

4637

4638

4639

case 29:

4640

if(as3_pass==2) {

4641

4642

/* Line 1464 of skeleton.m4 */

4643

#line 1972 "parser.y"

4644

{

4645

(yyval.code)=code_append((yyvsp[(1) - (2)].code),(yyvsp[(2) - (2)].code));

4646

}

4647

}

4648

break;

4649

4650

4651

4652

case 30:

4653

if(as3_pass==2) {

4654

4655

/* Line 1464 of skeleton.m4 */

4656

#line 1975 "parser.y"

4657

{(yyval.code)=(yyvsp[(1) - (1)].code);}

4658

}

4659

break;

4660

4661

4662

4663

case 44:

4664

if(as3_pass==2) {

4665

4666

/* Line 1464 of skeleton.m4 */

4667

#line 1991 "parser.y"

4668

{(yyval.code)=(yyvsp[(2) - (3)].code);}

4669

}

4670

break;

4671

4672

4673

4674

case 45:

4675

if(as3_pass==2) {

4676

4677

/* Line 1464 of skeleton.m4 */

4678

#line 1992 "parser.y"

4679

{(yyval.code)=0;}

4680

}

4681

break;

4682

4683

4684

4685

case 46:

4686

if(as3_pass==2) {

4687

4688

/* Line 1464 of skeleton.m4 */

4689

#line 1995 "parser.y"

4690

{(yyval.code)=0;}

4691

}

4692

break;

4693

4694

4695

4696

case 53:

4697

if(as3_pass==2) {

4698

4699

/* Line 1464 of skeleton.m4 */

4700

#line 2002 "parser.y"

4701

{

4702

PASS_ALWAYS

4703

if(as3_pass) {

4704

(yyval.code) = (yyvsp[(3) - (4)].code);

4705

} else {

4706

(yyval.code) = 0;

4707

}

4708

as3_pass=(yyvsp[(1) - (4)].number_int);

4709

}

4710

}

4711

break;

4712

4713

4714

4715

case 54:

4716

if(as3_pass==2) {

4717

4718

/* Line 1464 of skeleton.m4 */

4719

#line 2014 "parser.y"

4720

{(yyval.code)=(yyvsp[(1) - (2)].code);}

4721

}

4722

break;

4723

4724

4725

4726

case 55:

4727

if(as3_pass==2) {

4728

4729

/* Line 1464 of skeleton.m4 */

4730

#line 2015 "parser.y"

4731

{(yyval.code)=(yyvsp[(1) - (1)].code);}

4732

}

4733

break;

4734

4735

4736

4737

case 56:

4738

if(as3_pass==2) {

4739

4740

/* Line 1464 of skeleton.m4 */

4741

#line 2019 "parser.y"

4742

{

4743

if((yyvsp[(1) - (1)].code)) {

4744

if(!global->init)

4745

global->init = abc_initscript(global->file);

4746

code_t**cc = &global->init->method->body->code;

4747

*cc = code_append(*cc, (yyvsp[(1) - (1)].code));

4748

}

4749

}

4750

}

4751

break;

4752

4753

4754

4755

case 57:

4756

if(as3_pass==2) {

4757

4758

/* Line 1464 of skeleton.m4 */

4759

#line 2030 "parser.y"

4760

{

4761

PASS_ALWAYS

4762

(yyval.number_int) = as3_pass;

4763

as3_pass=0;

4764

}

4765

}

4766

break;

4767

4768

4769

4770

case 58:

4771

if(as3_pass==2) {

4772

4773

/* Line 1464 of skeleton.m4 */

4774

#line 2038 "parser.y"

4775

{

4776

PASS12

4777

(yyval.number_int)=as3_pass;

4778

char*key = concat3((yyvsp[(1) - (3)].id),"::",(yyvsp[(3) - (3)].id));

4779

if(!definitions || !dict_contains(definitions, key)) {

4780

as3_pass=0;

4781

}

4782

free(key);

4783

}

4784

}

4785

break;

4786

4787

4788

4789

case 59:

4790

if(as3_pass==2) {

4791

4792

/* Line 1464 of skeleton.m4 */

4793

#line 2065 "parser.y"

4794

{(yyval.node)=(yyvsp[(2) - (2)].node);}

4795

}

4796

break;

4797

4798

4799

4800

case 60:

4801

if(as3_pass==2) {

4802

4803

/* Line 1464 of skeleton.m4 */

4804

#line 2066 "parser.y"

4805

{(yyval.node)=mkdummynode();}

4806

}

4807

break;

4808

4809

4810

4811

case 61:

4812

if(as3_pass==2) {

4813

4814

/* Line 1464 of skeleton.m4 */

4815

#line 2068 "parser.y"

4816

{(yyval.code)=(yyvsp[(2) - (2)].code);}

4817

}

4818

break;

4819

4820

4821

4822

case 62:

4823

if(as3_pass==2) {

4824

4825

/* Line 1464 of skeleton.m4 */

4826

#line 2069 "parser.y"

4827

{(yyval.code)=(yyvsp[(2) - (2)].code);}

4828

}

4829

break;

4830

4831

4832

4833

case 63:

4834

if(as3_pass==2) {

4835

4836

/* Line 1464 of skeleton.m4 */

4837

#line 2071 "parser.y"

4838

{(yyval.code) = (yyvsp[(1) - (1)].code);}

4839

}

4840

break;

4841

4842

4843

4844

case 64:

4845

if(as3_pass==2) {

4846

4847

/* Line 1464 of skeleton.m4 */

4848

#line 2072 "parser.y"

4849

{(yyval.code) = code_append((yyvsp[(1) - (3)].code), (yyvsp[(3) - (3)].code));}

4850

}

4851

break;

4852

4853

4854

4855

case 65:

4856

if(as3_pass==2) {

4857

4858

/* Line 1464 of skeleton.m4 */

4859

#line 2075 "parser.y"

4860

{

4861

PASS12

4862

if(variable_exists((yyvsp[(1) - (3)].id)))

4863

syntaxerror("Variable %s already defined", (yyvsp[(1) - (3)].id));

4864

PASS1

4865

new_variable((yyvsp[(1) - (3)].id), 0, 1, 0);

4866

PASS2

4867

4868

char slot = 0;

4869

int index = 0;

4870

variable_t*v = 0;

4871

if(state->method->uses_slots) {

4872

v = find_slot(state, (yyvsp[(1) - (3)].id));

4873

if(v && !v->init) {

4874

// this variable is stored in a slot

4875

v->init = 1;

4876

v->type = (yyvsp[(2) - (3)].classinfo);

4877

slot = 1;

4878

}

4879

}

4880

if(!v) {

4881

v = new_variable2((yyvsp[(1) - (3)].id), (yyvsp[(2) - (3)].classinfo), 1, 0);

4882

}

4883

4884

(yyval.code) = slot?abc_getscopeobject(0, 1):0;

4885

4886

typedcode_t val = node_read((yyvsp[(3) - (3)].node));

4887

if(!is_subtype_of(val.t, (yyvsp[(2) - (3)].classinfo))) {

4888

syntaxerror("Can't convert %s to %s", val.t->name, (yyvsp[(2) - (3)].classinfo)->name);

4889

}

4890

if((yyvsp[(2) - (3)].classinfo)) {

4891

if(val.c->prev || val.c->opcode != OPCODE_PUSHUNDEFINED) {

4892

(yyval.code) = code_append((yyval.code), val.c);

4893

(yyval.code) = converttype((yyval.code), val.t, (yyvsp[(2) - (3)].classinfo));

4894

} else {

4895

code_free(val.c);

4896

(yyval.code) = defaultvalue((yyval.code), (yyvsp[(2) - (3)].classinfo));

4897

}

4898

} else {

4899

if(val.c->prev || val.c->opcode != OPCODE_PUSHUNDEFINED) {

4900

(yyval.code) = code_append((yyval.code), val.c);

4901

(yyval.code) = abc_coerce_a((yyval.code));

4902

} else {

4903

// don't do anything

4904

code_free(val.c);

4905

code_free((yyval.code));

4906

(yyval.code) = 0;

4907

break;

4908

}

4909

}

4910

if(slot) {

4911

(yyval.code) = abc_setslot((yyval.code), v->index);

4912

} else {

4913

(yyval.code) = abc_setlocal((yyval.code), v->index);

4914

v->init = do_init_variable((yyvsp[(1) - (3)].id));

4915

}

4916

}

4917

}

4918

break;

4919

4920

4921

4922

case 66:

4923

if(as3_pass==2) {

4924

4925

/* Line 1464 of skeleton.m4 */

4926

#line 2135 "parser.y"

4927

{PASS12 new_state();}

4928

}

4929

break;

4930

4931

4932

4933

case 67:

4934

if(as3_pass==2) {

4935

4936

/* Line 1464 of skeleton.m4 */

4937

#line 2135 "parser.y"

4938

{

4939

(yyval.code) = var_block((yyvsp[(2) - (2)].code), state->vars);

4940

PASS12 old_state();

4941

}

4942

}

4943

break;

4944

4945

4946

4947

case 68:

4948

if(as3_pass==2) {

4949

4950

/* Line 1464 of skeleton.m4 */

4951

#line 2139 "parser.y"

4952

{(yyval.code) = code_new();}

4953

}

4954

break;

4955

4956

4957

4958

case 69:

4959

if(as3_pass==2) {

4960

4961

/* Line 1464 of skeleton.m4 */

4962

#line 2140 "parser.y"

4963

{(yyval.code)=(yyvsp[(2) - (2)].code);}

4964

}

4965

break;

4966

4967

4968

4969

case 70:

4970

if(as3_pass==2) {

4971

4972

/* Line 1464 of skeleton.m4 */

4973

#line 2143 "parser.y"

4974

{

4975

(yyval.code) = code_new();

4976

(yyval.code) = code_append((yyval.code), (yyvsp[(3) - (6)].value).c);

4977

code_t*myjmp,*myif = (yyval.code) = abc_iffalse((yyval.code), 0);

4978

4979

(yyval.code) = code_append((yyval.code), (yyvsp[(5) - (6)].code));

4980

if((yyvsp[(6) - (6)].code)) {

4981

myjmp = (yyval.code) = abc_jump((yyval.code), 0);

4982

}

4983

myif->branch = (yyval.code) = abc_nop((yyval.code));

4984

if((yyvsp[(6) - (6)].code)) {

4985

(yyval.code) = code_append((yyval.code), (yyvsp[(6) - (6)].code));

4986

myjmp->branch = (yyval.code) = abc_nop((yyval.code));

4987

}

4988

}

4989

}

4990

break;

4991

4992

4993

4994

case 71:

4995

if(as3_pass==2) {

4996

4997

/* Line 1464 of skeleton.m4 */

4998

#line 2159 "parser.y"

4999

{(yyval.code)=code_new();}

5000

}

5001

break;

5002

5003

5004

5005

case 74:

5006

if(as3_pass==2) {

5007

5008

/* Line 1464 of skeleton.m4 */

5009

#line 2166 "parser.y"

5010

{

5011

PASS1 (yyval.id)=(yyvsp[(2) - (3)].id);new_variable((yyvsp[(2) - (3)].id),0,1,0);

5012

PASS2 (yyval.id)=(yyvsp[(2) - (3)].id);new_variable((yyvsp[(2) - (3)].id),(yyvsp[(3) - (3)].classinfo),1,0);

5013

}

5014

}

5015

break;

5016

5017

5018

5019

case 75:

5020

if(as3_pass==2) {

5021

5022

/* Line 1464 of skeleton.m4 */

5023

#line 2170 "parser.y"

5024

{

5025

PASS12

5026

(yyval.id)=(yyvsp[(1) - (1)].id);

5027

}

5028

}

5029

break;

5030

5031

5032

5033

case 76:

5034

if(as3_pass==2) {

5035

5036

/* Line 1464 of skeleton.m4 */

5037

#line 2175 "parser.y"

5038

{PASS12 new_state();(yyval.for_start).name=(yyvsp[(1) - (2)].id);(yyval.for_start).each=0;}

5039

}

5040

break;

5041

5042

5043

5044

case 77:

5045

if(as3_pass==2) {

5046

5047

/* Line 1464 of skeleton.m4 */

5048

#line 2176 "parser.y"

5049

{PASS12 new_state();(yyval.for_start).name=(yyvsp[(1) - (3)].id);(yyval.for_start).each=1;}

5050

}

5051

break;

5052

5053

5054

5055

case 78:

5056

if(as3_pass==2) {

5057

5058

/* Line 1464 of skeleton.m4 */

5059

#line 2178 "parser.y"

5060

{

5061

if((yyvsp[(1) - (8)].for_start).each) syntaxerror("invalid syntax: ; not allowed in for each statement");

5062

(yyval.code) = code_new();

5063

(yyval.code) = code_append((yyval.code), (yyvsp[(2) - (8)].code));

5064

code_t*loopstart = (yyval.code) = abc_label((yyval.code));

5065

(yyval.code) = code_append((yyval.code), (yyvsp[(4) - (8)].value).c);

5066

code_t*myif = (yyval.code) = abc_iffalse((yyval.code), 0);

5067

(yyval.code) = code_append((yyval.code), (yyvsp[(8) - (8)].code));

5068

code_t*cont = (yyval.code) = abc_nop((yyval.code));

5069

(yyval.code) = code_append((yyval.code), (yyvsp[(6) - (8)].code));

5070

(yyval.code) = abc_jump((yyval.code), loopstart);

5071

code_t*out = (yyval.code) = abc_nop((yyval.code));

5072

breakjumpsto((yyval.code), (yyvsp[(1) - (8)].for_start).name, out);

5073

continuejumpsto((yyval.code), (yyvsp[(1) - (8)].for_start).name, cont);

5074

myif->branch = out;

5075

5076

(yyval.code) = var_block((yyval.code), state->vars);

5077

PASS12 old_state();

5078

}

5079

}

5080

break;

5081

5082

5083

5084

case 79:

5085

if(as3_pass==2) {

5086

5087

/* Line 1464 of skeleton.m4 */

5088

#line 2198 "parser.y"

5089

{

5090

variable_t*var = find_variable(state, (yyvsp[(2) - (6)].id));

5091

if(!var) {

5092

syntaxerror("variable %s not known in this scope", (yyvsp[(2) - (6)].id));

5093

}

5094

int it = alloc_local();

5095

int array = alloc_local();

5096

5097

(yyval.code) = code_new();

5098

(yyval.code) = code_append((yyval.code), (yyvsp[(4) - (6)].value).c);

5099

(yyval.code) = abc_coerce_a((yyval.code));

5100

(yyval.code) = abc_setlocal((yyval.code), array);

5101

(yyval.code) = abc_pushbyte((yyval.code), 0);

5102

(yyval.code) = abc_setlocal((yyval.code), it);

5103

5104

code_t*loopstart = (yyval.code) = abc_label((yyval.code));

5105

5106

(yyval.code) = abc_hasnext2((yyval.code), array, it);

5107

code_t*myif = (yyval.code) = abc_iffalse((yyval.code), 0);

5108

(yyval.code) = abc_getlocal((yyval.code), array);

5109

(yyval.code) = abc_getlocal((yyval.code), it);

5110

if(!(yyvsp[(1) - (6)].for_start).each)

5111

(yyval.code) = abc_nextname((yyval.code));

5112

else

5113

(yyval.code) = abc_nextvalue((yyval.code));

5114

(yyval.code) = converttype((yyval.code), 0, var->type);

5115

(yyval.code) = abc_setlocal((yyval.code), var->index);

5116

5117

(yyval.code) = code_append((yyval.code), (yyvsp[(6) - (6)].code));

5118

(yyval.code) = abc_jump((yyval.code), loopstart);

5119

5120

code_t*out = (yyval.code) = abc_nop((yyval.code));

5121

breakjumpsto((yyval.code), (yyvsp[(1) - (6)].for_start).name, out);

5122

continuejumpsto((yyval.code), (yyvsp[(1) - (6)].for_start).name, loopstart);

5123

5124

myif->branch = out;

5125

5126

(yyval.code) = abc_kill((yyval.code), it);

5127

(yyval.code) = abc_kill((yyval.code), array);

5128

5129

PASS12 old_state();

5130

}

5131

}

5132

break;

5133

5134

5135

5136

case 80:

5137

if(as3_pass==2) {

5138

5139

/* Line 1464 of skeleton.m4 */

5140

#line 2241 "parser.y"

5141

{

5142

5143

(yyval.code) = code_new();

5144

5145

code_t*myjmp = (yyval.code) = abc_jump((yyval.code), 0);

5146

code_t*loopstart = (yyval.code) = abc_label((yyval.code));

5147

(yyval.code) = code_append((yyval.code), (yyvsp[(5) - (5)].code));

5148

code_t*cont = (yyval.code) = abc_nop((yyval.code));

5149

myjmp->branch = cont;

5150

(yyval.code) = code_append((yyval.code), (yyvsp[(3) - (5)].value).c);

5151

(yyval.code) = abc_iftrue((yyval.code), loopstart);

5152

code_t*out = (yyval.code) = abc_nop((yyval.code));

5153

breakjumpsto((yyval.code), (yyvsp[(1) - (5)].id), out);

5154

continuejumpsto((yyval.code), (yyvsp[(1) - (5)].id), cont);

5155

}

5156

}

5157

break;

5158

5159

5160

5161

case 81:

5162

if(as3_pass==2) {

5163

5164

/* Line 1464 of skeleton.m4 */

5165

#line 2257 "parser.y"

5166

{

5167

(yyval.code) = code_new();

5168

code_t*loopstart = (yyval.code) = abc_label((yyval.code));

5169

(yyval.code) = code_append((yyval.code), (yyvsp[(2) - (6)].code));

5170

code_t*cont = (yyval.code) = abc_nop((yyval.code));

5171

(yyval.code) = code_append((yyval.code), (yyvsp[(5) - (6)].value).c);

5172

(yyval.code) = abc_iftrue((yyval.code), loopstart);

5173

code_t*out = (yyval.code) = abc_nop((yyval.code));

5174

breakjumpsto((yyval.code), (yyvsp[(1) - (6)].id), out);

5175

continuejumpsto((yyval.code), (yyvsp[(1) - (6)].id), cont);

5176

}

5177

}

5178

break;

5179

5180

5181

5182

case 82:

5183

if(as3_pass==2) {

5184

5185

/* Line 1464 of skeleton.m4 */

5186

#line 2269 "parser.y"

5187

{

5188

(yyval.code) = abc___break__(0, "");

5189

}

5190

}

5191

break;

5192

5193

5194

5195

case 83:

5196

if(as3_pass==2) {

5197

5198

/* Line 1464 of skeleton.m4 */

5199

#line 2272 "parser.y"

5200

{

5201

(yyval.code) = abc___break__(0, (yyvsp[(2) - (2)].id));

5202

}

5203

}

5204

break;

5205

5206

5207

5208

case 84:

5209

if(as3_pass==2) {

5210

5211

/* Line 1464 of skeleton.m4 */

5212

#line 2275 "parser.y"

5213

{

5214

(yyval.code) = abc___continue__(0, "");

5215

}

5216

}

5217

break;

5218

5219

5220

5221

case 85:

5222

if(as3_pass==2) {

5223

5224

/* Line 1464 of skeleton.m4 */

5225

#line 2278 "parser.y"

5226

{

5227

(yyval.code) = abc___continue__(0, (yyvsp[(2) - (2)].id));

5228

}

5229

}

5230

break;

5231

5232

5233

5234

case 86:

5235

if(as3_pass==2) {

5236

5237

/* Line 1464 of skeleton.m4 */

5238

#line 2282 "parser.y"

5239

{(yyval.code)=0;}

5240

}

5241

break;

5242

5243

5244

5245

case 87:

5246

if(as3_pass==2) {

5247

5248

/* Line 1464 of skeleton.m4 */

5249

#line 2283 "parser.y"

5250

{(yyval.code)=(yyvsp[(1) - (1)].code);}

5251

}

5252

break;

5253

5254

5255

5256

case 88:

5257

if(as3_pass==2) {

5258

5259

/* Line 1464 of skeleton.m4 */

5260

#line 2284 "parser.y"

5261

{(yyval.code)=(yyvsp[(1) - (1)].code);}

5262

}

5263

break;

5264

5265

5266

5267

case 89:

5268

if(as3_pass==2) {

5269

5270

/* Line 1464 of skeleton.m4 */

5271

#line 2285 "parser.y"

5272

{(yyval.code)=code_append((yyvsp[(1) - (2)].code),(yyvsp[(2) - (2)].code));}

5273

}

5274

break;

5275

5276

5277

5278

case 90:

5279

if(as3_pass==2) {

5280

5281

/* Line 1464 of skeleton.m4 */

5282

#line 2286 "parser.y"

5283

{(yyval.code)=(yyvsp[(1) - (1)].code);}

5284

}

5285

break;

5286

5287

5288

5289

case 91:

5290

if(as3_pass==2) {

5291

5292

/* Line 1464 of skeleton.m4 */

5293

#line 2287 "parser.y"

5294

{(yyval.code)=code_append((yyval.code),(yyvsp[(2) - (2)].code));}

5295

}

5296

break;

5297

5298

5299

5300

case 92:

5301

if(as3_pass==2) {

5302

5303

/* Line 1464 of skeleton.m4 */

5304

#line 2289 "parser.y"

5305

{

5306

(yyval.code) = abc_getlocal(0, state->switch_var);

5307

(yyval.code) = code_append((yyval.code), node_read((yyvsp[(2) - (4)].node)).c);

5308

code_t*j = (yyval.code) = abc_ifne((yyval.code), 0);

5309

(yyval.code) = code_append((yyval.code), (yyvsp[(4) - (4)].code));

5310

if((yyval.code)->opcode != OPCODE___BREAK__) {

5311

(yyval.code) = abc___fallthrough__((yyval.code), "");

5312

}

5313

code_t*e = (yyval.code) = abc_nop((yyval.code));

5314

j->branch = e;

5315

}

5316

}

5317

break;

5318

5319

5320

5321

case 93:

5322

if(as3_pass==2) {

5323

5324

/* Line 1464 of skeleton.m4 */

5325

#line 2300 "parser.y"

5326

{

5327

(yyval.code) = (yyvsp[(3) - (3)].code);

5328

}

5329

}

5330

break;

5331

5332

5333

5334

case 94:

5335

if(as3_pass==2) {

5336

5337

/* Line 1464 of skeleton.m4 */

5338

#line 2303 "parser.y"

5339

{PASS12 new_state();state->switch_var=alloc_local();}

5340

}

5341

break;

5342

5343

5344

5345

case 95:

5346

if(as3_pass==2) {

5347

5348

/* Line 1464 of skeleton.m4 */

5349

#line 2303 "parser.y"

5350

{

5351

(yyval.code) = node_read((yyvsp[(4) - (8)].node)).c;

5352

(yyval.code) = abc_setlocal((yyval.code), state->switch_var);

5353

(yyval.code) = code_append((yyval.code), (yyvsp[(7) - (8)].code));

5354

5355

code_t*out = (yyval.code) = abc_kill((yyval.code), state->switch_var);

5356

breakjumpsto((yyval.code), (yyvsp[(1) - (8)].id), out);

5357

5358

code_t*c = (yyval.code),*lastblock=0;

5359

while(c) {

5360

if(c->opcode == OPCODE_IFNE) {

5361

if(!c->next) syntaxerror("internal error in fallthrough handling");

5362

lastblock=c->next;

5363

} else if(c->opcode == OPCODE___FALLTHROUGH__) {

5364

if(lastblock) {

5365

c->opcode = OPCODE_JUMP;

5366

c->branch = lastblock;

5367

} else {

5368

/* fall through end of switch */

5369

c->opcode = OPCODE_NOP;

5370

}

5371

}

5372

c=c->prev;

5373

}

5374

5375

(yyval.code) = var_block((yyval.code), state->vars);

5376

PASS12 old_state();

5377

}

5378

}

5379

break;

5380

5381

5382

5383

case 96:

5384

if(as3_pass==2) {

5385

5386

/* Line 1464 of skeleton.m4 */

5387

#line 2334 "parser.y"

5388

{PASS12 new_state();

5389

state->exception_name=(yyvsp[(3) - (5)].id);

5390

PASS1 new_variable((yyvsp[(3) - (5)].id), 0, 0, 0);

5391

PASS2 new_variable((yyvsp[(3) - (5)].id), (yyvsp[(4) - (5)].classinfo), 0, 0);

5392

}

5393

}

5394

break;

5395

5396

5397

5398

case 97:

5399

if(as3_pass==2) {

5400

5401

/* Line 1464 of skeleton.m4 */

5402

#line 2339 "parser.y"

5403

{

5404

namespace_t name_ns = {ACCESS_PACKAGE, ""};

5405

multiname_t name = {QNAME, &name_ns, 0, (yyvsp[(3) - (9)].id)};

5406

5407

NEW(abc_exception_t, e)

5408

e->exc_type = sig2mname((yyvsp[(4) - (9)].classinfo));

5409

e->var_name = multiname_clone(&name);

5410

(yyval.exception) = e;

5411

5412

code_t*c = 0;

5413

int i = find_variable_safe(state, (yyvsp[(3) - (9)].id))->index;

5414

e->target = c = abc_nop(0);

5415

c = abc_setlocal(c, i);

5416

c = code_append(c, code_dup(state->method->scope_code));

5417

c = code_append(c, (yyvsp[(8) - (9)].code));

5418

c = abc_kill(c, i);

5419

5420

c = var_block(c, state->vars);

5421

PASS12 old_state();

5422

}

5423

}

5424

break;

5425

5426

5427

5428

case 98:

5429

if(as3_pass==2) {

5430

5431

/* Line 1464 of skeleton.m4 */

5432

#line 2359 "parser.y"

5433

{PASS12 new_state();state->exception_name=0;}

5434

}

5435

break;

5436

5437

5438

5439

case 99:

5440

if(as3_pass==2) {

5441

5442

/* Line 1464 of skeleton.m4 */

5443

#line 2359 "parser.y"

5444

{

5445

(yyvsp[(4) - (5)].code) = var_block((yyvsp[(4) - (5)].code), state->vars);

5446

if(!(yyvsp[(4) - (5)].code)) {

5447

(yyval.exception)=0;

5448

} else {

5449

NEW(abc_exception_t, e)

5450

e->exc_type = 0; //all exceptions

5451

e->var_name = 0; //no name

5452

e->target = 0;

5453

e->to = abc_nop(0);

5454

e->to = code_append(e->to, (yyvsp[(4) - (5)].code));

5455

(yyval.exception) = e;

5456

}

5457

PASS12 old_state();

5458

}

5459

}

5460

break;

5461

5462

5463

5464

case 100:

5465

if(as3_pass==2) {

5466

5467

/* Line 1464 of skeleton.m4 */

5468

#line 2375 "parser.y"

5469

{(yyval.catch_list).l=list_new();(yyval.catch_list).finally=0;list_append((yyval.catch_list).l,(yyvsp[(1) - (1)].exception));}

5470

}

5471

break;

5472

5473

5474

5475

case 101:

5476

if(as3_pass==2) {

5477

5478

/* Line 1464 of skeleton.m4 */

5479

#line 2376 "parser.y"

5480

{(yyval.catch_list)=(yyvsp[(1) - (2)].catch_list);list_append((yyval.catch_list).l,(yyvsp[(2) - (2)].exception));}

5481

}

5482

break;

5483

5484

5485

5486

case 102:

5487

if(as3_pass==2) {

5488

5489

/* Line 1464 of skeleton.m4 */

5490

#line 2377 "parser.y"

5491

{(yyval.catch_list)=(yyvsp[(1) - (1)].catch_list);}

5492

}

5493

break;

5494

5495

5496

5497

case 103:

5498

if(as3_pass==2) {

5499

5500

/* Line 1464 of skeleton.m4 */

5501

#line 2378 "parser.y"

5502

{

5503

(yyval.catch_list) = (yyvsp[(1) - (2)].catch_list);

5504

(yyval.catch_list).finally = 0;

5505

if((yyvsp[(2) - (2)].exception)) {

5506

list_append((yyval.catch_list).l,(yyvsp[(2) - (2)].exception));

5507

(yyval.catch_list).finally = (yyvsp[(2) - (2)].exception)->to;(yyvsp[(2) - (2)].exception)->to=0;

5508

}

5509

}

5510

}

5511

break;

5512

5513

5514

5515

case 104:

5516

if(as3_pass==2) {

5517

5518

/* Line 1464 of skeleton.m4 */

5519

#line 2386 "parser.y"

5520

{

5521

(yyval.catch_list).l=list_new();

5522

(yyval.catch_list).finally = 0;

5523

if((yyvsp[(1) - (1)].exception)) {

5524

list_append((yyval.catch_list).l,(yyvsp[(1) - (1)].exception));

5525

(yyval.catch_list).finally = (yyvsp[(1) - (1)].exception)->to;(yyvsp[(1) - (1)].exception)->to=0;

5526

}

5527

}

5528

}

5529

break;

5530

5531

5532

5533

case 105:

5534

if(as3_pass==2) {

5535

5536

/* Line 1464 of skeleton.m4 */

5537

#line 2395 "parser.y"

5538

{PASS12 new_state();

5539

state->method->has_exceptions=1;

5540

state->method->late_binding=1;//for invariant scope_code

5541

}

5542

}

5543

break;

5544

5545

5546

5547

case 106:

5548

if(as3_pass==2) {

5549

5550

/* Line 1464 of skeleton.m4 */

5551

#line 2398 "parser.y"

5552

{

5553

code_t*out = abc_nop(0);

5554

5555

code_t*start = abc_nop(0);

5556

(yyval.code) = code_append(start, (yyvsp[(4) - (6)].code));

5557

if(!is_break_or_jump((yyvsp[(4) - (6)].code))) {

5558

(yyval.code) = abc_jump((yyval.code), out);

5559

}

5560

code_t*end = (yyval.code) = abc_nop((yyval.code));

5561

5562

int tmp;

5563

if((yyvsp[(6) - (6)].catch_list).finally)

5564

tmp = alloc_local();

5565

5566

abc_exception_list_t*l = (yyvsp[(6) - (6)].catch_list).l;

5567

int count=0;

5568

while(l) {

5569

abc_exception_t*e = l->abc_exception;

5570

if(e->var_name) {

5571

(yyval.code) = code_append((yyval.code), e->target);

5572

(yyval.code) = abc_jump((yyval.code), out);

5573

} else {

5574

parserassert((ptroff_t)(yyvsp[(6) - (6)].catch_list).finally);

5575

// finally block

5576

e->target = (yyval.code) = abc_nop((yyval.code));

5577

(yyval.code) = code_append((yyval.code), code_dup(state->method->scope_code));

5578

(yyval.code) = abc___rethrow__((yyval.code));

5579

}

5580

5581

e->from = start;

5582

e->to = end;

5583

5584

l = l->next;

5585

}

5586

(yyval.code) = code_append((yyval.code), out);

5587

5588

(yyval.code) = insert_finally((yyval.code), (yyvsp[(6) - (6)].catch_list).finally, tmp);

5589

5590

list_concat(state->method->exceptions, (yyvsp[(6) - (6)].catch_list).l);

5591

5592

(yyval.code) = var_block((yyval.code), state->vars);

5593

PASS12 old_state();

5594

}

5595

}

5596

break;

5597

5598

5599

5600

case 107:

5601

if(as3_pass==2) {

5602

5603

/* Line 1464 of skeleton.m4 */

5604

#line 2444 "parser.y"

5605

{

5606

(yyval.code)=(yyvsp[(2) - (2)].value).c;

5607

(yyval.code)=abc_throw((yyval.code));

5608

}

5609

}

5610

break;

5611

5612

5613

5614

case 108:

5615

if(as3_pass==2) {

5616

5617

/* Line 1464 of skeleton.m4 */

5618

#line 2448 "parser.y"

5619

{

5620

if(!state->exception_name)

5621

syntaxerror("re-throw only possible within a catch block");

5622

variable_t*v = find_variable(state, state->exception_name);

5623

(yyval.code)=code_new();

5624

(yyval.code)=abc_getlocal((yyval.code), v->index);

5625

(yyval.code)=abc_throw((yyval.code));

5626

}

5627

}

5628

break;

5629

5630

5631

5632

case 109:

5633

if(as3_pass==2) {

5634

5635

/* Line 1464 of skeleton.m4 */

5636

#line 2459 "parser.y"

5637

{

5638

new_state();

5639

if(state->method->has_exceptions) {

5640

int v = alloc_local();

5641

state->method->scope_code = abc_getlocal(state->method->scope_code, v);

5642

state->method->scope_code = abc_pushwith(state->method->scope_code);

5643

(yyval.value_list).number = v;

5644

}

5645

(yyval.value_list).cc = (yyvsp[(3) - (4)].value).c;

5646

}

5647

}

5648

break;

5649

5650

5651

5652

case 110:

5653

if(as3_pass==2) {

5654

5655

/* Line 1464 of skeleton.m4 */

5656

#line 2469 "parser.y"

5657

{

5658

/* remove getlocal;pushwith from scope code again */

5659

state->method->scope_code = code_cutlast(code_cutlast(state->method->scope_code));

5660

5661

(yyval.code) = (yyvsp[(1) - (2)].value_list).cc;

5662

if(state->method->has_exceptions) {

5663

(yyval.code) = abc_dup((yyval.code));

5664

(yyval.code) = abc_setlocal((yyval.code), (yyvsp[(1) - (2)].value_list).number);

5665

}

5666

(yyval.code) = abc_pushwith((yyval.code));

5667

(yyval.code) = code_append((yyval.code), (yyvsp[(2) - (2)].code));

5668

(yyval.code) = abc_popscope((yyval.code));

5669

old_state();

5670

}

5671

}

5672

break;

5673

5674

5675

5676

case 112:

5677

if(as3_pass==2) {

5678

5679

/* Line 1464 of skeleton.m4 */

5680

#line 2487 "parser.y"

5681

{PASS12 (yyval.id)="package";}

5682

}

5683

break;

5684

5685

5686

5687

case 113:

5688

if(as3_pass==2) {

5689

5690

/* Line 1464 of skeleton.m4 */

5691

#line 2488 "parser.y"

5692

{PASS12 (yyval.id)="namespace";}

5693

}

5694

break;

5695

5696

5697

5698

case 114:

5699

if(as3_pass==2) {

5700

5701

/* Line 1464 of skeleton.m4 */

5702

#line 2489 "parser.y"

5703

{PASS12 (yyval.id)="NaN";}

5704

}

5705

break;

5706

5707

5708

5709

case 115:

5710

if(as3_pass==2) {

5711

5712

/* Line 1464 of skeleton.m4 */

5713

#line 2490 "parser.y"

5714

{PASS12 (yyval.id)=(yyvsp[(1) - (1)].id);}

5715

}

5716

break;

5717

5718

5719

5720

case 116:

5721

if(as3_pass==2) {

5722

5723

/* Line 1464 of skeleton.m4 */

5724

#line 2492 "parser.y"

5725

{PASS12 (yyval.id) = concat3((yyvsp[(1) - (3)].id),".",(yyvsp[(3) - (3)].id));free((yyvsp[(1) - (3)].id));(yyvsp[(1) - (3)].id)=0;}

5726

}

5727

break;

5728

5729

5730

5731

case 117:

5732

if(as3_pass==2) {

5733

5734

/* Line 1464 of skeleton.m4 */

5735

#line 2493 "parser.y"

5736

{PASS12 (yyval.id)=strdup((yyvsp[(1) - (1)].id));}

5737

}

5738

break;

5739

5740

5741

5742

case 118:

5743

if(as3_pass==2) {

5744

5745

/* Line 1464 of skeleton.m4 */

5746

#line 2495 "parser.y"

5747

{PASS12 startpackage((yyvsp[(2) - (3)].id));free((yyvsp[(2) - (3)].id));(yyvsp[(2) - (3)].id)=0;}

5748

}

5749

break;

5750

5751

5752

5753

case 119:

5754

if(as3_pass==2) {

5755

5756

/* Line 1464 of skeleton.m4 */

5757

#line 2496 "parser.y"

5758

{PASS12 endpackage();(yyval.code)=0;}

5759

}

5760

break;

5761

5762

5763

5764

case 120:

5765

if(as3_pass==2) {

5766

5767

/* Line 1464 of skeleton.m4 */

5768

#line 2497 "parser.y"

5769

{PASS12 startpackage("");}

5770

}

5771

break;

5772

5773

5774

5775

case 121:

5776

if(as3_pass==2) {

5777

5778

/* Line 1464 of skeleton.m4 */

5779

#line 2498 "parser.y"

5780

{PASS12 endpackage();(yyval.code)=0;}

5781

}

5782

break;

5783

5784

5785

5786

case 122:

5787

if(as3_pass==2) {

5788

5789

/* Line 1464 of skeleton.m4 */

5790

#line 2521 "parser.y"

5791

{

5792

PASS12

5793

slotinfo_t*s = registry_find(state->package, (yyvsp[(2) - (2)].id));

5794

if(!s && as3_pass==1) {as3_schedule_class(state->package, (yyvsp[(2) - (2)].id));}

5795

state_has_imports();

5796

dict_put(state->imports, state->package, (yyvsp[(2) - (2)].id));

5797

(yyval.code)=0;

5798

}

5799

}

5800

break;

5801

5802

5803

5804

case 123:

5805

if(as3_pass==2) {

5806

5807

/* Line 1464 of skeleton.m4 */

5808

#line 2529 "parser.y"

5809

{

5810

PASS12

5811

slotinfo_t*s = registry_find((yyvsp[(2) - (2)].classinfo)->package, (yyvsp[(2) - (2)].classinfo)->name);

5812

if(!s && as3_pass==1) {// || !(s->flags&FLAG_BUILTIN)) {

5813

as3_schedule_class((yyvsp[(2) - (2)].classinfo)->package, (yyvsp[(2) - (2)].classinfo)->name);

5814

}

5815

state_has_imports();

5816

dict_put(state->imports, (yyvsp[(2) - (2)].classinfo)->name, (yyvsp[(2) - (2)].classinfo));

5817

import_toplevel((yyvsp[(2) - (2)].classinfo)->package);

5818

(yyval.code)=0;

5819

}

5820

}

5821

break;

5822

5823

5824

5825

case 124:

5826

if(as3_pass==2) {

5827

5828

/* Line 1464 of skeleton.m4 */

5829

#line 2540 "parser.y"

5830

{

5831

PASS12

5832

if(strncmp("flash.", (yyvsp[(2) - (4)].id), 6) && as3_pass==1) {

5833

as3_schedule_package((yyvsp[(2) - (4)].id));

5834

}

5835

5836

NEW(import_t,i);

5837

i->package = (yyvsp[(2) - (4)].id);

5838

state_has_imports();

5839

list_append(state->wildcard_imports, i);

5840

import_toplevel(i->package);

5841

(yyval.code)=0;

5842

}

5843

}

5844

break;

5845

5846

5847

5848

case 125:

5849

if(as3_pass==2) {

5850

5851

/* Line 1464 of skeleton.m4 */

5852

#line 2556 "parser.y"

5853

{PASS12 (yyval.flags).flags=0;(yyval.flags).ns=0;}

5854

}

5855

break;

5856

5857

5858

5859

case 126:

5860

if(as3_pass==2) {

5861

5862

/* Line 1464 of skeleton.m4 */

5863

#line 2557 "parser.y"

5864

{PASS12 (yyval.flags)=(yyvsp[(1) - (1)].flags);}

5865

}

5866

break;

5867

5868

5869

5870

case 127:

5871

if(as3_pass==2) {

5872

5873

/* Line 1464 of skeleton.m4 */

5874

#line 2558 "parser.y"

5875

{PASS12 (yyval.flags)=(yyvsp[(1) - (1)].flags);}

5876

}

5877

break;

5878

5879

5880

5881

case 128:

5882

if(as3_pass==2) {

5883

5884

/* Line 1464 of skeleton.m4 */

5885

#line 2559 "parser.y"

5886

{

5887

PASS12

5888

(yyval.flags).flags=(yyvsp[(1) - (2)].flags).flags|(yyvsp[(2) - (2)].flags).flags;

5889

if((yyvsp[(1) - (2)].flags).ns && (yyvsp[(2) - (2)].flags).ns) syntaxerror("only one namespace allowed in one declaration");

5890

(yyval.flags).ns=(yyvsp[(1) - (2)].flags).ns?(yyvsp[(1) - (2)].flags).ns:(yyvsp[(2) - (2)].flags).ns;

5891

5892

}

5893

}

5894

break;

5895

5896

5897

5898

case 129:

5899

if(as3_pass==2) {

5900

5901

/* Line 1464 of skeleton.m4 */

5902

#line 2566 "parser.y"

5903

{PASS12 (yyval.flags).flags=FLAG_PUBLIC;(yyval.flags).ns=0;}

5904

}

5905

break;

5906

5907

5908

5909

case 130:

5910

if(as3_pass==2) {

5911

5912

/* Line 1464 of skeleton.m4 */

5913

#line 2567 "parser.y"

5914

{PASS12 (yyval.flags).flags=FLAG_PRIVATE;(yyval.flags).ns=0;}

5915

}

5916

break;

5917

5918

5919

5920

case 131:

5921

if(as3_pass==2) {

5922

5923

/* Line 1464 of skeleton.m4 */

5924

#line 2568 "parser.y"

5925

{PASS12 (yyval.flags).flags=FLAG_PROTECTED;(yyval.flags).ns=0;}

5926

}

5927

break;

5928

5929

5930

5931

case 132:

5932

if(as3_pass==2) {

5933

5934

/* Line 1464 of skeleton.m4 */

5935

#line 2569 "parser.y"

5936

{PASS12 (yyval.flags).flags=FLAG_STATIC;(yyval.flags).ns=0;}

5937

}

5938

break;

5939

5940

5941

5942

case 133:

5943

if(as3_pass==2) {

5944

5945

/* Line 1464 of skeleton.m4 */

5946

#line 2570 "parser.y"

5947

{PASS12 (yyval.flags).flags=FLAG_DYNAMIC;(yyval.flags).ns=0;}

5948

}

5949

break;

5950

5951

5952

5953

case 134:

5954

if(as3_pass==2) {

5955

5956

/* Line 1464 of skeleton.m4 */

5957

#line 2571 "parser.y"

5958

{PASS12 (yyval.flags).flags=FLAG_FINAL;(yyval.flags).ns=0;}

5959

}

5960

break;

5961

5962

5963

5964

case 135:

5965

if(as3_pass==2) {

5966

5967

/* Line 1464 of skeleton.m4 */

5968

#line 2572 "parser.y"

5969

{PASS12 (yyval.flags).flags=FLAG_OVERRIDE;(yyval.flags).ns=0;}

5970

}

5971

break;

5972

5973

5974

5975

case 136:

5976

if(as3_pass==2) {

5977

5978

/* Line 1464 of skeleton.m4 */

5979

#line 2573 "parser.y"

5980

{PASS12 (yyval.flags).flags=FLAG_NATIVE;(yyval.flags).ns=0;}

5981

}

5982

break;

5983

5984

5985

5986

case 137:

5987

if(as3_pass==2) {

5988

5989

/* Line 1464 of skeleton.m4 */

5990

#line 2574 "parser.y"

5991

{PASS12 (yyval.flags).flags=FLAG_PACKAGEINTERNAL;(yyval.flags).ns=0;}

5992

}

5993

break;

5994

5995

5996

5997

case 138:

5998

if(as3_pass==2) {

5999

6000

/* Line 1464 of skeleton.m4 */

6001

#line 2575 "parser.y"

6002

{PASS12 (yyval.flags).flags=FLAG_NAMESPACE;

6003

(yyval.flags).ns=(yyvsp[(1) - (1)].id);

6004

}

6005

}

6006

break;

6007

6008

6009

6010

case 139:

6011

if(as3_pass==2) {

6012

6013

/* Line 1464 of skeleton.m4 */

6014

#line 2579 "parser.y"

6015

{PASS12 (yyval.classinfo)=0;}

6016

}

6017

break;

6018

6019

6020

6021

case 140:

6022

if(as3_pass==2) {

6023

6024

/* Line 1464 of skeleton.m4 */

6025

#line 2580 "parser.y"

6026

{PASS12 (yyval.classinfo)=(yyvsp[(2) - (2)].classinfo);}

6027

}

6028

break;

6029

6030

6031

6032

case 141:

6033

if(as3_pass==2) {

6034

6035

/* Line 1464 of skeleton.m4 */

6036

#line 2582 "parser.y"

6037

{PASS12 (yyval.classinfo_list)=list_new();}

6038

}

6039

break;

6040

6041

6042

6043

case 142:

6044

if(as3_pass==2) {

6045

6046

/* Line 1464 of skeleton.m4 */

6047

#line 2583 "parser.y"

6048

{PASS12 (yyval.classinfo_list)=(yyvsp[(2) - (2)].classinfo_list);}

6049

}

6050

break;

6051

6052

6053

6054

case 143:

6055

if(as3_pass==2) {

6056

6057

/* Line 1464 of skeleton.m4 */

6058

#line 2585 "parser.y"

6059

{PASS12 (yyval.classinfo_list)=list_new();}

6060

}

6061

break;

6062

6063

6064

6065

case 144:

6066

if(as3_pass==2) {

6067

6068

/* Line 1464 of skeleton.m4 */

6069

#line 2586 "parser.y"

6070

{PASS12 (yyval.classinfo_list)=(yyvsp[(2) - (2)].classinfo_list);}

6071

}

6072

break;

6073

6074

6075

6076

case 145:

6077

if(as3_pass==2) {

6078

6079

/* Line 1464 of skeleton.m4 */

6080

#line 2590 "parser.y"

6081

{PASS12 startclass(&(yyvsp[(1) - (6)].flags),(yyvsp[(3) - (6)].id),(yyvsp[(4) - (6)].classinfo),(yyvsp[(5) - (6)].classinfo_list));}

6082

}

6083

break;

6084

6085

6086

6087

case 146:

6088

if(as3_pass==2) {

6089

6090

/* Line 1464 of skeleton.m4 */

6091

#line 2592 "parser.y"

6092

{PASS12 endclass();(yyval.code)=0;}

6093

}

6094

break;

6095

6096

6097

6098

case 147:

6099

if(as3_pass==2) {

6100

6101

/* Line 1464 of skeleton.m4 */

6102

#line 2596 "parser.y"

6103

{PASS12 (yyvsp[(1) - (5)].flags).flags|=FLAG_INTERFACE;

6104

startclass(&(yyvsp[(1) - (5)].flags),(yyvsp[(3) - (5)].id),0,(yyvsp[(4) - (5)].classinfo_list));}

6105

}

6106

break;

6107

6108

6109

6110

case 148:

6111

if(as3_pass==2) {

6112

6113

/* Line 1464 of skeleton.m4 */

6114

#line 2599 "parser.y"

6115

{PASS12 endclass();(yyval.code)=0;}

6116

}

6117

break;

6118

6119

6120

6121

case 154:

6122

if(as3_pass==2) {

6123

6124

/* Line 1464 of skeleton.m4 */

6125

#line 2608 "parser.y"

6126

{PASS_ALWAYS as3_pass=(yyvsp[(1) - (4)].number_int);}

6127

}

6128

break;

6129

6130

6131

6132

case 157:

6133

if(as3_pass==2) {

6134

6135

/* Line 1464 of skeleton.m4 */

6136

#line 2612 "parser.y"

6137

{

6138

code_t*c = state->cls->static_init->header;

6139

c = code_append(c, (yyvsp[(1) - (1)].code));

6140

state->cls->static_init->header = c;

6141

}

6142

}

6143

break;

6144

6145

6146

6147

case 163:

6148

if(as3_pass==2) {

6149

6150

/* Line 1464 of skeleton.m4 */

6151

#line 2623 "parser.y"

6152

{

6153

syntaxerror("variable declarations not allowed in interfaces");

6154

}

6155

}

6156

break;

6157

6158

6159

6160

case 164:

6161

if(as3_pass==2) {

6162

6163

/* Line 1464 of skeleton.m4 */

6164

#line 2626 "parser.y"

6165

{

6166

PASS12

6167

(yyvsp[(1) - (8)].flags).flags |= FLAG_PUBLIC;

6168

if((yyvsp[(1) - (8)].flags).flags&(FLAG_PRIVATE|FLAG_PACKAGEINTERNAL|FLAG_PROTECTED)) {

6169

syntaxerror("invalid method modifiers: interface methods always need to be public");

6170

}

6171

startfunction(&(yyvsp[(1) - (8)].flags),(yyvsp[(3) - (8)].token),(yyvsp[(4) - (8)].id),&(yyvsp[(6) - (8)].params),(yyvsp[(8) - (8)].classinfo));

6172

endfunction(&(yyvsp[(1) - (8)].flags),(yyvsp[(3) - (8)].token),(yyvsp[(4) - (8)].id),&(yyvsp[(6) - (8)].params),(yyvsp[(8) - (8)].classinfo), 0);

6173

list_deep_free((yyvsp[(6) - (8)].params).list);

6174

}

6175

}

6176

break;

6177

6178

6179

6180

case 167:

6181

if(as3_pass==2) {

6182

6183

/* Line 1464 of skeleton.m4 */

6184

#line 2701 "parser.y"

6185

{PASS12 setslotstate(&(yyvsp[(1) - (2)].flags),(yyvsp[(2) - (2)].token));}

6186

}

6187

break;

6188

6189

6190

6191

case 168:

6192

if(as3_pass==2) {

6193

6194

/* Line 1464 of skeleton.m4 */

6195

#line 2701 "parser.y"

6196

{PASS12 (yyval.code)=(yyvsp[(4) - (4)].code);setslotstate(0, 0);}

6197

}

6198

break;

6199

6200

6201

6202

case 169:

6203

if(as3_pass==2) {

6204

6205

/* Line 1464 of skeleton.m4 */

6206

#line 2703 "parser.y"

6207

{PASS12 (yyval.code)=0;}

6208

}

6209

break;

6210

6211

6212

6213

case 170:

6214

if(as3_pass==2) {

6215

6216

/* Line 1464 of skeleton.m4 */

6217

#line 2704 "parser.y"

6218

{PASS12 (yyval.code)=0;}

6219

}

6220

break;

6221

6222

6223

6224

case 171:

6225

if(as3_pass==2) {

6226

6227

/* Line 1464 of skeleton.m4 */

6228

#line 2707 "parser.y"

6229

{

6230

PASS12

6231

int flags = slotstate_flags->flags;

6232

namespace_t ns = modifiers2access(slotstate_flags);

6233

6234

if(as3_pass == 1) {

6235

6236

varinfo_t* info = 0;

6237

if(state->cls) {

6238

memberinfo_t*i = registry_findmember(state->cls->info, ns.name, (yyvsp[(1) - (3)].id), 1);

6239

if(i) {

6240

check_override(i, flags);

6241

}

6242

info = varinfo_register_onclass(state->cls->info, ns.access, ns.name, (yyvsp[(1) - (3)].id));

6243

} else {

6244

slotinfo_t*i = registry_find(state->package, (yyvsp[(1) - (3)].id));

6245

if(i) {

6246

syntaxerror("package %s already contains '%s'", state->package, (yyvsp[(1) - (3)].id));

6247

}

6248

if(ns.name && ns.name[0]) {

6249

syntaxerror("namespaces not allowed on package-level variables");

6250

}

6251

info = varinfo_register_global(ns.access, state->package, (yyvsp[(1) - (3)].id));

6252

}

6253

6254

info->type = (yyvsp[(2) - (3)].classinfo);

6255

info->flags = flags;

6256

6257

dict_put(global->token2info, (void*)(ptroff_t)as3_tokencount, info);

6258

}

6259

6260

if(as3_pass == 2) {

6261

varinfo_t*info = dict_lookup(global->token2info, (void*)(ptroff_t)as3_tokencount);

6262

6263

multiname_t mname;

6264

code_t**code;

6265

trait_t*t = add_abc_slot(slotstate_flags, (yyvsp[(1) - (3)].id), &mname, &code);

6266

6267

if((yyvsp[(2) - (3)].classinfo)) {

6268

MULTINAME(m, (yyvsp[(2) - (3)].classinfo));

6269

t->type_name = multiname_clone(&m);

6270

}

6271

info->slot = t->slot_id;

6272

6273

/* workaround for "VerifyError: Error #1053: Illegal override of ::test2 in C1"

6274

FIXME: is there a way to use slots and still don't have conflicting overrides?

6275

*/

6276

info->slot = t->slot_id = 0;

6277

6278

constant_t cval = (yyvsp[(3) - (3)].node)->type->eval((yyvsp[(3) - (3)].node));

6279

if(cval.type!=CONSTANT_UNKNOWN) {

6280

/* compile time constant */

6281

t->value = malloc(sizeof(constant_t));

6282

memcpy(t->value, &cval, sizeof(constant_t));

6283

info->value = constant_clone(t->value);

6284

} else {

6285

typedcode_t v = node_read((yyvsp[(3) - (3)].node));

6286

/* initalization code (if needed) */

6287

code_t*c = 0;

6288

if(v.c && !is_pushundefined(v.c)) {

6289

c = abc_getlocal_0(c);

6290

c = code_append(c, v.c);

6291

c = converttype(c, v.t, (yyvsp[(2) - (3)].classinfo));

6292

if(!t->slot_id) {

6293

c = abc_initproperty2(c, &mname);

6294

} else {

6295

c = abc_setslot(c, t->slot_id);

6296

}

6297

}

6298

*code = code_append(*code, c);

6299

}

6300

6301

if(slotstate_varconst==KW_CONST) {

6302

t->kind= TRAIT_CONST;

6303

info->flags |= FLAG_CONST;

6304

}

6305

}

6306

6307

(yyval.code)=0;

6308

}

6309

}

6310

break;

6311

6312

6313

6314

case 172:

6315

if(as3_pass==2) {

6316

6317

/* Line 1464 of skeleton.m4 */

6318

#line 2790 "parser.y"

6319

{(yyval.constant)=0;}

6320

}

6321

break;

6322

6323

6324

6325

case 173:

6326

if(as3_pass==2) {

6327

6328

/* Line 1464 of skeleton.m4 */

6329

#line 2791 "parser.y"

6330

{

6331

(yyval.constant) = malloc(sizeof(constant_t));

6332

*(yyval.constant) = node_eval((yyvsp[(2) - (2)].node));

6333

if((yyval.constant)->type == CONSTANT_UNKNOWN) {

6334

syntaxerror("can't evaluate default parameter value (needs to be a compile-time constant)");

6335

}

6336

}

6337

}

6338

break;

6339

6340

6341

6342

case 174:

6343

if(as3_pass==2) {

6344

6345

/* Line 1464 of skeleton.m4 */

6346

#line 2800 "parser.y"

6347

{(yyval.constant) = constant_new_int((yyvsp[(1) - (1)].number_int));}

6348

}

6349

break;

6350

6351

6352

6353

case 175:

6354

if(as3_pass==2) {

6355

6356

/* Line 1464 of skeleton.m4 */

6357

#line 2801 "parser.y"

6358

{

6359

(yyval.constant) = constant_new_uint((yyvsp[(1) - (1)].number_uint));

6360

}

6361

}

6362

break;

6363

6364

6365

6366

case 176:

6367

if(as3_pass==2) {

6368

6369

/* Line 1464 of skeleton.m4 */

6370

#line 2804 "parser.y"

6371

{(yyval.constant) = constant_new_float((yyvsp[(1) - (1)].number_float));}

6372

}

6373

break;

6374

6375

6376

6377

case 177:

6378

if(as3_pass==2) {

6379

6380

/* Line 1464 of skeleton.m4 */

6381

#line 2805 "parser.y"

6382

{(yyval.constant) = constant_new_string2((yyvsp[(1) - (1)].str).str,(yyvsp[(1) - (1)].str).len);free((char*)(yyvsp[(1) - (1)].str).str);}

6383

}

6384

break;

6385

6386

6387

6388

case 178:

6389

if(as3_pass==2) {

6390

6391

/* Line 1464 of skeleton.m4 */

6392

#line 2806 "parser.y"

6393

{(yyval.constant) = constant_new_true((yyvsp[(1) - (1)].token));}

6394

}

6395

break;

6396

6397

6398

6399

case 179:

6400

if(as3_pass==2) {

6401

6402

/* Line 1464 of skeleton.m4 */

6403

#line 2807 "parser.y"

6404

{(yyval.constant) = constant_new_false((yyvsp[(1) - (1)].token));}

6405

}

6406

break;

6407

6408

6409

6410

case 180:

6411

if(as3_pass==2) {

6412

6413

/* Line 1464 of skeleton.m4 */

6414

#line 2808 "parser.y"

6415

{(yyval.constant) = constant_new_null((yyvsp[(1) - (1)].token));}

6416

}

6417

break;

6418

6419

6420

6421

case 181:

6422

if(as3_pass==2) {

6423

6424

/* Line 1464 of skeleton.m4 */

6425

#line 2809 "parser.y"

6426

{(yyval.constant) = constant_new_undefined((yyvsp[(1) - (1)].token));}

6427

}

6428

break;

6429

6430

6431

6432

case 182:

6433

if(as3_pass==2) {

6434

6435

/* Line 1464 of skeleton.m4 */

6436

#line 2810 "parser.y"

6437

{(yyval.constant) = constant_new_float(__builtin_nan(""));}

6438

}

6439

break;

6440

6441

6442

6443

case 183:

6444

if(as3_pass==2) {

6445

6446

/* Line 1464 of skeleton.m4 */

6447

#line 2823 "parser.y"

6448

{

6449

multiname_t m = {QNAME, &stdns, 0, "XML"};

6450

typedcode_t v;

6451

v.c = 0;

6452

v.c = abc_getlex2(v.c, &m);

6453

v.c = code_append(v.c, node_read((yyvsp[(1) - (1)].node)).c);

6454

v.c = abc_construct(v.c, 1);

6455

v.t = TYPE_XML;

6456

(yyval.node) = mkcodenode(v);

6457

}

6458

}

6459

break;

6460

6461

6462

6463

case 184:

6464

if(as3_pass==2) {

6465

6466

/* Line 1464 of skeleton.m4 */

6467

#line 2834 "parser.y"

6468

{PASS_ALWAYS if(!xml_level++) tokenizer_begin_xml();}

6469

}

6470

break;

6471

6472

6473

6474

case 185:

6475

if(as3_pass==2) {

6476

6477

/* Line 1464 of skeleton.m4 */

6478

#line 2835 "parser.y"

6479

{PASS_ALWAYS tokenizer_begin_xmltext();}

6480

}

6481

break;

6482

6483

6484

6485

case 186:

6486

if(as3_pass==2) {

6487

6488

/* Line 1464 of skeleton.m4 */

6489

#line 2836 "parser.y"

6490

{PASS_ALWAYS if(!--xml_level) tokenizer_end_xml(); else tokenizer_begin_xmltext();}

6491

}

6492

break;

6493

6494

6495

6496

case 187:

6497

if(as3_pass==2) {

6498

6499

/* Line 1464 of skeleton.m4 */

6500

#line 2838 "parser.y"

6501

{PASS_ALWAYS tokenizer_begin_xmltext();}

6502

}

6503

break;

6504

6505

6506

6507

case 188:

6508

if(as3_pass==2) {

6509

6510

/* Line 1464 of skeleton.m4 */

6511

#line 2838 "parser.y"

6512

{

6513

(yyval.node) = (yyvsp[(2) - (4)].node);

6514

}

6515

}

6516

break;

6517

6518

6519

6520

case 189:

6521

if(as3_pass==2) {

6522

6523

/* Line 1464 of skeleton.m4 */

6524

#line 2841 "parser.y"

6525

{PASS_ALWAYS tokenizer_begin_xml();}

6526

}

6527

break;

6528

6529

6530

6531

case 190:

6532

if(as3_pass==2) {

6533

6534

/* Line 1464 of skeleton.m4 */

6535

#line 2841 "parser.y"

6536

{

6537

(yyval.node) = (yyvsp[(2) - (4)].node);

6538

}

6539

}

6540

break;

6541

6542

6543

6544

case 191:

6545

if(as3_pass==2) {

6546

6547

/* Line 1464 of skeleton.m4 */

6548

#line 2844 "parser.y"

6549

{(yyval.node)=mkstringnode("");}

6550

}

6551

break;

6552

6553

6554

6555

case 192:

6556

if(as3_pass==2) {

6557

6558

/* Line 1464 of skeleton.m4 */

6559

#line 2845 "parser.y"

6560

{

6561

(yyval.node) = mkaddnode((yyvsp[(1) - (2)].node),(yyvsp[(2) - (2)].node));

6562

}

6563

}

6564

break;

6565

6566

6567

6568

case 193:

6569

if(as3_pass==2) {

6570

6571

/* Line 1464 of skeleton.m4 */

6572

#line 2848 "parser.y"

6573

{

6574

char* str = string_cstr(&(yyvsp[(2) - (2)].str));

6575

(yyval.node) = mkaddnode((yyvsp[(1) - (2)].node),mkstringnode(str));

6576

free(str);

6577

}

6578

}

6579

break;

6580

6581

6582

6583

case 194:

6584

if(as3_pass==2) {

6585

6586

/* Line 1464 of skeleton.m4 */

6587

#line 2853 "parser.y"

6588

{

6589

(yyval.node) = mkaddnode((yyvsp[(1) - (2)].node), mkstringnode(">"));

6590

}

6591

}

6592

break;

6593

6594

6595

6596

case 195:

6597

if(as3_pass==2) {

6598

6599

/* Line 1464 of skeleton.m4 */

6600

#line 2856 "parser.y"

6601

{

6602

(yyval.node) = mkaddnode((yyvsp[(1) - (2)].node),(yyvsp[(2) - (2)].node));

6603

}

6604

}

6605

break;

6606

6607

6608

6609

case 196:

6610

if(as3_pass==2) {

6611

6612

/* Line 1464 of skeleton.m4 */

6613

#line 2859 "parser.y"

6614

{

6615

(yyval.node) = mkaddnode((yyvsp[(1) - (3)].node), mkaddnode((yyvsp[(2) - (3)].node),(yyvsp[(3) - (3)].node)));

6616

}

6617

}

6618

break;

6619

6620

6621

6622

case 197:

6623

if(as3_pass==2) {

6624

6625

/* Line 1464 of skeleton.m4 */

6626

#line 2862 "parser.y"

6627

{

6628

(yyval.node) = mkstringnode((yyvsp[(1) - (1)].id));

6629

}

6630

}

6631

break;

6632

6633

6634

6635

case 198:

6636

if(as3_pass==2) {

6637

6638

/* Line 1464 of skeleton.m4 */

6639

#line 2865 "parser.y"

6640

{

6641

(yyval.node) = (yyvsp[(1) - (1)].node);

6642

}

6643

}

6644

break;

6645

6646

6647

6648

case 199:

6649

if(as3_pass==2) {

6650

6651

/* Line 1464 of skeleton.m4 */

6652

#line 2869 "parser.y"

6653

{

6654

(yyval.node) = mkstringnode("");

6655

}

6656

}

6657

break;

6658

6659

6660

6661

case 200:

6662

if(as3_pass==2) {

6663

6664

/* Line 1464 of skeleton.m4 */

6665

#line 2872 "parser.y"

6666

{

6667

(yyval.node) = mkaddnode(mkstringnode(" "),(yyvsp[(1) - (1)].node));

6668

}

6669

}

6670

break;

6671

6672

6673

6674

case 201:

6675

if(as3_pass==2) {

6676

6677

/* Line 1464 of skeleton.m4 */

6678

#line 2876 "parser.y"

6679

{

6680

//$$ = allocprintf("<%s%s/>", $2, $3, $5, $8);

6681

(yyval.node) = mkaddnode(mkaddnode(mkaddnode(mkstringnode("<"),(yyvsp[(2) - (6)].node)),(yyvsp[(3) - (6)].node)),mkstringnode("/>"));

6682

}

6683

}

6684

break;

6685

6686

6687

6688

case 202:

6689

if(as3_pass==2) {

6690

6691

/* Line 1464 of skeleton.m4 */

6692

#line 2880 "parser.y"

6693

{

6694

//$$ = allocprintf("<%s%s>%s</%s>", $2, $3, $5, $8);

6695

(yyval.node) = mkaddnode(mkaddnode(mkaddnode(mkaddnode(mkaddnode(mkaddnode(mkaddnode(

6696

mkstringnode("<"),(yyvsp[(2) - (10)].node)),(yyvsp[(3) - (10)].node)),mkstringnode(">")),(yyvsp[(5) - (10)].node)),mkstringnode("</")),(yyvsp[(8) - (10)].node)),mkstringnode(">"));

6697

}

6698

}

6699

break;

6700

6701

6702

6703

case 203:

6704

if(as3_pass==2) {

6705

6706

/* Line 1464 of skeleton.m4 */

6707

#line 2885 "parser.y"

6708

{

6709

//$$ = allocprintf("<%s%s>%s%s</%s>", $2, $3, $5, $6, $9);

6710

(yyval.node) = mkaddnode(mkaddnode(mkaddnode(mkaddnode(mkaddnode(mkaddnode(mkaddnode(mkaddnode(

6711

mkstringnode("<"),(yyvsp[(2) - (11)].node)),(yyvsp[(3) - (11)].node)),mkstringnode(">")),(yyvsp[(5) - (11)].node)),(yyvsp[(6) - (11)].node)),mkstringnode("</")),(yyvsp[(9) - (11)].node)),mkstringnode(">"));

6712

}

6713

}

6714

break;

6715

6716

6717

6718

case 204:

6719

if(as3_pass==2) {

6720

6721

/* Line 1464 of skeleton.m4 */

6722

#line 2891 "parser.y"

6723

{

6724

(yyval.node) = (yyvsp[(1) - (1)].node);

6725

}

6726

}

6727

break;

6728

6729

6730

6731

case 205:

6732

if(as3_pass==2) {

6733

6734

/* Line 1464 of skeleton.m4 */

6735

#line 2894 "parser.y"

6736

{

6737

(yyval.node) = mkaddnode((yyvsp[(1) - (2)].node), mkaddnode(mkstringnode(" "),(yyvsp[(2) - (2)].node)));

6738

}

6739

}

6740

break;

6741

6742

6743

6744

case 206:

6745

if(as3_pass==2) {

6746

6747

/* Line 1464 of skeleton.m4 */

6748

#line 2897 "parser.y"

6749

{

6750

(yyval.node) = (yyvsp[(1) - (1)].node);

6751

}

6752

}

6753

break;

6754

6755

6756

6757

case 207:

6758

if(as3_pass==2) {

6759

6760

/* Line 1464 of skeleton.m4 */

6761

#line 2900 "parser.y"

6762

{

6763

char* str = string_cstr(&(yyvsp[(3) - (3)].str));

6764

(yyval.node) = mkaddnode((yyvsp[(1) - (3)].node), mkstringnode(concat2("=",str)));

6765

free(str);

6766

}

6767

}

6768

break;

6769

6770

6771

6772

case 208:

6773

if(as3_pass==2) {

6774

6775

/* Line 1464 of skeleton.m4 */

6776

#line 2905 "parser.y"

6777

{

6778

(yyval.node) = mkaddnode((yyvsp[(1) - (3)].node), mkaddnode(mkstringnode("=\""), mkaddnode((yyvsp[(3) - (3)].node), mkstringnode("\""))));

6779

}

6780

}

6781

break;

6782

6783

6784

6785

case 209:

6786

if(as3_pass==2) {

6787

6788

/* Line 1464 of skeleton.m4 */

6789

#line 2908 "parser.y"

6790

{

6791

(yyval.node) = mkaddnode(mkaddnode(mkstringnode(concat2((yyvsp[(1) - (3)].id),"=\"")), (yyvsp[(3) - (3)].node)), mkstringnode("\""));

6792

}

6793

}

6794

break;

6795

6796

6797

6798

case 210:

6799

if(as3_pass==2) {

6800

6801

/* Line 1464 of skeleton.m4 */

6802

#line 2911 "parser.y"

6803

{

6804

char* str = string_cstr(&(yyvsp[(3) - (3)].str));

6805

(yyval.node)=mkstringnode(allocprintf("%s=%s", (yyvsp[(1) - (3)].id),str));

6806

free(str);

6807

free((yyvsp[(1) - (3)].id));free((char*)(yyvsp[(3) - (3)].str).str);

6808

}

6809

}

6810

break;

6811

6812

6813

6814

case 211:

6815

if(as3_pass==2) {

6816

6817

/* Line 1464 of skeleton.m4 */

6818

#line 2921 "parser.y"

6819

{

6820

PASS12

6821

memset(&(yyval.params),0,sizeof((yyval.params)));

6822

}

6823

}

6824

break;

6825

6826

6827

6828

case 212:

6829

if(as3_pass==2) {

6830

6831

/* Line 1464 of skeleton.m4 */

6832

#line 2925 "parser.y"

6833

{

6834

PASS12

6835

(yyval.params)=(yyvsp[(1) - (1)].params);

6836

}

6837

}

6838

break;

6839

6840

6841

6842

case 213:

6843

if(as3_pass==2) {

6844

6845

/* Line 1464 of skeleton.m4 */

6846

#line 2931 "parser.y"

6847

{

6848

PASS12

6849

memset(&(yyval.params),0,sizeof((yyval.params)));

6850

(yyval.params).varargs=1;

6851

list_append((yyval.params).list, (yyvsp[(2) - (2)].param));

6852

}

6853

}

6854

break;

6855

6856

6857

6858

case 214:

6859

if(as3_pass==2) {

6860

6861

/* Line 1464 of skeleton.m4 */

6862

#line 2937 "parser.y"

6863

{

6864

PASS12

6865

(yyval.params) =(yyvsp[(1) - (4)].params);

6866

(yyval.params).varargs=1;

6867

list_append((yyval.params).list, (yyvsp[(4) - (4)].param));

6868

}

6869

}

6870

break;

6871

6872

6873

6874

case 215:

6875

if(as3_pass==2) {

6876

6877

/* Line 1464 of skeleton.m4 */

6878

#line 2945 "parser.y"

6879

{

6880

PASS12

6881

(yyval.params) = (yyvsp[(1) - (3)].params);

6882

list_append((yyval.params).list, (yyvsp[(3) - (3)].param));

6883

}

6884

}

6885

break;

6886

6887

6888

6889

case 216:

6890

if(as3_pass==2) {

6891

6892

/* Line 1464 of skeleton.m4 */

6893

#line 2950 "parser.y"

6894

{

6895

PASS12

6896

memset(&(yyval.params),0,sizeof((yyval.params)));

6897

list_append((yyval.params).list, (yyvsp[(1) - (1)].param));

6898

}

6899

}

6900

break;

6901

6902

6903

6904

case 217:

6905

if(as3_pass==2) {

6906

6907

/* Line 1464 of skeleton.m4 */

6908

#line 2956 "parser.y"

6909

{

6910

PASS12

6911

(yyval.param) = rfx_calloc(sizeof(param_t));

6912

(yyval.param)->name=(yyvsp[(1) - (4)].id);

6913

(yyval.param)->type = (yyvsp[(3) - (4)].classinfo);

6914

PASS2

6915

(yyval.param)->value = (yyvsp[(4) - (4)].constant);

6916

}

6917

}

6918

break;

6919

6920

6921

6922

case 218:

6923

if(as3_pass==2) {

6924

6925

/* Line 1464 of skeleton.m4 */

6926

#line 2964 "parser.y"

6927

{

6928

PASS12

6929

(yyval.param) = rfx_calloc(sizeof(param_t));

6930

(yyval.param)->name=(yyvsp[(1) - (2)].id);

6931

(yyval.param)->type = TYPE_ANY;

6932

PASS2

6933

(yyval.param)->value = (yyvsp[(2) - (2)].constant);

6934

}

6935

}

6936

break;

6937

6938

6939

6940

case 221:

6941

if(as3_pass==2) {

6942

6943

/* Line 1464 of skeleton.m4 */

6944

#line 2974 "parser.y"

6945

{PASS12 (yyval.token)=0;}

6946

}

6947

break;

6948

6949

6950

6951

case 222:

6952

if(as3_pass==2) {

6953

6954

/* Line 1464 of skeleton.m4 */

6955

#line 2977 "parser.y"

6956

{PASS12 startfunction(&(yyvsp[(1) - (9)].flags),(yyvsp[(3) - (9)].token),(yyvsp[(4) - (9)].id),&(yyvsp[(6) - (9)].params),(yyvsp[(8) - (9)].classinfo));}

6957

}

6958

break;

6959

6960

6961

6962

case 223:

6963

if(as3_pass==2) {

6964

6965

/* Line 1464 of skeleton.m4 */

6966

#line 2978 "parser.y"

6967

{

6968

PASS1

6969

endfunction(&(yyvsp[(1) - (12)].flags),(yyvsp[(3) - (12)].token),(yyvsp[(4) - (12)].id),&(yyvsp[(6) - (12)].params),0,0);

6970

PASS2

6971

if(!state->method->info) syntaxerror("internal error");

6972

6973

code_t*c = method_header(state->method);

6974

c = wrap_function(c, 0, (yyvsp[(11) - (12)].code));

6975

6976

endfunction(&(yyvsp[(1) - (12)].flags),(yyvsp[(3) - (12)].token),(yyvsp[(4) - (12)].id),&(yyvsp[(6) - (12)].params),(yyvsp[(8) - (12)].classinfo),c);

6977

PASS12

6978

list_deep_free((yyvsp[(6) - (12)].params).list);

6979

(yyval.code)=0;

6980

}

6981

}

6982

break;

6983

6984

6985

6986

case 225:

6987

if(as3_pass==2) {

6988

6989

/* Line 1464 of skeleton.m4 */

6990

#line 2994 "parser.y"

6991

{PASS12 (yyval.id)=0;}

6992

}

6993

break;

6994

6995

6996

6997

case 226:

6998

if(as3_pass==2) {

6999

7000

/* Line 1464 of skeleton.m4 */

7001

#line 2996 "parser.y"

7002

{PASS12 innerfunction((yyvsp[(2) - (7)].id),&(yyvsp[(4) - (7)].params),(yyvsp[(6) - (7)].classinfo));}

7003

}

7004

break;

7005

7006

7007

7008

case 227:

7009

if(as3_pass==2) {

7010

7011

/* Line 1464 of skeleton.m4 */

7012

#line 2997 "parser.y"

7013

{

7014

PASS1

7015

endfunction(0,0,(yyvsp[(2) - (10)].id),&(yyvsp[(4) - (10)].params),0,0);

7016

PASS2

7017

methodinfo_t*f = state->method->info;

7018

if(!f || !f->kind) syntaxerror("internal error");

7019

7020

code_t*c = method_header(state->method);

7021

c = wrap_function(c, 0, (yyvsp[(9) - (10)].code));

7022

7023

int index = state->method->var_index;

7024

endfunction(0,0,(yyvsp[(2) - (10)].id),&(yyvsp[(4) - (10)].params),(yyvsp[(6) - (10)].classinfo),c);

7025

7026

(yyval.value).c = abc_getlocal(0, index);

7027

(yyval.value).t = TYPE_FUNCTION(f);

7028

7029

PASS12 list_deep_free((yyvsp[(4) - (10)].params).list);

7030

}

7031

}

7032

break;

7033

7034

7035

7036

case 228:

7037

if(as3_pass==2) {

7038

7039

/* Line 1464 of skeleton.m4 */

7040

#line 3019 "parser.y"

7041

{

7042

PASS1 NEW(unresolvedinfo_t,c);

7043

memset(c, 0, sizeof(*c));

7044

c->kind = INFOTYPE_UNRESOLVED;

7045

c->name = (yyvsp[(1) - (1)].id);

7046

c->package = get_package_from_name((yyvsp[(1) - (1)].id));

7047

if(!c->package) {

7048

c->nsset = get_current_imports();

7049

/* make the compiler look for this class in the current directory,

7050

just in case: */

7051

as3_schedule_class_noerror(state->package, (yyvsp[(1) - (1)].id));

7052

}

7053

(yyval.classinfo) = (classinfo_t*)c;

7054

PASS2

7055

slotinfo_t*s = find_class((yyvsp[(1) - (1)].id));

7056

if(!s) syntaxerror("Could not find class/method %s (current package: %s)\n", (yyvsp[(1) - (1)].id), state->package);

7057

(yyval.classinfo) = (classinfo_t*)s;

7058

}

7059

}

7060

break;

7061

7062

7063

7064

case 229:

7065

if(as3_pass==2) {

7066

7067

/* Line 1464 of skeleton.m4 */

7068

#line 3038 "parser.y"

7069

{

7070

PASS1 NEW(unresolvedinfo_t,c);

7071

memset(c, 0, sizeof(*c));

7072

c->kind = INFOTYPE_UNRESOLVED;

7073

c->package = (yyvsp[(1) - (3)].id);

7074

c->name = (yyvsp[(3) - (3)].id);

7075

(yyval.classinfo) = (classinfo_t*)c;

7076

PASS2

7077

slotinfo_t*s = registry_find((yyvsp[(1) - (3)].id), (yyvsp[(3) - (3)].id));

7078

if(!s) syntaxerror("Couldn't find class/method %s.%s\n", (yyvsp[(1) - (3)].id), (yyvsp[(3) - (3)].id));

7079

free((yyvsp[(1) - (3)].id));(yyvsp[(1) - (3)].id)=0;

7080

(yyval.classinfo) = (classinfo_t*)s;

7081

}

7082

}

7083

break;

7084

7085

7086

7087

case 232:

7088

if(as3_pass==2) {

7089

7090

/* Line 1464 of skeleton.m4 */

7091

#line 3055 "parser.y"

7092

{PASS12 (yyval.classinfo_list)=list_new();list_append((yyval.classinfo_list), (yyvsp[(1) - (1)].classinfo));}

7093

}

7094

break;

7095

7096

7097

7098

case 233:

7099

if(as3_pass==2) {

7100

7101

/* Line 1464 of skeleton.m4 */

7102

#line 3056 "parser.y"

7103

{PASS12 (yyval.classinfo_list)=(yyvsp[(1) - (3)].classinfo_list);list_append((yyval.classinfo_list),(yyvsp[(3) - (3)].classinfo));}

7104

}

7105

break;

7106

7107

7108

7109

case 234:

7110

if(as3_pass==2) {

7111

7112

/* Line 1464 of skeleton.m4 */

7113

#line 3058 "parser.y"

7114

{PASS12 (yyval.classinfo)=(yyvsp[(1) - (1)].classinfo);}

7115

}

7116

break;

7117

7118

7119

7120

case 235:

7121

if(as3_pass==2) {

7122

7123

/* Line 1464 of skeleton.m4 */

7124

#line 3059 "parser.y"

7125

{PASS12 (yyval.classinfo)=TYPE_ANY;}

7126

}

7127

break;

7128

7129

7130

7131

case 236:

7132

if(as3_pass==2) {

7133

7134

/* Line 1464 of skeleton.m4 */

7135

#line 3060 "parser.y"

7136

{PASS12 (yyval.classinfo)=TYPE_VOID;}

7137

}

7138

break;

7139

7140

7141

7142

case 237:

7143

if(as3_pass==2) {

7144

7145

/* Line 1464 of skeleton.m4 */

7146

#line 3069 "parser.y"

7147

{PASS12 (yyval.classinfo)=(yyvsp[(2) - (2)].classinfo);}

7148

}

7149

break;

7150

7151

7152

7153

case 238:

7154

if(as3_pass==2) {

7155

7156

/* Line 1464 of skeleton.m4 */

7157

#line 3070 "parser.y"

7158

{PASS12 (yyval.classinfo)=0;}

7159

}

7160

break;

7161

7162

7163

7164

case 239:

7165

if(as3_pass==2) {

7166

7167

/* Line 1464 of skeleton.m4 */

7168

#line 3074 "parser.y"

7169

{(yyval.value_list).cc=0;(yyval.value_list).number=0;}

7170

}

7171

break;

7172

7173

7174

7175

case 240:

7176

if(as3_pass==2) {

7177

7178

/* Line 1464 of skeleton.m4 */

7179

#line 3075 "parser.y"

7180

{(yyval.value_list)=(yyvsp[(2) - (3)].value_list);}

7181

}

7182

break;

7183

7184

7185

7186

case 241:

7187

if(as3_pass==2) {

7188

7189

/* Line 1464 of skeleton.m4 */

7190

#line 3077 "parser.y"

7191

{(yyval.value_list).cc=0;(yyval.value_list).number=0;}

7192

}

7193

break;

7194

7195

7196

7197

case 244:

7198

if(as3_pass==2) {

7199

7200

/* Line 1464 of skeleton.m4 */

7201

#line 3081 "parser.y"

7202

{(yyval.value_list).number=1;

7203

(yyval.value_list).cc = (yyvsp[(1) - (1)].value).c;

7204

}

7205

}

7206

break;

7207

7208

7209

7210

case 245:

7211

if(as3_pass==2) {

7212

7213

/* Line 1464 of skeleton.m4 */

7214

#line 3085 "parser.y"

7215

{(yyval.value_list) = (yyvsp[(1) - (2)].value_list);}

7216

}

7217

break;

7218

7219

7220

7221

case 246:

7222

if(as3_pass==2) {

7223

7224

/* Line 1464 of skeleton.m4 */

7225

#line 3086 "parser.y"

7226

{

7227

(yyval.value_list).number= (yyvsp[(1) - (2)].value_list).number+1;

7228

(yyval.value_list).cc = code_append((yyvsp[(1) - (2)].value_list).cc, (yyvsp[(2) - (2)].value).c);

7229

}

7230

}

7231

break;

7232

7233

7234

7235

case 248:

7236

if(as3_pass==2) {

7237

7238

/* Line 1464 of skeleton.m4 */

7239

#line 3092 "parser.y"

7240

{

7241

typedcode_t v = node_read((yyvsp[(2) - (4)].node));

7242

(yyval.value).c = v.c;

7243

if((yyval.value).c->opcode == OPCODE_COERCE_A) (yyval.value).c = code_cutlast((yyval.value).c);

7244

7245

code_t*paramcode = (yyvsp[(4) - (4)].value_list).cc;

7246

if((yyval.value).c->opcode == OPCODE_GETPROPERTY) {

7247

multiname_t*name = (yyval.value).c->data[0];(yyval.value).c->data[0]=0;

7248

(yyval.value).c = code_cutlast((yyval.value).c);

7249

(yyval.value).c = code_append((yyval.value).c, paramcode);

7250

(yyval.value).c = abc_constructprop2((yyval.value).c, name, (yyvsp[(4) - (4)].value_list).number);

7251

multiname_destroy(name);

7252

} else if(TYPE_IS_CLASS(v.t) && v.t->data) {

7253

code_free((yyval.value).c);

7254

classinfo_t*c = v.t->data;

7255

MULTINAME(m, c);

7256

(yyval.value).c = abc_findpropstrict2(0, &m);

7257

(yyval.value).c = code_append((yyval.value).c, paramcode);

7258

(yyval.value).c = abc_constructprop2((yyval.value).c, &m, (yyvsp[(4) - (4)].value_list).number);

7259

/*} else if($$.c->opcode == OPCODE_GETSLOT) {

7260

int slot = (int)(ptroff_t)$$.c->data[0];

7261

trait_t*t = traits_find_slotid(state->cls->abc->traits,slot);//FIXME

7262

multiname_t*name = t->name;

7263

$$.c = code_cutlast($$.c);

7264

$$.c = code_append($$.c, paramcode);

7265

$$.c = abc_constructprop2($$.c, name, $4.number);*/

7266

} else {

7267

(yyval.value).c = code_append((yyval.value).c, paramcode);

7268

(yyval.value).c = abc_construct((yyval.value).c, (yyvsp[(4) - (4)].value_list).number);

7269

}

7270

7271

(yyval.value).t = TYPE_ANY;

7272

if(TYPE_IS_CLASS(v.t) && v.t->data) {

7273

(yyval.value).t = v.t->data;

7274

} else {

7275

(yyval.value).c = abc_coerce_a((yyval.value).c);

7276

(yyval.value).t = TYPE_ANY;

7277

}

7278

}

7279

}

7280

break;

7281

7282

7283

7284

case 249:

7285

if(as3_pass==2) {

7286

7287

/* Line 1464 of skeleton.m4 */

7288

#line 3136 "parser.y"

7289

{

7290

7291

typedcode_t v = node_read((yyvsp[(1) - (4)].node));

7292

(yyval.value).c = v.c;

7293

if((yyval.value).c->opcode == OPCODE_COERCE_A) {

7294

(yyval.value).c = code_cutlast((yyval.value).c);

7295

}

7296

code_t*paramcode = (yyvsp[(3) - (4)].value_list).cc;

7297

7298

(yyval.value).t = TYPE_ANY;

7299

if((yyval.value).c->opcode == OPCODE_GETPROPERTY) {

7300

multiname_t*name = (yyval.value).c->data[0];(yyval.value).c->data[0]=0;

7301

(yyval.value).c = code_cutlast((yyval.value).c);

7302

(yyval.value).c = code_append((yyval.value).c, paramcode);

7303

(yyval.value).c = abc_callproperty2((yyval.value).c, name, (yyvsp[(3) - (4)].value_list).number);

7304

multiname_destroy(name);

7305

/* } else if($$.c->opcode == OPCODE_GETSLOT && $$.c->prev->opcode != OPCODE_GETSCOPEOBJECT) {

7306

int slot = (int)(ptroff_t)$$.c->data[0];

7307

trait_t*t = traits_find_slotid(state->cls->abc->traits,slot);

7308

if(t->kind!=TRAIT_METHOD) {

7309

//ok: flash allows to assign closures to members.

7310

}

7311

multiname_t*name = t->name;

7312

$$.c = code_cutlast($$.c);

7313

$$.c = code_append($$.c, paramcode);

7314

//$$.c = abc_callmethod($$.c, t->method, len); //#1051 illegal early access binding

7315

$$.c = abc_callproperty2($$.c, name, $3.number);*/

7316

} else if((yyval.value).c->opcode == OPCODE_GETSUPER) {

7317

multiname_t*name = (yyval.value).c->data[0];(yyval.value).c->data[0]=0;

7318

(yyval.value).c = code_cutlast((yyval.value).c);

7319

(yyval.value).c = code_append((yyval.value).c, paramcode);

7320

(yyval.value).c = abc_callsuper2((yyval.value).c, name, (yyvsp[(3) - (4)].value_list).number);

7321

multiname_destroy(name);

7322

} else {

7323

(yyval.value).c = abc_getglobalscope((yyval.value).c);

7324

(yyval.value).c = code_append((yyval.value).c, paramcode);

7325

(yyval.value).c = abc_call((yyval.value).c, (yyvsp[(3) - (4)].value_list).number);

7326

}

7327

7328

if(TYPE_IS_FUNCTION(v.t) && v.t->data) {

7329

(yyval.value).t = ((methodinfo_t*)(v.t->data))->return_type;

7330

} else if(TYPE_IS_CLASS(v.t) && v.t->data) {

7331

// calling a class is like a typecast

7332

(yyval.value).t = (classinfo_t*)v.t->data;

7333

} else {

7334

(yyval.value).t = TYPE_ANY;

7335

(yyval.value).c = abc_coerce_a((yyval.value).c);

7336

}

7337

}

7338

}

7339

break;

7340

7341

7342

7343

case 250:

7344

if(as3_pass==2) {

7345

7346

/* Line 1464 of skeleton.m4 */

7347

#line 3186 "parser.y"

7348

{

7349

if(!state->cls) syntaxerror("super() not allowed outside of a class");

7350

if(!state->method) syntaxerror("super() not allowed outside of a function");

7351

if(!state->method->is_constructor) syntaxerror("super() not allowed outside of a constructor");

7352

7353

(yyval.value).c = code_new();

7354

(yyval.value).c = abc_getlocal_0((yyval.value).c);

7355

7356

(yyval.value).c = code_append((yyval.value).c, (yyvsp[(3) - (4)].value_list).cc);

7357

/*

7358

this is dependent on the control path, check this somewhere else

7359

if(state->method->has_super)

7360

syntaxerror("constructor may call super() only once");

7361

*/

7362

state->method->has_super = 1;

7363

7364

(yyval.value).c = abc_constructsuper((yyval.value).c, (yyvsp[(3) - (4)].value_list).number);

7365

(yyval.value).c = abc_pushundefined((yyval.value).c);

7366

(yyval.value).t = TYPE_ANY;

7367

}

7368

}

7369

break;

7370

7371

7372

7373

case 251:

7374

if(as3_pass==2) {

7375

7376

/* Line 1464 of skeleton.m4 */

7377

#line 3207 "parser.y"

7378

{

7379

typedcode_t v = node_read((yyvsp[(2) - (2)].node));

7380

(yyval.value).c = v.c;

7381

if((yyval.value).c->opcode == OPCODE_COERCE_A) {

7382

(yyval.value).c = code_cutlast((yyval.value).c);

7383

}

7384

multiname_t*name = 0;

7385

if((yyval.value).c->opcode == OPCODE_GETPROPERTY) {

7386

(yyval.value).c->opcode = OPCODE_DELETEPROPERTY;

7387

} else if((yyval.value).c->opcode == OPCODE_GETSLOT) {

7388

int slot = (int)(ptroff_t)(yyval.value).c->data[0];

7389

multiname_t*name = traits_find_slotid(state->cls->abc->traits,slot)->name;

7390

(yyval.value).c = code_cutlast((yyval.value).c);

7391

(yyval.value).c = abc_deleteproperty2((yyval.value).c, name);

7392

} else {

7393

(yyval.value).c = abc_getlocal_0((yyval.value).c);

7394

MULTINAME_LATE(m, v.t?v.t->access:ACCESS_PACKAGE, "");

7395

(yyval.value).c = abc_deleteproperty2((yyval.value).c, &m);

7396

}

7397

(yyval.value).t = TYPE_BOOLEAN;

7398

}

7399

}

7400

break;

7401

7402

7403

7404

case 252:

7405

if(as3_pass==2) {

7406

7407

/* Line 1464 of skeleton.m4 */

7408

#line 3229 "parser.y"

7409

{

7410

(yyval.code) = abc_returnvoid(0);

7411

}

7412

}

7413

break;

7414

7415

7416

7417

case 253:

7418

if(as3_pass==2) {

7419

7420

/* Line 1464 of skeleton.m4 */

7421

#line 3232 "parser.y"

7422

{

7423

(yyval.code) = (yyvsp[(2) - (2)].value).c;

7424

(yyval.code) = abc_returnvalue((yyval.code));

7425

}

7426

}

7427

break;

7428

7429

7430

7431

case 254:

7432

if(as3_pass==2) {

7433

7434

/* Line 1464 of skeleton.m4 */

7435

#line 3239 "parser.y"

7436

{

7437

(yyval.value) = node_read((yyvsp[(1) - (1)].node));

7438

}

7439

}

7440

break;

7441

7442

7443

7444

case 255:

7445

if(as3_pass==2) {

7446

7447

/* Line 1464 of skeleton.m4 */

7448

#line 3242 "parser.y"

7449

{

7450

(yyval.value) = node_read((yyvsp[(1) - (1)].node));

7451

}

7452

}

7453

break;

7454

7455

7456

7457

case 256:

7458

if(as3_pass==2) {

7459

7460

/* Line 1464 of skeleton.m4 */

7461

#line 3245 "parser.y"

7462

{

7463

(yyval.node) = mkmultinode(&node_comma, (yyvsp[(1) - (1)].node));

7464

}

7465

}

7466

break;

7467

7468

7469

7470

case 257:

7471

if(as3_pass==2) {

7472

7473

/* Line 1464 of skeleton.m4 */

7474

#line 3248 "parser.y"

7475

{

7476

(yyval.node) = multinode_extend((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));

7477

}

7478

}

7479

break;

7480

7481

7482

7483

case 258:

7484

if(as3_pass==2) {

7485

7486

/* Line 1464 of skeleton.m4 */

7487

#line 3251 "parser.y"

7488

{

7489

(yyval.code) = node_exec((yyvsp[(1) - (1)].node));

7490

}

7491

}

7492

break;

7493

7494

7495

7496

case 259:

7497

if(as3_pass==2) {

7498

7499

/* Line 1464 of skeleton.m4 */

7500

#line 3254 "parser.y"

7501

{

7502

(yyval.code) = (yyvsp[(1) - (3)].code);

7503

(yyval.code) = code_append((yyval.code), node_exec((yyvsp[(3) - (3)].node)));

7504

}

7505

}

7506

break;

7507

7508

7509

7510

case 260:

7511

if(as3_pass==2) {

7512

7513

/* Line 1464 of skeleton.m4 */

7514

#line 3259 "parser.y"

7515

{(yyval.value_list).cc=0;(yyval.value_list).number=0;}

7516

}

7517

break;

7518

7519

7520

7521

case 261:

7522

if(as3_pass==2) {

7523

7524

/* Line 1464 of skeleton.m4 */

7525

#line 3260 "parser.y"

7526

{(yyval.value_list)=(yyvsp[(1) - (1)].value_list);}

7527

}

7528

break;

7529

7530

7531

7532

case 262:

7533

if(as3_pass==2) {

7534

7535

/* Line 1464 of skeleton.m4 */

7536

#line 3262 "parser.y"

7537

{(yyval.code)=abc_pushstring(0,(yyvsp[(1) - (1)].id));}

7538

}

7539

break;

7540

7541

7542

7543

case 263:

7544

if(as3_pass==2) {

7545

7546

/* Line 1464 of skeleton.m4 */

7547

#line 3263 "parser.y"

7548

{(yyval.code)=abc_pushstring2(0,&(yyvsp[(1) - (1)].str));}

7549

}

7550

break;

7551

7552

7553

7554

case 264:

7555

if(as3_pass==2) {

7556

7557

/* Line 1464 of skeleton.m4 */

7558

#line 3264 "parser.y"

7559

{syntaxerror("dictionary keys must be strings");}

7560

}

7561

break;

7562

7563

7564

7565

case 265:

7566

if(as3_pass==2) {

7567

7568

/* Line 1464 of skeleton.m4 */

7569

#line 3265 "parser.y"

7570

{syntaxerror("dictionary keys must be strings");}

7571

}

7572

break;

7573

7574

7575

7576

case 266:

7577

if(as3_pass==2) {

7578

7579

/* Line 1464 of skeleton.m4 */

7580

#line 3266 "parser.y"

7581

{syntaxerror("dictionary keys must be strings");}

7582

}

7583

break;

7584

7585

7586

7587

case 267:

7588

if(as3_pass==2) {

7589

7590

/* Line 1464 of skeleton.m4 */

7591

#line 3268 "parser.y"

7592

{

7593

(yyval.value_list).cc = 0;

7594

(yyval.value_list).cc = code_append((yyval.value_list).cc, (yyvsp[(1) - (3)].code));

7595

(yyval.value_list).cc = code_append((yyval.value_list).cc, (yyvsp[(3) - (3)].value).c);

7596

(yyval.value_list).number = 2;

7597

}

7598

}

7599

break;

7600

7601

7602

7603

case 268:

7604

if(as3_pass==2) {

7605

7606

/* Line 1464 of skeleton.m4 */

7607

#line 3274 "parser.y"

7608

{

7609

(yyval.value_list).cc = (yyvsp[(1) - (5)].value_list).cc;

7610

(yyval.value_list).number = (yyvsp[(1) - (5)].value_list).number+2;

7611

(yyval.value_list).cc = code_append((yyval.value_list).cc, (yyvsp[(3) - (5)].code));

7612

(yyval.value_list).cc = code_append((yyval.value_list).cc, (yyvsp[(5) - (5)].value).c);

7613

}

7614

}

7615

break;

7616

7617

7618

7619

case 269:

7620

if(as3_pass==2) {

7621

7622

/* Line 1464 of skeleton.m4 */

7623

#line 3283 "parser.y"

7624

{(yyval.node) = mkcodenode((yyvsp[(1) - (1)].value));}

7625

}

7626

break;

7627

7628

7629

7630

case 270:

7631

if(as3_pass==2) {

7632

7633

/* Line 1464 of skeleton.m4 */

7634

#line 3284 "parser.y"

7635

{(yyval.node) = mkcodenode((yyvsp[(1) - (1)].value));}

7636

}

7637

break;

7638

7639

7640

7641

case 271:

7642

if(as3_pass==2) {

7643

7644

/* Line 1464 of skeleton.m4 */

7645

#line 3285 "parser.y"

7646

{(yyval.node) = mkcodenode((yyvsp[(1) - (1)].value));}

7647

}

7648

break;

7649

7650

7651

7652

case 272:

7653

if(as3_pass==2) {

7654

7655

/* Line 1464 of skeleton.m4 */

7656

#line 3286 "parser.y"

7657

{(yyval.node) = mkcodenode((yyvsp[(1) - (1)].value));}

7658

}

7659

break;

7660

7661

7662

7663

case 273:

7664

if(as3_pass==2) {

7665

7666

/* Line 1464 of skeleton.m4 */

7667

#line 3287 "parser.y"

7668

{(yyval.node) = mkcodenode((yyvsp[(1) - (1)].value));}

7669

}

7670

break;

7671

7672

7673

7674

case 274:

7675

if(as3_pass==2) {

7676

7677

/* Line 1464 of skeleton.m4 */

7678

#line 3288 "parser.y"

7679

{(yyval.node) = (yyvsp[(1) - (1)].node);}

7680

}

7681

break;

7682

7683

7684

7685

case 275:

7686

if(as3_pass==2) {

7687

7688

/* Line 1464 of skeleton.m4 */

7689

#line 3290 "parser.y"

7690

{

7691

(yyval.node) = mkconstnode((yyvsp[(1) - (1)].constant));

7692

}

7693

}

7694

break;

7695

7696

7697

7698

case 276:

7699

if(as3_pass==2) {

7700

7701

/* Line 1464 of skeleton.m4 */

7702

#line 3294 "parser.y"

7703

{

7704

(yyval.node) = (yyvsp[(1) - (1)].node);

7705

}

7706

}

7707

break;

7708

7709

7710

7711

case 277:

7712

if(as3_pass==2) {

7713

7714

/* Line 1464 of skeleton.m4 */

7715

#line 3299 "parser.y"

7716

{

7717

typedcode_t v;

7718

v.c = 0;

7719

multiname_t m = {QNAME, &stdns, 0, "RegExp"};

7720

if(!(yyvsp[(1) - (1)].regexp).options) {

7721

v.c = abc_getlex2(v.c, &m);

7722

v.c = abc_pushstring(v.c, (yyvsp[(1) - (1)].regexp).pattern);

7723

v.c = abc_construct(v.c, 1);

7724

} else {

7725

v.c = abc_getlex2(v.c, &m);

7726

v.c = abc_pushstring(v.c, (yyvsp[(1) - (1)].regexp).pattern);

7727

v.c = abc_pushstring(v.c, (yyvsp[(1) - (1)].regexp).options);

7728

v.c = abc_construct(v.c, 2);

7729

}

7730

v.t = TYPE_REGEXP;

7731

(yyval.node) = mkcodenode(v);

7732

}

7733

}

7734

break;

7735

7736

7737

7738

case 278:

7739

if(as3_pass==2) {

7740

7741

/* Line 1464 of skeleton.m4 */

7742

#line 3317 "parser.y"

7743

{

7744

PASS1

7745

state->method->need_arguments = 1;

7746

PASS2

7747

typedcode_t v;

7748

v.c = abc_getlocal(0, state->method->need_arguments);

7749

v.t = TYPE_ARRAY;

7750

(yyval.node) = mkcodenode(v);

7751

}

7752

}

7753

break;

7754

7755

7756

7757

case 279:

7758

if(as3_pass==2) {

7759

7760

/* Line 1464 of skeleton.m4 */

7761

#line 3328 "parser.y"

7762

{

7763

typedcode_t v;

7764

v.c = code_new();

7765

v.c = code_append(v.c, (yyvsp[(2) - (3)].value_list).cc);

7766

v.c = abc_newarray(v.c, (yyvsp[(2) - (3)].value_list).number);

7767

v.t = registry_getarrayclass();

7768

(yyval.node) = mkcodenode(v);

7769

}

7770

}

7771

break;

7772

7773

7774

7775

case 280:

7776

if(as3_pass==2) {

7777

7778

/* Line 1464 of skeleton.m4 */

7779

#line 3338 "parser.y"

7780

{

7781

typedcode_t v;

7782

v.c = code_new();

7783

v.c = code_append(v.c, (yyvsp[(2) - (3)].value_list).cc);

7784

v.c = abc_newobject(v.c, (yyvsp[(2) - (3)].value_list).number/2);

7785

v.t = registry_getobjectclass();

7786

(yyval.node) = mkcodenode(v);

7787

}

7788

}

7789

break;

7790

7791

7792

7793

case 281:

7794

if(as3_pass==2) {

7795

7796

/* Line 1464 of skeleton.m4 */

7797

#line 3347 "parser.y"

7798

{(yyval.node) = mknode2(&node_lt,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}

7799

}

7800

break;

7801

7802

7803

7804

case 282:

7805

if(as3_pass==2) {

7806

7807

/* Line 1464 of skeleton.m4 */

7808

#line 3348 "parser.y"

7809

{(yyval.node) = mknode2(&node_gt,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}

7810

}

7811

break;

7812

7813

7814

7815

case 283:

7816

if(as3_pass==2) {

7817

7818

/* Line 1464 of skeleton.m4 */

7819

#line 3349 "parser.y"

7820

{(yyval.node) = mknode2(&node_le,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}

7821

}

7822

break;

7823

7824

7825

7826

case 284:

7827

if(as3_pass==2) {

7828

7829

/* Line 1464 of skeleton.m4 */

7830

#line 3350 "parser.y"

7831

{(yyval.node) = mknode2(&node_ge,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}

7832

}

7833

break;

7834

7835

7836

7837

case 285:

7838

if(as3_pass==2) {

7839

7840

/* Line 1464 of skeleton.m4 */

7841

#line 3351 "parser.y"

7842

{(yyval.node) = mknode2(&node_eqeq,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}

7843

}

7844

break;

7845

7846

7847

7848

case 286:

7849

if(as3_pass==2) {

7850

7851

/* Line 1464 of skeleton.m4 */

7852

#line 3352 "parser.y"

7853

{(yyval.node) = mknode2(&node_eqeqeq,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}

7854

}

7855

break;

7856

7857

7858

7859

case 287:

7860

if(as3_pass==2) {

7861

7862

/* Line 1464 of skeleton.m4 */

7863

#line 3353 "parser.y"

7864

{(yyval.node) = mknode2(&node_noteqeq,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}

7865

}

7866

break;

7867

7868

7869

7870

case 288:

7871

if(as3_pass==2) {

7872

7873

/* Line 1464 of skeleton.m4 */

7874

#line 3354 "parser.y"

7875

{(yyval.node) = mknode2(&node_noteq,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}

7876

}

7877

break;

7878

7879

7880

7881

case 289:

7882

if(as3_pass==2) {

7883

7884

/* Line 1464 of skeleton.m4 */

7885

#line 3355 "parser.y"

7886

{(yyval.node) = mknode2(&node_oror,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}

7887

}

7888

break;

7889

7890

7891

7892

case 290:

7893

if(as3_pass==2) {

7894

7895

/* Line 1464 of skeleton.m4 */

7896

#line 3356 "parser.y"

7897

{(yyval.node) = mknode2(&node_andand,(yyvsp[(1) - (3)].node),(yyvsp[(3) - (3)].node));}

7898

}

7899

break;

7900

7901

7902

7903

case 291:

7904

if(as3_pass==2) {

7905

7906

/* Line 1464 of skeleton.m4 */

7907

#line 3357 "parser.y"

7908

{(yyval.node) = mknode1(&node_not, (yyvsp[(2) - (2)].node));}

7909

}

7910

break;

7911

7912

7913

7914

case 292:

7915

if(as3_pass==2) {

7916

7917

/* Line 1464 of skeleton.m4 */

7918

#line 3358 "parser.y"

7919

{(yyval.node) = mknode1(&node_bitnot, (yyvsp[(2) - (2)].node));}

7920

}

7921

break;

7922

7923

7924

7925

case 293:

7926

if(as3_pass==2) {

7927

7928

/* Line 1464 of skeleton.m4 */

7929

#line 3359 "parser.y"

7930

{(yyval.node) = mknode2(&node_bitand, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}

7931

}

7932

break;

7933

7934

7935

7936

case 294:

7937

if(as3_pass==2) {

7938

7939

/* Line 1464 of skeleton.m4 */

7940

#line 3360 "parser.y"

7941

{(yyval.node) = mknode2(&node_bitxor, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}

7942

}

7943

break;

7944

7945

7946

7947

case 295:

7948

if(as3_pass==2) {

7949

7950

/* Line 1464 of skeleton.m4 */

7951

#line 3361 "parser.y"

7952

{(yyval.node) = mknode2(&node_bitor, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}

7953

}

7954

break;

7955

7956

7957

7958

case 296:

7959

if(as3_pass==2) {

7960

7961

/* Line 1464 of skeleton.m4 */

7962

#line 3362 "parser.y"

7963

{(yyval.node) = mknode2(&node_shr, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}

7964

}

7965

break;

7966

7967

7968

7969

case 297:

7970

if(as3_pass==2) {

7971

7972

/* Line 1464 of skeleton.m4 */

7973

#line 3363 "parser.y"

7974

{(yyval.node) = mknode2(&node_ushr, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}

7975

}

7976

break;

7977

7978

7979

7980

case 298:

7981

if(as3_pass==2) {

7982

7983

/* Line 1464 of skeleton.m4 */

7984

#line 3364 "parser.y"

7985

{(yyval.node) = mknode2(&node_shl, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}

7986

}

7987

break;

7988

7989

7990

7991

case 299:

7992

if(as3_pass==2) {

7993

7994

/* Line 1464 of skeleton.m4 */

7995

#line 3365 "parser.y"

7996

{(yyval.node) = mknode2(&node_div, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}

7997

}

7998

break;

7999

8000

8001

8002

case 300:

8003

if(as3_pass==2) {

8004

8005

/* Line 1464 of skeleton.m4 */

8006

#line 3366 "parser.y"

8007

{(yyval.node) = mknode2(&node_mod, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}

8008

}

8009

break;

8010

8011

8012

8013

case 301:

8014

if(as3_pass==2) {

8015

8016

/* Line 1464 of skeleton.m4 */

8017

#line 3367 "parser.y"

8018

{(yyval.node) = mknode2(&node_plus, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}

8019

}

8020

break;

8021

8022

8023

8024

case 302:

8025

if(as3_pass==2) {

8026

8027

/* Line 1464 of skeleton.m4 */

8028

#line 3368 "parser.y"

8029

{(yyval.node) = mknode2(&node_minus, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}

8030

}

8031

break;

8032

8033

8034

8035

case 303:

8036

if(as3_pass==2) {

8037

8038

/* Line 1464 of skeleton.m4 */

8039

#line 3369 "parser.y"

8040

{(yyval.node) = mknode2(&node_multiply, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}

8041

}

8042

break;

8043

8044

8045

8046

case 304:

8047

if(as3_pass==2) {

8048

8049

/* Line 1464 of skeleton.m4 */

8050

#line 3370 "parser.y"

8051

{(yyval.node) = mknode2(&node_in, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}

8052

}

8053

break;

8054

8055

8056

8057

case 305:

8058

if(as3_pass==2) {

8059

8060

/* Line 1464 of skeleton.m4 */

8061

#line 3371 "parser.y"

8062

{(yyval.node) = mknode2(&node_as, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}

8063

}

8064

break;

8065

8066

8067

8068

case 306:

8069

if(as3_pass==2) {

8070

8071

/* Line 1464 of skeleton.m4 */

8072

#line 3372 "parser.y"

8073

{(yyval.node) = mknode2(&node_instanceof, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}

8074

}

8075

break;

8076

8077

8078

8079

case 307:

8080

if(as3_pass==2) {

8081

8082

/* Line 1464 of skeleton.m4 */

8083

#line 3373 "parser.y"

8084

{(yyval.node) = mknode2(&node_is, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}

8085

}

8086

break;

8087

8088

8089

8090

case 308:

8091

if(as3_pass==2) {

8092

8093

/* Line 1464 of skeleton.m4 */

8094

#line 3374 "parser.y"

8095

{(yyval.node) = mknode1(&node_typeof, (yyvsp[(2) - (2)].node));}

8096

}

8097

break;

8098

8099

8100

8101

case 309:

8102

if(as3_pass==2) {

8103

8104

/* Line 1464 of skeleton.m4 */

8105

#line 3375 "parser.y"

8106

{(yyval.node) = mknode1(&node_void, (yyvsp[(2) - (2)].node));}

8107

}

8108

break;

8109

8110

8111

8112

case 310:

8113

if(as3_pass==2) {

8114

8115

/* Line 1464 of skeleton.m4 */

8116

#line 3376 "parser.y"

8117

{ (yyval.node) = mkconstnode(constant_new_undefined());}

8118

}

8119

break;

8120

8121

8122

8123

case 311:

8124

if(as3_pass==2) {

8125

8126

/* Line 1464 of skeleton.m4 */

8127

#line 3377 "parser.y"

8128

{ (yyval.node)=(yyvsp[(2) - (3)].node);}

8129

}

8130

break;

8131

8132

8133

8134

case 312:

8135

if(as3_pass==2) {

8136

8137

/* Line 1464 of skeleton.m4 */

8138

#line 3378 "parser.y"

8139

{(yyval.node) = mknode1(&node_neg, (yyvsp[(2) - (2)].node));}

8140

}

8141

break;

8142

8143

8144

8145

case 313:

8146

if(as3_pass==2) {

8147

8148

/* Line 1464 of skeleton.m4 */

8149

#line 3379 "parser.y"

8150

{(yyval.node) = mknode2(&node_arraylookup, (yyvsp[(1) - (4)].node),(yyvsp[(3) - (4)].node));}

8151

}

8152

break;

8153

8154

8155

8156

case 314:

8157

if(as3_pass==2) {

8158

8159

/* Line 1464 of skeleton.m4 */

8160

#line 3380 "parser.y"

8161

{(yyval.node) = mknode2(&node_muleq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}

8162

}

8163

break;

8164

8165

8166

8167

case 315:

8168

if(as3_pass==2) {

8169

8170

/* Line 1464 of skeleton.m4 */

8171

#line 3381 "parser.y"

8172

{(yyval.node) = mknode2(&node_modeq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}

8173

}

8174

break;

8175

8176

8177

8178

case 316:

8179

if(as3_pass==2) {

8180

8181

/* Line 1464 of skeleton.m4 */

8182

#line 3382 "parser.y"

8183

{(yyval.node) = mknode2(&node_shleq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}

8184

}

8185

break;

8186

8187

8188

8189

case 317:

8190

if(as3_pass==2) {

8191

8192

/* Line 1464 of skeleton.m4 */

8193

#line 3383 "parser.y"

8194

{(yyval.node) = mknode2(&node_shreq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}

8195

}

8196

break;

8197

8198

8199

8200

case 318:

8201

if(as3_pass==2) {

8202

8203

/* Line 1464 of skeleton.m4 */

8204

#line 3384 "parser.y"

8205

{(yyval.node) = mknode2(&node_ushreq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}

8206

}

8207

break;

8208

8209

8210

8211

case 319:

8212

if(as3_pass==2) {

8213

8214

/* Line 1464 of skeleton.m4 */

8215

#line 3385 "parser.y"

8216

{ (yyval.node) = mknode2(&node_diveq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}

8217

}

8218

break;

8219

8220

8221

8222

case 320:

8223

if(as3_pass==2) {

8224

8225

/* Line 1464 of skeleton.m4 */

8226

#line 3386 "parser.y"

8227

{ (yyval.node) = mknode2(&node_bitoreq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}

8228

}

8229

break;

8230

8231

8232

8233

case 321:

8234

if(as3_pass==2) {

8235

8236

/* Line 1464 of skeleton.m4 */

8237

#line 3387 "parser.y"

8238

{ (yyval.node) = mknode2(&node_bitxoreq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}

8239

}

8240

break;

8241

8242

8243

8244

case 322:

8245

if(as3_pass==2) {

8246

8247

/* Line 1464 of skeleton.m4 */

8248

#line 3388 "parser.y"

8249

{ (yyval.node) = mknode2(&node_bitandeq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}

8250

}

8251

break;

8252

8253

8254

8255

case 323:

8256

if(as3_pass==2) {

8257

8258

/* Line 1464 of skeleton.m4 */

8259

#line 3389 "parser.y"

8260

{ (yyval.node) = mknode2(&node_pluseq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}

8261

}

8262

break;

8263

8264

8265

8266

case 324:

8267

if(as3_pass==2) {

8268

8269

/* Line 1464 of skeleton.m4 */

8270

#line 3390 "parser.y"

8271

{ (yyval.node) = mknode2(&node_minuseq, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}

8272

}

8273

break;

8274

8275

8276

8277

case 325:

8278

if(as3_pass==2) {

8279

8280

/* Line 1464 of skeleton.m4 */

8281

#line 3391 "parser.y"

8282

{ (yyval.node) = mknode2(&node_assign, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));}

8283

}

8284

break;

8285

8286

8287

8288

case 326:

8289

if(as3_pass==2) {

8290

8291

/* Line 1464 of skeleton.m4 */

8292

#line 3392 "parser.y"

8293

{ (yyval.node) = mknode3(&node_tenary, (yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].node));}

8294

}

8295

break;

8296

8297

8298

8299

case 327:

8300

if(as3_pass==2) {

8301

8302

/* Line 1464 of skeleton.m4 */

8303

#line 3394 "parser.y"

8304

{ (yyval.node) = mknode1(&node_rplusplus, (yyvsp[(1) - (2)].node));}

8305

}

8306

break;

8307

8308

8309

8310

case 328:

8311

if(as3_pass==2) {

8312

8313

/* Line 1464 of skeleton.m4 */

8314

#line 3395 "parser.y"

8315

{ (yyval.node) = mknode1(&node_rminusminus, (yyvsp[(1) - (2)].node));}

8316

}

8317

break;

8318

8319

8320

8321

case 329:

8322

if(as3_pass==2) {

8323

8324

/* Line 1464 of skeleton.m4 */

8325

#line 3396 "parser.y"

8326

{(yyval.node) = mknode1(&node_lplusplus, (yyvsp[(2) - (2)].node)); }

8327

}

8328

break;

8329

8330

8331

8332

case 330:

8333

if(as3_pass==2) {

8334

8335

/* Line 1464 of skeleton.m4 */

8336

#line 3397 "parser.y"

8337

{(yyval.node) = mknode1(&node_lminusminus, (yyvsp[(2) - (2)].node)); }

8338

}

8339

break;

8340

8341

8342

8343

case 331:

8344

if(as3_pass==2) {

8345

8346

/* Line 1464 of skeleton.m4 */

8347

#line 3400 "parser.y"

8348

{ if(!state->cls->info)

8349

syntaxerror("super keyword not allowed outside a class");

8350

classinfo_t*t = state->cls->info->superclass;

8351

if(!t) t = TYPE_OBJECT;

8352

memberinfo_t*f = findmember_nsset(t, (yyvsp[(3) - (3)].id), 1);

8353

MEMBER_MULTINAME(m, f, (yyvsp[(3) - (3)].id));

8354

typedcode_t v;

8355

v.c = 0;

8356

v.c = abc_getlocal_0(v.c);

8357

v.c = abc_getsuper2(v.c, &m);

8358

v.t = slotinfo_gettype((slotinfo_t*)f);

8359

(yyval.node) = mkcodenode(v);

8360

}

8361

}

8362

break;

8363

8364

8365

8366

case 332:

8367

if(as3_pass==2) {

8368

8369

/* Line 1464 of skeleton.m4 */

8370

#line 3414 "parser.y"

8371

{

8372

typedcode_t v;

8373

multiname_t m = {MULTINAMEA, 0, &nopackage_namespace_set, (yyvsp[(2) - (2)].id)};

8374

v.c = abc_getlex2(0, &m);

8375

v.t = TYPE_STRING;

8376

(yyval.node) = mkcodenode(v);

8377

}

8378

}

8379

break;

8380

8381

8382

8383

case 333:

8384

if(as3_pass==2) {

8385

8386

/* Line 1464 of skeleton.m4 */

8387

#line 3422 "parser.y"

8388

{PASS12 new_state();state->xmlfilter=1;}

8389

}

8390

break;

8391

8392

8393

8394

case 334:

8395

if(as3_pass==2) {

8396

8397

/* Line 1464 of skeleton.m4 */

8398

#line 3422 "parser.y"

8399

{

8400

PASS1 old_state();

8401

PASS2

8402

typedcode_t v = node_read((yyvsp[(1) - (6)].node));

8403

typedcode_t w = node_read((yyvsp[(5) - (6)].node));

8404

code_t*c = 0;

8405

int index = alloc_local();

8406

int result = alloc_local();

8407

int tmp = alloc_local();

8408

int xml = alloc_local();

8409

8410

c = code_append(c, v.c);

8411

c = abc_checkfilter(c);

8412

c = abc_coerce_a(c); //hasnext2 converts to *

8413

c = abc_setlocal(c, xml);

8414

multiname_t m = {QNAME, &stdns, 0, "XMLList"};

8415

c = abc_getlex2(c, &m);

8416

c = abc_construct(c, 0);

8417

c = abc_setlocal(c, result);

8418

c = abc_pushbyte(c, 0);

8419

c = abc_setlocal(c, index);

8420

code_t*jmp = c = abc_jump(c, 0);

8421

code_t*loop = c = abc_label(c);

8422

c = abc_getlocal(c, xml);

8423

c = abc_getlocal(c, index);

8424

c = abc_nextvalue(c);

8425

c = abc_dup(c);

8426

c = abc_setlocal(c, tmp);

8427

c = abc_pushwith(c);

8428

c = code_append(c, w.c);

8429

c = abc_popscope(c);

8430

code_t*b = c = abc_iffalse(c, 0);

8431

c = abc_getlocal(c, result);

8432

c = abc_getlocal(c, index);

8433

c = abc_getlocal(c, tmp);

8434

multiname_t m2 = {MULTINAMEL, 0, &nopackage_namespace_set, 0};

8435

c = abc_setproperty2(c, &m2);

8436

c = b->branch = jmp->branch = abc_nop(c);

8437

c = abc_kill(c, tmp);

8438

c = abc_hasnext2(c, xml, index);

8439

c = abc_iftrue(c, loop);

8440

c = abc_getlocal(c, result);

8441

c = abc_kill(c, xml);

8442

c = abc_kill(c, result);

8443

c = abc_kill(c, index);

8444

8445

c = var_block(c, state->vars);

8446

old_state();

8447

typedcode_t r;

8448

r.c = c;

8449

r.t = TYPE_XMLLIST;

8450

(yyval.node) = mkcodenode(r);

8451

}

8452

}

8453

break;

8454

8455

8456

8457

case 335:

8458

if(as3_pass==2) {

8459

8460

/* Line 1464 of skeleton.m4 */

8461

#line 3476 "parser.y"

8462

{(yyval.id)=(yyvsp[(1) - (1)].id);}

8463

}

8464

break;

8465

8466

8467

8468

case 336:

8469

if(as3_pass==2) {

8470

8471

/* Line 1464 of skeleton.m4 */

8472

#line 3477 "parser.y"

8473

{(yyval.id)="*";}

8474

}

8475

break;

8476

8477

8478

8479

case 337:

8480

if(as3_pass==2) {

8481

8482

/* Line 1464 of skeleton.m4 */

8483

#line 3478 "parser.y"

8484

{(yyval.id)=(char*)(yyvsp[(1) - (1)].id);}

8485

}

8486

break;

8487

8488

8489

8490

case 339:

8491

if(as3_pass==2) {

8492

8493

/* Line 1464 of skeleton.m4 */

8494

#line 3480 "parser.y"

8495

{(yyval.id)="*";}

8496

}

8497

break;

8498

8499

8500

8501

case 340:

8502

if(as3_pass==2) {

8503

8504

/* Line 1464 of skeleton.m4 */

8505

#line 3488 "parser.y"

8506

{

8507

typedcode_t v = node_read((yyvsp[(1) - (5)].node));

8508

typedcode_t w = node_read(resolve_identifier((yyvsp[(3) - (5)].id)));

8509

v.c = code_append(v.c, w.c);

8510

if(!TYPE_IS_NAMESPACE(w.t)) {

8511

as3_softwarning("%s might not be a namespace", (yyvsp[(3) - (5)].id));

8512

}

8513

v.c = converttype(v.c, w.t, TYPE_NAMESPACE);

8514

multiname_t m = {RTQNAME, 0, 0, (yyvsp[(5) - (5)].id)};

8515

v.c = abc_getproperty2(v.c, &m);

8516

if(TYPE_IS_XML(v.t)) {

8517

v.t = TYPE_XMLLIST;

8518

} else {

8519

v.c = abc_coerce_a(v.c);

8520

v.t = TYPE_ANY;

8521

}

8522

(yyval.node) = mkcodenode(v);

8523

}

8524

}

8525

break;

8526

8527

8528

8529

case 341:

8530

if(as3_pass==2) {

8531

8532

/* Line 1464 of skeleton.m4 */

8533

#line 3506 "parser.y"

8534

{

8535

typedcode_t v = node_read((yyvsp[(1) - (3)].node));

8536

multiname_t m = {MULTINAME, 0, &nopackage_namespace_set, (yyvsp[(3) - (3)].id)};

8537

v.c = abc_getdescendants2(v.c, &m);

8538

v.t = TYPE_XMLLIST;

8539

(yyval.node) = mkcodenode(v);

8540

}

8541

}

8542

break;

8543

8544

8545

8546

case 342:

8547

if(as3_pass==2) {

8548

8549

/* Line 1464 of skeleton.m4 */

8550

#line 3513 "parser.y"

8551

{

8552

typedcode_t v = node_read((yyvsp[(1) - (5)].node));

8553

typedcode_t w = node_read((yyvsp[(4) - (5)].node));

8554

multiname_t m = {MULTINAMEL, 0, &nopackage_namespace_set, 0};

8555

v.c = code_append(v.c, w.c);

8556

v.c = converttype(w.c, w.t, TYPE_STRING);

8557

v.c = abc_getproperty2(v.c, &m);

8558

v.t = TYPE_XMLLIST;

8559

(yyval.node) = mkcodenode(v);

8560

}

8561

}

8562

break;

8563

8564

8565

8566

case 343:

8567

if(as3_pass==2) {

8568

8569

/* Line 1464 of skeleton.m4 */

8570

#line 3524 "parser.y"

8571

{

8572

typedcode_t v = node_read((yyvsp[(1) - (4)].node));

8573

multiname_t m = {MULTINAMEA, 0, &nopackage_namespace_set, (yyvsp[(4) - (4)].id)};

8574

v.c = abc_getproperty2(v.c, &m);

8575

v.t = TYPE_STRING;

8576

(yyval.node) = mkcodenode(v);

8577

}

8578

}

8579

break;

8580

8581

8582

8583

case 344:

8584

if(as3_pass==2) {

8585

8586

/* Line 1464 of skeleton.m4 */

8587

#line 3531 "parser.y"

8588

{

8589

typedcode_t v = node_read((yyvsp[(1) - (4)].node));

8590

multiname_t m = {MULTINAMEA, 0, &nopackage_namespace_set, (yyvsp[(4) - (4)].id)};

8591

v.c = abc_getdescendants2(v.c, &m);

8592

v.t = TYPE_STRING;

8593

(yyval.node) = mkcodenode(v);

8594

}

8595

}

8596

break;

8597

8598

8599

8600

case 345:

8601

if(as3_pass==2) {

8602

8603

/* Line 1464 of skeleton.m4 */

8604

#line 3538 "parser.y"

8605

{

8606

typedcode_t v = node_read((yyvsp[(1) - (6)].node));

8607

typedcode_t w = node_read((yyvsp[(5) - (6)].node));

8608

multiname_t m = {MULTINAMELA, 0, &nopackage_namespace_set, 0};

8609

v.c = code_append(v.c, w.c);

8610

v.c = converttype(w.c, w.t, TYPE_STRING);

8611

v.c = abc_getproperty2(v.c, &m);

8612

v.t = TYPE_STRING;

8613

(yyval.node) = mkcodenode(v);

8614

}

8615

}

8616

break;

8617

8618

8619

8620

case 346:

8621

if(as3_pass==2) {

8622

8623

/* Line 1464 of skeleton.m4 */

8624

#line 3548 "parser.y"

8625

{

8626

typedcode_t v = node_read((yyvsp[(1) - (6)].node));

8627

typedcode_t w = node_read((yyvsp[(5) - (6)].node));

8628

multiname_t m = {MULTINAMELA, 0, &nopackage_namespace_set, 0};

8629

v.c = code_append(v.c, w.c);

8630

v.c = converttype(w.c, w.t, TYPE_STRING);

8631

v.c = abc_getdescendants2(v.c, &m);

8632

v.t = TYPE_STRING;

8633

(yyval.node) = mkcodenode(v);

8634

}

8635

}

8636

break;

8637

8638

8639

8640

case 347:

8641

if(as3_pass==2) {

8642

8643

/* Line 1464 of skeleton.m4 */

8644

#line 3559 "parser.y"

8645

{

8646

typedcode_t v1 = node_read((yyvsp[(1) - (3)].node));

8647

(yyval.value).c = v1.c;

8648

classinfo_t*t = v1.t;

8649

char is_static = 0;

8650

if(TYPE_IS_CLASS(t) && t->data) {

8651

t = t->data;

8652

is_static = 1;

8653

}

8654

if(TYPE_IS_XML(t)) {

8655

multiname_t m = {MULTINAME, 0, &nopackage_namespace_set, (yyvsp[(3) - (3)].id)};

8656

(yyval.value).c = abc_getproperty2((yyval.value).c, &m);

8657

(yyval.value).c = abc_coerce_a((yyval.value).c);

8658

(yyval.value).t = TYPE_XMLLIST;

8659

} else if(t) {

8660

if(t->subtype==INFOTYPE_UNRESOLVED) {

8661

syntaxerror("syntaxerror: trying to resolve property '%s' on incomplete object '%s'", (yyvsp[(3) - (3)].id), t->name);

8662

}

8663

memberinfo_t*f = findmember_nsset(t, (yyvsp[(3) - (3)].id), 1);

8664

char noslot = 0;

8665

if(f && !is_static != !(f->flags&FLAG_STATIC))

8666

noslot=1;

8667

if(f && f->slot && !noslot) {

8668

(yyval.value).c = abc_getslot((yyval.value).c, f->slot);

8669

} else {

8670

if(!f) {

8671

if(!TYPE_IS_XMLLIST(t)) {

8672

as3_softwarning("Access of undefined property '%s' in %s", (yyvsp[(3) - (3)].id), t->name);

8673

}

8674

}

8675

MEMBER_MULTINAME(m, f, (yyvsp[(3) - (3)].id));

8676

(yyval.value).c = abc_getproperty2((yyval.value).c, &m);

8677

}

8678

/* determine type */

8679

(yyval.value).t = slotinfo_gettype((slotinfo_t*)f);

8680

if(!(yyval.value).t)

8681

(yyval.value).c = abc_coerce_a((yyval.value).c);

8682

8683

} else if(v1.c && v1.c->opcode == OPCODE___PUSHPACKAGE__) {

8684

string_t*package = v1.c->data[0];

8685

char*package2 = concat3(package->str, ".", (yyvsp[(3) - (3)].id));

8686

8687

slotinfo_t*a = registry_find(package->str, (yyvsp[(3) - (3)].id));

8688

if(a) {

8689

(yyval.value) = push_class(a);

8690

} else if(dict_contains(state->import_toplevel_packages, package2) ||

8691

registry_ispackage(package2)) {

8692

(yyval.value).c = v1.c;

8693

(yyval.value).c->data[0] = string_new4(package2);

8694

(yyval.value).t = 0;

8695

} else {

8696

syntaxerror("couldn't resolve %s", package2);

8697

}

8698

} else {

8699

/* when resolving a property on an unknown type, we do know the

8700

name of the property (and don't seem to need the package), but

8701

we need to make avm2 try out all access modes */

8702

as3_softwarning("Resolving %s on unknown type", (yyvsp[(3) - (3)].id));

8703

multiname_t m = {MULTINAME, 0, &nopackage_namespace_set, (yyvsp[(3) - (3)].id)};

8704

(yyval.value).c = abc_getproperty2((yyval.value).c, &m);

8705

(yyval.value).c = abc_coerce_a((yyval.value).c);

8706

(yyval.value).t = TYPE_ANY;

8707

}

8708

}

8709

}

8710

break;

8711

8712

8713

8714

case 348:

8715

if(as3_pass==2) {

8716

8717

/* Line 1464 of skeleton.m4 */

8718

#line 3739 "parser.y"

8719

{

8720

PASS1

8721

/* Queue unresolved identifiers for checking against the parent

8722

function's variables.

8723

We consider everything which is not a local variable "unresolved".

8724

This encompasses class names, members of the surrounding class

8725

etc. which is *correct* because local variables of the parent function

8726

would shadow those.

8727

*/

8728

8729

if(!find_variable(state, (yyvsp[(1) - (1)].id))) {

8730

unknown_variable((yyvsp[(1) - (1)].id));

8731

/* let the compiler know that it might want to check the current directory/package

8732

for this identifier- maybe there's a file $1.as defining $1. */

8733

as3_schedule_class_noerror(state->package, (yyvsp[(1) - (1)].id));

8734

}

8735

8736

(yyval.node) = 0;

8737

PASS2

8738

8739

(yyval.node) = resolve_identifier((yyvsp[(1) - (1)].id));

8740

}

8741

}

8742

break;

8743

8744

8745

8746

case 349:

8747

if(as3_pass==2) {

8748

8749

/* Line 1464 of skeleton.m4 */

8750

#line 3773 "parser.y"

8751

{

8752

PASS12

8753

NEW(namespace_decl_t,n);

8754

n->name = (yyvsp[(2) - (2)].id);

8755

n->url = (yyvsp[(2) - (2)].id);

8756

(yyval.namespace_decl)=n;

8757

}

8758

}

8759

break;

8760

8761

8762

8763

case 350:

8764

if(as3_pass==2) {

8765

8766

/* Line 1464 of skeleton.m4 */

8767

#line 3780 "parser.y"

8768

{

8769

PASS12

8770

NEW(namespace_decl_t,n);

8771

n->name = (yyvsp[(2) - (4)].id);

8772

n->url = (yyvsp[(4) - (4)].id);

8773

(yyval.namespace_decl)=n;

8774

}

8775

}

8776

break;

8777

8778

8779

8780

case 351:

8781

if(as3_pass==2) {

8782

8783

/* Line 1464 of skeleton.m4 */

8784

#line 3787 "parser.y"

8785

{

8786

PASS12

8787

NEW(namespace_decl_t,n);

8788

n->name = (yyvsp[(2) - (4)].id);

8789

n->url = (yyvsp[(4) - (4)].str).str;

8790

(yyval.namespace_decl)=n;

8791

}

8792

}

8793

break;

8794

8795

8796

8797

case 352:

8798

if(as3_pass==2) {

8799

8800

/* Line 1464 of skeleton.m4 */

8801

#line 3794 "parser.y"

8802

{

8803

PASS12

8804

trie_put(active_namespaces, (yyvsp[(2) - (2)].namespace_decl)->name, (void*)(yyvsp[(2) - (2)].namespace_decl)->url);

8805

8806

namespace_t access = modifiers2access(&(yyvsp[(1) - (2)].flags));

8807

varinfo_t* var = varinfo_register_global(access.access, state->package, (yyvsp[(2) - (2)].namespace_decl)->name);

8808

var->type = TYPE_NAMESPACE;

8809

namespace_t ns;

8810

ns.access = ACCESS_NAMESPACE;

8811

ns.name = (yyvsp[(2) - (2)].namespace_decl)->url;

8812

var->value = constant_new_namespace(&ns);

8813

8814

if(as3_pass==2) {

8815

MULTINAME(m, TYPE_NAMESPACE);

8816

trait_t*t = add_abc_slot(&(yyvsp[(1) - (2)].flags), (yyvsp[(2) - (2)].namespace_decl)->name, 0, 0);

8817

t->value = var->value;

8818

t->type_name = multiname_clone(&m);

8819

}

8820

8821

(yyval.code)=0;

8822

}

8823

}

8824

break;

8825

8826

8827

8828

case 353:

8829

if(as3_pass==2) {

8830

8831

/* Line 1464 of skeleton.m4 */

8832

#line 3817 "parser.y"

8833

{

8834

as3_warning("default xml namespaces not supported yet");

8835

(yyval.code) = 0;

8836

}

8837

}

8838

break;

8839

8840

8841

8842

case 354:

8843

if(as3_pass==2) {

8844

8845

/* Line 1464 of skeleton.m4 */

8846

#line 3822 "parser.y"

8847

{

8848

PASS12

8849

const char*url = (yyvsp[(3) - (3)].classinfo)->name;

8850

8851

varinfo_t*s = (varinfo_t*)(yyvsp[(3) - (3)].classinfo);

8852

if(s->kind == INFOTYPE_UNRESOLVED) {

8853

s = (varinfo_t*)registry_resolve((slotinfo_t*)s);

8854

if(!s)

8855

syntaxerror("Couldn't resolve namespace %s", (yyvsp[(3) - (3)].classinfo)->name);

8856

}

8857

8858

if(!s || s->kind != INFOTYPE_VAR)

8859

syntaxerror("%s.%s is not a public namespace (%d)", (yyvsp[(3) - (3)].classinfo)->package, (yyvsp[(3) - (3)].classinfo)->name, s?s->kind:-1);

8860

if(!s->value || !NS_TYPE(s->value->type))

8861

syntaxerror("%s.%s is not a namespace", (yyvsp[(3) - (3)].classinfo)->package, (yyvsp[(3) - (3)].classinfo)->name);

8862

url = s->value->ns->name;

8863

8864

trie_put(active_namespaces, (yyvsp[(3) - (3)].classinfo)->name, (void*)url);

8865

add_active_url(url);

8866

(yyval.code)=0;

8867

}

8868

}

8869

break;

8870

8871

8872

8873

8874

/* Line 1464 of skeleton.m4 */

8875

#line 8876 "parser.tab.c"

8876

default: break;

8877

}

8878

YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);

8879

8880

YYPOPSTACK (yylen);

8881

yylen = 0;

8882

YY_STACK_PRINT (yyss, yyssp);

8883

8884

*++yyvsp = yyval;

8885

8886

/* Now `shift' the result of the reduction. Determine what state

8887

that goes to, based on the state we popped back to and the rule

8888

number reduced by. */

8889

8890

yyn = yyr1[yyn];

8891

8892

yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;

8893

if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)

8894

yystate = yytable[yystate];

8895

else

8896

yystate = yydefgoto[yyn - YYNTOKENS];

8897

8898

goto yynewstate;

8899

8900

8901

/*------------------------------------.

8902

| yyerrlab -- here on detecting error |

8903

`------------------------------------*/

8904

yyerrlab:

8905

/* If not already recovering from an error, report this error. */

8906

if (!yyerrstatus)

8907

{

8908

++yynerrs;

8909

#if ! YYERROR_VERBOSE

8910

yyerror (YY_("syntax error"));

8911

#else

8912

{

8913

YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);

8914

if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)

8915

{

8916

YYSIZE_T yyalloc = 2 * yysize;

8917

if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))

8918

yyalloc = YYSTACK_ALLOC_MAXIMUM;

8919

if (yymsg != yymsgbuf)

8920

YYSTACK_FREE (yymsg);

8921

yymsg = (char *) YYSTACK_ALLOC (yyalloc);

8922

if (yymsg)

8923

yymsg_alloc = yyalloc;

8924

else

8925

{

8926

yymsg = yymsgbuf;

8927

yymsg_alloc = sizeof yymsgbuf;

8928

}

8929

}

8930

8931

if (0 < yysize && yysize <= yymsg_alloc)

8932

{

8933

(void) yysyntax_error (yymsg, yystate, yychar);

8934

yyerror (yymsg);

8935

}

8936

else

8937

{

8938

yyerror (YY_("syntax error"));

8939

if (yysize != 0)

8940

goto yyexhaustedlab;

8941

}

8942

}

8943

#endif

8944

}

8945

8946

8947

8948

if (yyerrstatus == 3)

8949

{

8950

/* If just tried and failed to reuse lookahead token after an

8951

error, discard it. */

8952

8953

if (yychar <= YYEOF)

8954

{

8955

/* Return failure if at end of input. */

8956

if (yychar == YYEOF)

8957

YYABORT;

8958

}

8959

else

8960

{

8961

yydestruct ("Error: discarding",

8962

yytoken, &yylval);

8963

yychar = YYEMPTY;

8964

}

8965

}

8966

8967

/* Else will try to reuse lookahead token after shifting the error

8968

token. */

8969

goto yyerrlab1;

8970

8971

8972

/*---------------------------------------------------.

8973

| yyerrorlab -- error raised explicitly by YYERROR. |

8974

`---------------------------------------------------*/

8975

yyerrorlab:

8976

8977

/* Pacify compilers like GCC when the user code never invokes

8978

YYERROR and the label yyerrorlab therefore never appears in user

8979

code. */

8980

if (/*CONSTCOND*/ 0)

8981

goto yyerrorlab;

8982

8983

/* Do not reclaim the symbols of the rule which action triggered

8984

this YYERROR. */

8985

YYPOPSTACK (yylen);

8986

yylen = 0;

8987

YY_STACK_PRINT (yyss, yyssp);

8988

yystate = *yyssp;

8989

goto yyerrlab1;

8990

8991

8992

/*-------------------------------------------------------------.

8993

| yyerrlab1 -- common code for both syntax error and YYERROR. |

8994

`-------------------------------------------------------------*/

8995

yyerrlab1:

8996

yyerrstatus = 3; /* Each real token shifted decrements this. */

8997

8998

for (;;)

8999

{

9000

yyn = yypact[yystate];

9001

if (yyn != YYPACT_NINF)

9002

{

9003

yyn += YYTERROR;

9004

if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)

9005

{

9006

yyn = yytable[yyn];

9007

if (0 < yyn)

9008

break;

9009

}

9010

}

9011

9012

/* Pop the current state because it cannot handle the error token. */

9013

if (yyssp == yyss)

9014

YYABORT;

9015

9016

9017

yydestruct ("Error: popping",

9018

yystos[yystate], yyvsp);

9019

YYPOPSTACK (1);

9020

yystate = *yyssp;

9021

YY_STACK_PRINT (yyss, yyssp);

9022

}

9023

9024

*++yyvsp = yylval;

9025

9026

9027

/* Shift the error token. */

9028

YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);

9029

9030

yystate = yyn;

9031

goto yynewstate;

9032

9033

9034

/*-------------------------------------.

9035

| yyacceptlab -- YYACCEPT comes here. |

9036

`-------------------------------------*/

9037

yyacceptlab:

9038

yyresult = 0;

9039

goto yyreturn;

9040

9041

/*-----------------------------------.

9042

| yyabortlab -- YYABORT comes here. |

9043

`-----------------------------------*/

9044

yyabortlab:

9045

yyresult = 1;

9046

goto yyreturn;

9047

9048

#if !defined(yyoverflow) || YYERROR_VERBOSE

9049

/*-------------------------------------------------.

9050

| yyexhaustedlab -- memory exhaustion comes here. |

9051

`-------------------------------------------------*/

9052

yyexhaustedlab:

9053

yyerror (YY_("memory exhausted"));

9054

yyresult = 2;

9055

/* Fall through. */

9056

#endif

9057

9058

yyreturn:

9059

if (yychar != YYEMPTY)

9060

yydestruct ("Cleanup: discarding lookahead",

9061

yytoken, &yylval);

9062

/* Do not reclaim the symbols of the rule which action triggered

9063

this YYABORT or YYACCEPT. */

9064

YYPOPSTACK (yylen);

9065

YY_STACK_PRINT (yyss, yyssp);

9066

while (yyssp != yyss)

9067

{

9068

yydestruct ("Cleanup: popping",

9069

yystos[*yyssp], yyvsp);

9070

YYPOPSTACK (1);

9071

}

9072

#ifndef yyoverflow

9073

if (yyss != yyssa)

9074

YYSTACK_FREE (yyss);

9075

#endif

9076

#if YYERROR_VERBOSE

9077

if (yymsg != yymsgbuf)

9078

YYSTACK_FREE (yymsg);

9079

#endif

9080

/* Make sure YYID is used. */

9081

return YYID (yyresult);

9082

}

9083

9084

9085