~ubuntu-branches/ubuntu/trusty/sblim-sfcb/trusty-proposed : revision 6

1

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

2

3

/* Skeleton parser for Yacc-like parsing with Bison,

4

1

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

2

3

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

4

5

6

Free Software Foundation, Inc.

5

7

6

8

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

7

9

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

18

20

Foundation, Inc., 51 Franklin Street, Fifth Floor,

19

21

Boston, MA 02110-1301, USA. */

20

22

21

/* As a special exception, when this file is copied by Bison into a

22

Bison output file, you may use that output file without restriction.

23

This special exception was added by the Free Software Foundation

24

in version 1.24 of Bison. */

25

26

/* Written by Richard Stallman by simplifying the original so called

27

``semantic'' parser. */

23

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

24

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

25

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

26

parser generator using the skeleton or a modified version thereof

27

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

28

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

29

special exception, which will cause the skeleton and the resulting

30

Bison output files to be licensed under the GNU General Public

31

License without this special exception.

32

33

This special exception was added by the Free Software Foundation in

34

version 2.2 of Bison. */

35

36

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

37

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

28

38

29

39

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

30

40

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

37

47

#define YYBISON 1

38

48

39

49

/* Bison version. */

40

#define YYBISON_VERSION "2.1"

50

#define YYBISON_VERSION "2.3"

41

51

42

52

/* Skeleton name. */

43

53

#define YYSKELETON_NAME "yacc.c"

137

147

extern class_chain * cls_chain_current;

138

148

extern class_chain * inst_chain_current;

139

149

extern qual_chain * qual_chain_current;

140

150

extern int g_instmig;

141

151

142

152

143

153

/* Enabling traces. */

158

168

# define YYTOKEN_TABLE 0

159

169

#endif

160

170

161

#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)

171

#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED

172

typedef union YYSTYPE

162

173

#line 42 "mofc.y"

163

typedef union YYSTYPE {

174

{

164

175

char * lval_id;

165

176

type_type lval_type;

166

177

char * lval_literal;

172

183

param_chain * lval_params;

173

184

int lval_int;

174

185

qual_quals lval_qual_quals;

175

} YYSTYPE;

176

/* Line 196 of yacc.c. */

177

#line 178 "mofc.c"

186

}

187

/* Line 187 of yacc.c. */

188

#line 189 "mofc.c"

189

YYSTYPE;

178

190

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

179

191

# define YYSTYPE_IS_DECLARED 1

180

192

# define YYSTYPE_IS_TRIVIAL 1

185

197

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

186

198

187

199

188

/* Line 219 of yacc.c. */

189

#line 190 "mofc.c"

190

191

#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)

192

# define YYSIZE_T __SIZE_TYPE__

193

#endif

194

#if ! defined (YYSIZE_T) && defined (size_t)

195

# define YYSIZE_T size_t

196

#endif

197

#if ! defined (YYSIZE_T) && (defined (__STDC__) || defined (__cplusplus))

198

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

199

# define YYSIZE_T size_t

200

#endif

201

#if ! defined (YYSIZE_T)

202

# define YYSIZE_T unsigned int

203

#endif

200

/* Line 216 of yacc.c. */

201

#line 202 "mofc.c"

202

203

#ifdef short

204

# undef short

205

#endif

206

207

#ifdef YYTYPE_UINT8

208

typedef YYTYPE_UINT8 yytype_uint8;

209

#else

210

typedef unsigned char yytype_uint8;

211

#endif

212

213

#ifdef YYTYPE_INT8

214

typedef YYTYPE_INT8 yytype_int8;

215

#elif (defined __STDC__ || defined __C99__FUNC__ \

216

|| defined __cplusplus || defined _MSC_VER)

217

typedef signed char yytype_int8;

218

#else

219

typedef short int yytype_int8;

220

#endif

221

222

#ifdef YYTYPE_UINT16

223

typedef YYTYPE_UINT16 yytype_uint16;

224

#else

225

typedef unsigned short int yytype_uint16;

226

#endif

227

228

#ifdef YYTYPE_INT16

229

typedef YYTYPE_INT16 yytype_int16;

230

#else

231

typedef short int yytype_int16;

232

#endif

233

234

#ifndef YYSIZE_T

235

# ifdef __SIZE_TYPE__

236

# define YYSIZE_T __SIZE_TYPE__

237

# elif defined size_t

238

# define YYSIZE_T size_t

239

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

240

|| defined __cplusplus || defined _MSC_VER)

241

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

242

# define YYSIZE_T size_t

243

# else

244

# define YYSIZE_T unsigned int

245

# endif

246

#endif

247

248

#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)

204

249

205

250

#ifndef YY_

206

251

# if YYENABLE_NLS

214

259

# endif

215

260

#endif

216

261

217

#if ! defined (yyoverflow) || YYERROR_VERBOSE

262

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

263

#if ! defined lint || defined __GNUC__

264

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

265

#else

266

# define YYUSE(e) /* empty */

267

#endif

268

269

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

270

#ifndef lint

271

# define YYID(n) (n)

272

#else

273

#if (defined __STDC__ || defined __C99__FUNC__ \

274

|| defined __cplusplus || defined _MSC_VER)

275

static int

276

YYID (int i)

277

#else

278

static int

279

YYID (i)

280

int i;

281

#endif

282

{

283

return i;

284

}

285

#endif

286

287

#if ! defined yyoverflow || YYERROR_VERBOSE

218

288

219

289

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

220

290

222

292

# if YYSTACK_USE_ALLOCA

223

293

# ifdef __GNUC__

224

294

# define YYSTACK_ALLOC __builtin_alloca

295

# elif defined __BUILTIN_VA_ARG_INCR

296

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

297

# elif defined _AIX

298

# define YYSTACK_ALLOC __alloca

299

# elif defined _MSC_VER

300

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

301

# define alloca _alloca

225

302

# else

226

303

# define YYSTACK_ALLOC alloca

227

# if defined (__STDC__) || defined (__cplusplus)

304

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

305

|| defined __cplusplus || defined _MSC_VER)

228

306

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

229

# define YYINCLUDED_STDLIB_H

307

# ifndef _STDLIB_H

308

# define _STDLIB_H 1

309

# endif

230

310

# endif

231

311

# endif

232

312

# endif

233

313

# endif

234

314

235

315

# ifdef YYSTACK_ALLOC

236

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

237

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

316

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

317

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

238

318

# ifndef YYSTACK_ALLOC_MAXIMUM

239

319

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

240

320

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

241

321

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

242

322

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

243

# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2005 */

323

# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */

244

324

# endif

245

325

# else

246

326

# define YYSTACK_ALLOC YYMALLOC

247

327

# define YYSTACK_FREE YYFREE

248

328

# ifndef YYSTACK_ALLOC_MAXIMUM

249

# define YYSTACK_ALLOC_MAXIMUM ((YYSIZE_T) -1)

329

# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM

250

330

# endif

251

# ifdef __cplusplus

252

extern "C" {

331

# if (defined __cplusplus && ! defined _STDLIB_H \

332

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

333

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

334

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

335

# ifndef _STDLIB_H

336

# define _STDLIB_H 1

337

# endif

253

338

# endif

254

339

# ifndef YYMALLOC

255

340

# define YYMALLOC malloc

256

# if (! defined (malloc) && ! defined (YYINCLUDED_STDLIB_H) \

257

&& (defined (__STDC__) || defined (__cplusplus)))

341

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

342

|| defined __cplusplus || defined _MSC_VER)

258

343

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

259

344

# endif

260

345

# endif

261

346

# ifndef YYFREE

262

347

# define YYFREE free

263

# if (! defined (free) && ! defined (YYINCLUDED_STDLIB_H) \

264

&& (defined (__STDC__) || defined (__cplusplus)))

348

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

349

|| defined __cplusplus || defined _MSC_VER)

265

350

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

266

351

# endif

267

352

# endif

268

# ifdef __cplusplus

269

}

270

# endif

271

353

# endif

272

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

273

274

275

#if (! defined (yyoverflow) \

276

&& (! defined (__cplusplus) \

277

|| (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))

354

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

355

356

357

#if (! defined yyoverflow \

358

&& (! defined __cplusplus \

359

|| (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))

278

360

279

361

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

280

362

union yyalloc

281

363

{

282

short int yyss;

364

yytype_int16 yyss;

283

365

YYSTYPE yyvs;

284

366

};

285

367

289

371

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

290

372

N elements. */

291

373

# define YYSTACK_BYTES(N) \

292

((N) * (sizeof (short int) + sizeof (YYSTYPE)) \

374

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

293

375

+ YYSTACK_GAP_MAXIMUM)

294

376

295

377

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

296

378

not overlap. */

297

379

# ifndef YYCOPY

298

# if defined (__GNUC__) && 1 < __GNUC__

380

# if defined __GNUC__ && 1 < __GNUC__

299

381

# define YYCOPY(To, From, Count) \

300

382

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

301

383

# else

306

388

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

307

389

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

308

390

} \

309

while (0)

391

while (YYID (0))

310

392

# endif

311

393

# endif

312

394

324

406

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

325

407

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

326

408

} \

327

while (0)

328

329

#endif

330

331

#if defined (__STDC__) || defined (__cplusplus)

332

typedef signed char yysigned_char;

333

#else

334

typedef short int yysigned_char;

335

#endif

336

337

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

409

while (YYID (0))

410

411

#endif

412

413

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

338

414

#define YYFINAL 14

339

415

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

340

416

#define YYLAST 142

341

417

342

/* YYNTOKENS -- Number of terminals. */

418

/* YYNTOKENS -- Number of terminals. */

343

419

#define YYNTOKENS 42

344

/* YYNNTS -- Number of nonterminals. */

420

/* YYNNTS -- Number of nonterminals. */

345

421

#define YYNNTS 36

346

/* YYNRULES -- Number of rules. */

422

/* YYNRULES -- Number of rules. */

347

423

#define YYNRULES 86

348

/* YYNRULES -- Number of states. */

424

/* YYNRULES -- Number of states. */

349

425

#define YYNSTATES 140

350

426

351

427

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

356

432

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

357

433

358

434

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

359

static const unsigned char yytranslate[] =

435

static const yytype_uint8 yytranslate[] =

360

436

{

361

437

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

362

438

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

392

468

#if YYDEBUG

393

469

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

394

470

YYRHS. */

395

static const unsigned char yyprhs[] =

471

static const yytype_uint8 yyprhs[] =

396

472

{

397

473

0, 0, 3, 4, 6, 8, 11, 13, 15, 17,

398

474

26, 27, 33, 39, 50, 52, 56, 58, 62, 64,

405

481

227, 228, 231, 232, 234, 236, 239

406

482

};

407

483

408

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

409

static const yysigned_char yyrhs[] =

484

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

485

static const yytype_int8 yyrhs[] =

410

486

{

411

487

43, 0, -1, -1, 44, -1, 45, -1, 44, 45,

412

488

-1, 46, -1, 51, -1, 52, -1, 28, 3, 32,

436

512

};

437

513

438

514

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

439

static const unsigned short int yyrline[] =

515

static const yytype_uint16 yyrline[] =

440

516

{

441

517

0, 126, 126, 127, 135, 136, 139, 143, 147, 157,

442

518

167, 171, 176, 181, 188, 192, 198, 202, 208, 209,

452

528

453

529

#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE

454

530

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

455

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

531

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

456

532

static const char *const yytname[] =

457

533

{

458

534

"$end", "error", "$undefined", "Identifier", "BaseTypeUINT8",

481

557

# ifdef YYPRINT

482

558

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

483

559

token YYLEX-NUM. */

484

static const unsigned short int yytoknum[] =

560

static const yytype_uint16 yytoknum[] =

485

561

{

486

562

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

487

563

265, 266, 267, 268, 269, 270, 271, 272, 273, 274,

492

568

# endif

493

569

494

570

/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */

495

static const unsigned char yyr1[] =

571

static const yytype_uint8 yyr1[] =

496

572

{

497

573

0, 42, 43, 43, 44, 44, 45, 45, 45, 46,

498

574

47, 47, 47, 47, 48, 48, 49, 49, 50, 50,

506

582

};

507

583

508

584

/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */

509

static const unsigned char yyr2[] =

585

static const yytype_uint8 yyr2[] =

510

586

{

511

587

0, 2, 0, 1, 1, 2, 1, 1, 1, 8,

512

588

0, 5, 5, 10, 1, 3, 1, 3, 1, 1,

522

598

/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state

523

599

STATE-NUM when YYTABLE doesn't specify something else to do. Zero

524

600

means the default is an error. */

525

static const unsigned char yydefact[] =

601

static const yytype_uint8 yydefact[] =

526

602

{

527

603

22, 0, 0, 0, 22, 4, 6, 7, 8, 0,

528

604

0, 27, 0, 24, 1, 5, 0, 0, 0, 60,

540

616

22, 64, 40, 0, 57, 66, 0, 67, 0, 13

541

617

};

542

618

543

/* YYDEFGOTO[NTERM-NUM]. */

544

static const yysigned_char yydefgoto[] =

619

/* YYDEFGOTO[NTERM-NUM]. */

620

static const yytype_int8 yydefgoto[] =

545

621

{

546

622

-1, 3, 4, 5, 6, 83, 113, 111, 112, 7,

547

623

8, 9, 12, 13, 21, 50, 51, 55, 73, 74,

552

628

/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing

553

629

STATE-NUM. */

554

630

#define YYPACT_NINF -98

555

static const yysigned_char yypact[] =

631

static const yytype_int8 yypact[] =

556

632

{

557

633

3, 15, 22, 29, 4, -98, -98, -98, -98, 34,

558

634

33, -9, -4, -98, -98, -98, 95, 72, 78, 35,

571

647

};

572

648

573

649

/* YYPGOTO[NTERM-NUM]. */

574

static const yysigned_char yypgoto[] =

650

static const yytype_int8 yypgoto[] =

575

651

{

576

652

-98, -98, -98, 127, -98, -98, -98, -12, -70, -98,

577

653

-98, -64, -98, 110, -98, 56, -98, -98, -98, -98,

584

660

number is the opposite. If zero, do what YYDEFACT says.

585

661

If YYTABLE_NINF, syntax error. */

586

662

#define YYTABLE_NINF -38

587

static const short int yytable[] =

663

static const yytype_int16 yytable[] =

588

664

{

589

665

72, 106, 48, -2, -3, 109, 100, 117, 121, 118,

590

666

72, 2, 41, 42, 43, 44, 45, 46, 10, 41,

603

679

40, 135, 102

604

680

};

605

681

606

static const unsigned char yycheck[] =

682

static const yytype_uint8 yycheck[] =

607

683

{

608

684

64, 98, 19, 0, 0, 3, 89, 34, 36, 36,

609

685

74, 39, 18, 19, 20, 21, 22, 23, 3, 18,

624

700

625

701

/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing

626

702

symbol of state STATE-NUM. */

627

static const unsigned char yystos[] =

703

static const yytype_uint8 yystos[] =

628

704

{

629

705

0, 28, 39, 43, 44, 45, 46, 51, 52, 53,

630

706

3, 3, 54, 55, 0, 45, 25, 26, 32, 35,

667

743

yychar = (Token); \

668

744

yylval = (Value); \

669

745

yytoken = YYTRANSLATE (yychar); \

670

YYPOPSTACK; \

746

YYPOPSTACK (1); \

671

747

goto yybackup; \

672

748

} \

673

749

else \

675

751

yyerror (YY_("syntax error: cannot back up")); \

676

752

YYERROR; \

677

753

} \

678

while (0)

754

while (YYID (0))

679

755

680

756

681

757

#define YYTERROR 1

690

766

#ifndef YYLLOC_DEFAULT

691

767

# define YYLLOC_DEFAULT(Current, Rhs, N) \

692

768

do \

693

if (N) \

769

if (YYID (N)) \

694

770

{ \

695

771

(Current).first_line = YYRHSLOC (Rhs, 1).first_line; \

696

772

(Current).first_column = YYRHSLOC (Rhs, 1).first_column; \

704

780

(Current).first_column = (Current).last_column = \

705

781

YYRHSLOC (Rhs, 0).last_column; \

706

782

} \

707

while (0)

783

while (YYID (0))

708

784

#endif

709

785

710

786

716

792

# if YYLTYPE_IS_TRIVIAL

717

793

# define YY_LOCATION_PRINT(File, Loc) \

718

794

fprintf (File, "%d.%d-%d.%d", \

719

(Loc).first_line, (Loc).first_column, \

720

(Loc).last_line, (Loc).last_column)

795

(Loc).first_line, (Loc).first_column, \

796

(Loc).last_line, (Loc).last_column)

721

797

# else

722

798

# define YY_LOCATION_PRINT(File, Loc) ((void) 0)

723

799

# endif

744

820

do { \

745

821

if (yydebug) \

746

822

YYFPRINTF Args; \

747

} while (0)

748

749

# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \

750

do { \

751

if (yydebug) \

752

{ \

753

YYFPRINTF (stderr, "%s ", Title); \

754

yysymprint (stderr, \

755

Type, Value); \

756

YYFPRINTF (stderr, "\n"); \

757

} \

758

} while (0)

823

} while (YYID (0))

824

825

# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \

826

do { \

827

if (yydebug) \

828

{ \

829

YYFPRINTF (stderr, "%s ", Title); \

830

yy_symbol_print (stderr, \

831

Type, Value); \

832

YYFPRINTF (stderr, "\n"); \

833

} \

834

} while (YYID (0))

835

836

837

/*--------------------------------.

838

| Print this symbol on YYOUTPUT. |

839

`--------------------------------*/

840

841

/*ARGSUSED*/

842

#if (defined __STDC__ || defined __C99__FUNC__ \

843

|| defined __cplusplus || defined _MSC_VER)

844

static void

845

yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)

846

#else

847

static void

848

yy_symbol_value_print (yyoutput, yytype, yyvaluep)

849

FILE *yyoutput;

850

int yytype;

851

YYSTYPE const * const yyvaluep;

852

#endif

853

{

854

if (!yyvaluep)

855

return;

856

# ifdef YYPRINT

857

if (yytype < YYNTOKENS)

858

YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);

859

# else

860

YYUSE (yyoutput);

861

# endif

862

switch (yytype)

863

{

864

default:

865

break;

866

}

867

}

868

869

870

/*--------------------------------.

871

| Print this symbol on YYOUTPUT. |

872

`--------------------------------*/

873

874

#if (defined __STDC__ || defined __C99__FUNC__ \

875

|| defined __cplusplus || defined _MSC_VER)

876

static void

877

yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)

878

#else

879

static void

880

yy_symbol_print (yyoutput, yytype, yyvaluep)

881

FILE *yyoutput;

882

int yytype;

883

YYSTYPE const * const yyvaluep;

884

#endif

885

{

886

if (yytype < YYNTOKENS)

887

YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);

888

else

889

YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);

890

891

yy_symbol_value_print (yyoutput, yytype, yyvaluep);

892

YYFPRINTF (yyoutput, ")");

893

}

759

894

760

895

/*------------------------------------------------------------------.

761

896

| yy_stack_print -- Print the state stack from its BOTTOM up to its |

762

897

| TOP (included). |

763

898

`------------------------------------------------------------------*/

764

899

765

#if defined (__STDC__) || defined (__cplusplus)

900

#if (defined __STDC__ || defined __C99__FUNC__ \

901

|| defined __cplusplus || defined _MSC_VER)

766

902

static void

767

yy_stack_print (short int *bottom, short int *top)

903

yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)

768

904

#else

769

905

static void

770

906

yy_stack_print (bottom, top)

771

short int *bottom;

772

short int *top;

907

yytype_int16 *bottom;

908

yytype_int16 *top;

773

909

#endif

774

910

{

775

911

YYFPRINTF (stderr, "Stack now");

776

for (/* Nothing. */; bottom <= top; ++bottom)

912

for (; bottom <= top; ++bottom)

777

913

YYFPRINTF (stderr, " %d", *bottom);

778

914

YYFPRINTF (stderr, "\n");

779

915

}

782

918

do { \

783

919

if (yydebug) \

784

920

yy_stack_print ((Bottom), (Top)); \

785

} while (0)

921

} while (YYID (0))

786

922

787

923

788

924

/*------------------------------------------------.

789

925

| Report that the YYRULE is going to be reduced. |

790

926

`------------------------------------------------*/

791

927

792

#if defined (__STDC__) || defined (__cplusplus)

928

#if (defined __STDC__ || defined __C99__FUNC__ \

929

|| defined __cplusplus || defined _MSC_VER)

793

930

static void

794

yy_reduce_print (int yyrule)

931

yy_reduce_print (YYSTYPE *yyvsp, int yyrule)

795

932

#else

796

933

static void

797

yy_reduce_print (yyrule)

934

yy_reduce_print (yyvsp, yyrule)

935

YYSTYPE *yyvsp;

798

936

int yyrule;

799

937

#endif

800

938

{

939

int yynrhs = yyr2[yyrule];

801

940

int yyi;

802

941

unsigned long int yylno = yyrline[yyrule];

803

YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu), ",

804

yyrule - 1, yylno);

805

/* Print the symbols being reduced, and their result. */

806

for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)

807

YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);

808

YYFPRINTF (stderr, "-> %s\n", yytname[yyr1[yyrule]]);

942

YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",

943

yyrule - 1, yylno);

944

/* The symbols being reduced. */

945

for (yyi = 0; yyi < yynrhs; yyi++)

946

{

947

fprintf (stderr, " $%d = ", yyi + 1);

948

yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],

949

&(yyvsp[(yyi + 1) - (yynrhs)])

950

);

951

fprintf (stderr, "\n");

952

}

809

953

}

810

954

811

955

# define YY_REDUCE_PRINT(Rule) \

812

956

do { \

813

957

if (yydebug) \

814

yy_reduce_print (Rule); \

815

} while (0)

958

yy_reduce_print (yyvsp, Rule); \

959

} while (YYID (0))

816

960

817

961

/* Nonzero means print parse trace. It is left uninitialized so that

818

962

multiple parsers can coexist. */

846

990

#if YYERROR_VERBOSE

847

991

848

992

# ifndef yystrlen

849

# if defined (__GLIBC__) && defined (_STRING_H)

993

# if defined __GLIBC__ && defined _STRING_H

850

994

# define yystrlen strlen

851

995

# else

852

996

/* Return the length of YYSTR. */

997

#if (defined __STDC__ || defined __C99__FUNC__ \

998

|| defined __cplusplus || defined _MSC_VER)

853

999

static YYSIZE_T

854

# if defined (__STDC__) || defined (__cplusplus)

855

1000

yystrlen (const char *yystr)

856

# else

1001

#else

1002

static YYSIZE_T

857

1003

yystrlen (yystr)

858

const char *yystr;

859

# endif

1004

const char *yystr;

1005

#endif

860

1006

{

861

const char *yys = yystr;

862

863

while (*yys++ != '\0')

1007

YYSIZE_T yylen;

1008

for (yylen = 0; yystr[yylen]; yylen++)

864

1009

continue;

865

866

return yys - yystr - 1;

1010

return yylen;

867

1011

}

868

1012

# endif

869

1013

# endif

870

1014

871

1015

# ifndef yystpcpy

872

# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)

1016

# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE

873

1017

# define yystpcpy stpcpy

874

1018

# else

875

1019

/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in

876

1020

YYDEST. */

1021

#if (defined __STDC__ || defined __C99__FUNC__ \

1022

|| defined __cplusplus || defined _MSC_VER)

877

1023

static char *

878

# if defined (__STDC__) || defined (__cplusplus)

879

1024

yystpcpy (char *yydest, const char *yysrc)

880

# else

1025

#else

1026

static char *

881

1027

yystpcpy (yydest, yysrc)

882

char *yydest;

883

const char *yysrc;

884

# endif

1028

char *yydest;

1029

const char *yysrc;

1030

#endif

885

1031

{

886

1032

char *yyd = yydest;

887

1033

const char *yys = yysrc;

907

1053

{

908

1054

if (*yystr == '"')

909

1055

{

910

size_t yyn = 0;

1056

YYSIZE_T yyn = 0;

911

1057

char const *yyp = yystr;

912

1058

913

1059

for (;;)

942

1088

}

943

1089

# endif

944

1090

945

#endif /* YYERROR_VERBOSE */

946

947

948

949

#if YYDEBUG

950

/*--------------------------------.

951

| Print this symbol on YYOUTPUT. |

952

`--------------------------------*/

953

954

#if defined (__STDC__) || defined (__cplusplus)

955

static void

956

yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)

957

#else

958

static void

959

yysymprint (yyoutput, yytype, yyvaluep)

960

FILE *yyoutput;

961

int yytype;

962

YYSTYPE *yyvaluep;

963

#endif

1091

/* Copy into YYRESULT an error message about the unexpected token

1092

YYCHAR while in state YYSTATE. Return the number of bytes copied,

1093

including the terminating null byte. If YYRESULT is null, do not

1094

copy anything; just return the number of bytes that would be

1095

copied. As a special case, return 0 if an ordinary "syntax error"

1096

message will do. Return YYSIZE_MAXIMUM if overflow occurs during

1097

size calculation. */

1098

static YYSIZE_T

1099

yysyntax_error (char *yyresult, int yystate, int yychar)

964

1100

{

965

/* Pacify ``unused variable'' warnings. */

966

(void) yyvaluep;

1101

int yyn = yypact[yystate];

967

1102

968

if (yytype < YYNTOKENS)

969

YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);

1103

if (! (YYPACT_NINF < yyn && yyn <= YYLAST))

1104

return 0;

970

1105

else

971

YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);

972

973

974

# ifdef YYPRINT

975

if (yytype < YYNTOKENS)

976

YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);

977

# endif

978

switch (yytype)

979

1106

{

980

default:

981

break;

1107

int yytype = YYTRANSLATE (yychar);

1108

YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);

1109

YYSIZE_T yysize = yysize0;

1110

YYSIZE_T yysize1;

1111

int yysize_overflow = 0;

1112

enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };

1113

char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];

1114

int yyx;

1115

1116

# if 0

1117

/* This is so xgettext sees the translatable formats that are

1118

constructed on the fly. */

1119

YY_("syntax error, unexpected %s");

1120

YY_("syntax error, unexpected %s, expecting %s");

1121

YY_("syntax error, unexpected %s, expecting %s or %s");

1122

YY_("syntax error, unexpected %s, expecting %s or %s or %s");

1123

YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");

1124

# endif

1125

char *yyfmt;

1126

char const *yyf;

1127

static char const yyunexpected[] = "syntax error, unexpected %s";

1128

static char const yyexpecting[] = ", expecting %s";

1129

static char const yyor[] = " or %s";

1130

char yyformat[sizeof yyunexpected

1131

+ sizeof yyexpecting - 1

1132

+ ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)

1133

* (sizeof yyor - 1))];

1134

char const *yyprefix = yyexpecting;

1135

1136

/* Start YYX at -YYN if negative to avoid negative indexes in

1137

YYCHECK. */

1138

int yyxbegin = yyn < 0 ? -yyn : 0;

1139

1140

/* Stay within bounds of both yycheck and yytname. */

1141

int yychecklim = YYLAST - yyn + 1;

1142

int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;

1143

int yycount = 1;

1144

1145

yyarg[0] = yytname[yytype];

1146

yyfmt = yystpcpy (yyformat, yyunexpected);

1147

1148

for (yyx = yyxbegin; yyx < yyxend; ++yyx)

1149

if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)

1150

{

1151

if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)

1152

{

1153

yycount = 1;

1154

yysize = yysize0;

1155

yyformat[sizeof yyunexpected - 1] = '\0';

1156

break;

1157

}

1158

yyarg[yycount++] = yytname[yyx];

1159

yysize1 = yysize + yytnamerr (0, yytname[yyx]);

1160

yysize_overflow |= (yysize1 < yysize);

1161

yysize = yysize1;

1162

yyfmt = yystpcpy (yyfmt, yyprefix);

1163

yyprefix = yyor;

1164

}

1165

1166

yyf = YY_(yyformat);

1167

yysize1 = yysize + yystrlen (yyf);

1168

yysize_overflow |= (yysize1 < yysize);

1169

yysize = yysize1;

1170

1171

if (yysize_overflow)

1172

return YYSIZE_MAXIMUM;

1173

1174

if (yyresult)

1175

{

1176

/* Avoid sprintf, as that infringes on the user's name space.

1177

Don't have undefined behavior even if the translation

1178

produced a string with the wrong number of "%s"s. */

1179

char *yyp = yyresult;

1180

int yyi = 0;

1181

while ((*yyp = *yyf) != '\0')

1182

{

1183

if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)

1184

{

1185

yyp += yytnamerr (yyp, yyarg[yyi++]);

1186

yyf += 2;

1187

}

1188

else

1189

{

1190

yyp++;

1191

yyf++;

1192

}

1193

}

1194

}

1195

return yysize;

982

1196

}

983

YYFPRINTF (yyoutput, ")");

984

1197

}

1198

#endif /* YYERROR_VERBOSE */

1199

985

1200

986

#endif /* ! YYDEBUG */

987

1201

/*-----------------------------------------------.

988

1202

| Release the memory associated to this symbol. |

989

1203

`-----------------------------------------------*/

990

1204

991

#if defined (__STDC__) || defined (__cplusplus)

1205

/*ARGSUSED*/

1206

#if (defined __STDC__ || defined __C99__FUNC__ \

1207

|| defined __cplusplus || defined _MSC_VER)

992

1208

static void

993

1209

yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)

994

1210

#else

999

1215

YYSTYPE *yyvaluep;

1000

1216

#endif

1001

1217

{

1002

/* Pacify ``unused variable'' warnings. */

1003

(void) yyvaluep;

1218

YYUSE (yyvaluep);

1004

1219

1005

1220

if (!yymsg)

1006

1221

yymsg = "Deleting";

1010

1225

{

1011

1226

1012

1227

default:

1013

break;

1228

break;

1014

1229

}

1015

1230

}

1016

1231

1018

1233

/* Prevent warnings from -Wmissing-prototypes. */

1019

1234

1020

1235

#ifdef YYPARSE_PARAM

1021

# if defined (__STDC__) || defined (__cplusplus)

1236

#if defined __STDC__ || defined __cplusplus

1022

1237

int yyparse (void *YYPARSE_PARAM);

1023

# else

1238

#else

1024

1239

int yyparse ();

1025

# endif

1240

#endif

1026

1241

#else /* ! YYPARSE_PARAM */

1027

#if defined (__STDC__) || defined (__cplusplus)

1242

#if defined __STDC__ || defined __cplusplus

1028

1243

int yyparse (void);

1029

1244

#else

1030

1245

int yyparse ();

1049

1264

`----------*/

1050

1265

1051

1266

#ifdef YYPARSE_PARAM

1052

# if defined (__STDC__) || defined (__cplusplus)

1053

int yyparse (void *YYPARSE_PARAM)

1054

# else

1055

int yyparse (YYPARSE_PARAM)

1056

void *YYPARSE_PARAM;

1057

# endif

1267

#if (defined __STDC__ || defined __C99__FUNC__ \

1268

|| defined __cplusplus || defined _MSC_VER)

1269

int

1270

yyparse (void *YYPARSE_PARAM)

1271

#else

1272

int

1273

yyparse (YYPARSE_PARAM)

1274

void *YYPARSE_PARAM;

1275

#endif

1058

1276

#else /* ! YYPARSE_PARAM */

1059

#if defined (__STDC__) || defined (__cplusplus)

1277

#if (defined __STDC__ || defined __C99__FUNC__ \

1278

|| defined __cplusplus || defined _MSC_VER)

1060

1279

int

1061

1280

yyparse (void)

1062

1281

#else

1074

1293

int yyerrstatus;

1075

1294

/* Look-ahead token as an internal (translated) token number. */

1076

1295

int yytoken = 0;

1296

#if YYERROR_VERBOSE

1297

/* Buffer for error messages, and its allocated size. */

1298

char yymsgbuf[128];

1299

char *yymsg = yymsgbuf;

1300

YYSIZE_T yymsg_alloc = sizeof yymsgbuf;

1301

#endif

1077

1302

1078

1303

/* Three stacks and their tools:

1079

1304

`yyss': related to states,

1084

1309

to reallocate them elsewhere. */

1085

1310

1086

1311

/* The state stack. */

1087

short int yyssa[YYINITDEPTH];

1088

short int *yyss = yyssa;

1089

short int *yyssp;

1312

yytype_int16 yyssa[YYINITDEPTH];

1313

yytype_int16 *yyss = yyssa;

1314

yytype_int16 *yyssp;

1090

1315

1091

1316

/* The semantic value stack. */

1092

1317

YYSTYPE yyvsa[YYINITDEPTH];

1095

1320

1096

1321

1097

1322

1098

#define YYPOPSTACK (yyvsp--, yyssp--)

1323

#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))

1099

1324

1100

1325

YYSIZE_T yystacksize = YYINITDEPTH;

1101

1326

1104

1329

YYSTYPE yyval;

1105

1330

1106

1331

1107

/* When reducing, the number of symbols on the RHS of the reduced

1108

rule. */

1109

int yylen;

1332

/* The number of symbols on the RHS of the reduced rule.

1333

Keep to zero when no symbol should be popped. */

1334

int yylen = 0;

1110

1335

1111

1336

YYDPRINTF ((stderr, "Starting parse\n"));

1112

1337

1130

1355

`------------------------------------------------------------*/

1131

1356

yynewstate:

1132

1357

/* In all cases, when you get here, the value and location stacks

1133

have just been pushed. so pushing a state here evens the stacks.

1134

*/

1358

have just been pushed. So pushing a state here evens the stacks. */

1135

1359

yyssp++;

1136

1360

1137

1361

yysetstate:

1144

1368

1145

1369

#ifdef yyoverflow

1146

1370

{

1147

/* Give user a chance to reallocate the stack. Use copies of

1371

/* Give user a chance to reallocate the stack. Use copies of

1148

1372

these so that the &'s don't force the real ones into

1149

1373

memory. */

1150

1374

YYSTYPE *yyvs1 = yyvs;

1151

short int *yyss1 = yyss;

1375

yytype_int16 *yyss1 = yyss;

1152

1376

1153

1377

1154

1378

/* Each stack pointer address is followed by the size of the

1176

1400

yystacksize = YYMAXDEPTH;

1177

1401

1178

1402

{

1179

short int *yyss1 = yyss;

1403

yytype_int16 *yyss1 = yyss;

1180

1404

union yyalloc *yyptr =

1181

1405

(union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));

1182

1406

if (! yyptr)

1211

1435

`-----------*/

1212

1436

yybackup:

1213

1437

1214

/* Do appropriate processing given the current state. */

1215

/* Read a look-ahead token if we need one and don't already have one. */

1216

/* yyresume: */

1438

/* Do appropriate processing given the current state. Read a

1439

look-ahead token if we need one and don't already have one. */

1217

1440

1218

1441

/* First try to decide what to do without reference to look-ahead token. */

1219

1220

1442

yyn = yypact[yystate];

1221

1443

if (yyn == YYPACT_NINF)

1222

1444

goto yydefault;

1258

1480

if (yyn == YYFINAL)

1259

1481

YYACCEPT;

1260

1482

1483

/* Count tokens shifted since error; after three, turn off error

1484

status. */

1485

if (yyerrstatus)

1486

yyerrstatus--;

1487

1261

1488

/* Shift the look-ahead token. */

1262

1489

YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);

1263

1490

1264

/* Discard the token being shifted unless it is eof. */

1491

/* Discard the shifted token unless it is eof. */

1265

1492

if (yychar != YYEOF)

1266

1493

yychar = YYEMPTY;

1267

1494

1495

yystate = yyn;

1268

1496

*++yyvsp = yylval;

1269

1497

1270

1271

/* Count tokens shifted since error; after three, turn off error

1272

status. */

1273

if (yyerrstatus)

1274

yyerrstatus--;

1275

1276

yystate = yyn;

1277

1498

goto yynewstate;

1278

1499

1279

1500

1320

1541

case 6:

1321

1542

#line 140 "mofc.y"

1322

1543

{

1323

add_qual_list(qual_chain_current,(yyvsp[0].lval_qual));

1544

add_qual_list(qual_chain_current,(yyvsp[(1) - (1)].lval_qual));

1324

1545

}

1325

1546

break;

1326

1547

1327

1548

case 7:

1328

1549

#line 144 "mofc.y"

1329

1550

{

1330

add_class_list(cls_chain_current,(yyvsp[0].lval_class));

1551

add_class_list(cls_chain_current,(yyvsp[(1) - (1)].lval_class));

1331

1552

}

1332

1553

break;

1333

1554

1334

1555

case 8:

1335

1556

#line 148 "mofc.y"

1336

1557

{

1337

add_class_list(inst_chain_current,(yyvsp[0].lval_class));

1558

add_class_list(inst_chain_current,(yyvsp[(1) - (1)].lval_class));

1338

1559

}

1339

1560

break;

1340

1561

1341

1562

case 9:

1342

1563

#line 160 "mofc.y"

1343

1564

{

1344

(yyval.lval_qual) = make_qualifier_definition(current_qualtab, (yyvsp[-6].lval_id), (yyvsp[-4].lval_type),

1345

(yyvsp[-3].lval_literal),(yyvsp[-2].lval_vals),(yyvsp[-1].lval_qual_quals));

1565

(yyval.lval_qual) = make_qualifier_definition(current_qualtab, (yyvsp[(2) - (8)].lval_id), (yyvsp[(4) - (8)].lval_type),

1566

(yyvsp[(5) - (8)].lval_literal),(yyvsp[(6) - (8)].lval_vals),(yyvsp[(7) - (8)].lval_qual_quals));

1346

1567

}

1347

1568

break;

1348

1569

1357

1578

case 11:

1358

1579

#line 172 "mofc.y"

1359

1580

{

1360

(yyval.lval_qual_quals).scope = (yyvsp[-1].lval_int);

1581

(yyval.lval_qual_quals).scope = (yyvsp[(4) - (5)].lval_int);

1361

1582

(yyval.lval_qual_quals).flavor = 0;

1362

1583

}

1363

1584

break;

1366

1587

#line 177 "mofc.y"

1367

1588

{

1368

1589

(yyval.lval_qual_quals).scope = 0;

1369

(yyval.lval_qual_quals).flavor = (yyvsp[-1].lval_int);

1590

(yyval.lval_qual_quals).flavor = (yyvsp[(4) - (5)].lval_int);

1370

1591

}

1371

1592

break;

1372

1593

1373

1594

case 13:

1374

1595

#line 182 "mofc.y"

1375

1596

{

1376

(yyval.lval_qual_quals).scope = (yyvsp[-6].lval_int);

1377

(yyval.lval_qual_quals).flavor = (yyvsp[-1].lval_int);

1597

(yyval.lval_qual_quals).scope = (yyvsp[(4) - (10)].lval_int);

1598

(yyval.lval_qual_quals).flavor = (yyvsp[(9) - (10)].lval_int);

1378

1599

}

1379

1600

break;

1380

1601

1381

1602

case 14:

1382

1603

#line 189 "mofc.y"

1383

1604

{

1384

(yyval.lval_int)=make_scope((yyvsp[0].lval_id));

1605

(yyval.lval_int)=make_scope((yyvsp[(1) - (1)].lval_id));

1385

1606

}

1386

1607

break;

1387

1608

1388

1609

case 15:

1389

1610

#line 193 "mofc.y"

1390

1611

{

1391

(yyval.lval_int)|=make_scope((yyvsp[0].lval_id));

1612

(yyval.lval_int)|=make_scope((yyvsp[(3) - (3)].lval_id));

1392

1613

}

1393

1614

break;

1394

1615

1395

1616

case 16:

1396

1617

#line 199 "mofc.y"

1397

1618

{

1398

(yyval.lval_int)=make_flavor((yyvsp[0].lval_id));

1619

(yyval.lval_int)=make_flavor((yyvsp[(1) - (1)].lval_id));

1399

1620

}

1400

1621

break;

1401

1622

1402

1623

case 17:

1403

1624

#line 203 "mofc.y"

1404

1625

{

1405

(yyval.lval_int)|=make_flavor((yyvsp[0].lval_id));

1626

(yyval.lval_int)|=make_flavor((yyvsp[(3) - (3)].lval_id));

1406

1627

}

1407

1628

break;

1408

1629

1409

1630

case 20:

1410

1631

#line 220 "mofc.y"

1411

{ (yyval.lval_class) = make_class(current_symtab,(yyvsp[-7].lval_quals),(yyvsp[-5].lval_id),(yyvsp[-4].lval_class),(yyvsp[-2].lval_props)); }

1632

{ (yyval.lval_class) = make_class(current_symtab,(yyvsp[(1) - (8)].lval_quals),(yyvsp[(3) - (8)].lval_id),(yyvsp[(4) - (8)].lval_class),(yyvsp[(6) - (8)].lval_props)); }

1412

1633

break;

1413

1634

1414

1635

case 21:

1415

1636

#line 227 "mofc.y"

1416

1637

{

1417

(yyval.lval_class) = make_instance(current_symtab,(yyvsp[-8].lval_quals),(yyvsp[-5].lval_id),(yyvsp[-2].lval_props));

1418

add_class_list(cls_chain_current,get_class_def(current_symtab,(yyvsp[-5].lval_id)));

1638

(yyval.lval_class) = make_instance(current_symtab,(yyvsp[(1) - (9)].lval_quals),(yyvsp[(4) - (9)].lval_id),(yyvsp[(7) - (9)].lval_props),g_instmig);

1639

add_class_list(cls_chain_current,get_class_def(current_symtab,(yyvsp[(4) - (9)].lval_id)));

1419

1640

}

1420

1641

break;

1421

1642

1426

1647

1427

1648

case 23:

1428

1649

#line 234 "mofc.y"

1429

{(yyval.lval_quals)=(yyvsp[-1].lval_quals);}

1650

{(yyval.lval_quals)=(yyvsp[(2) - (3)].lval_quals);}

1430

1651

break;

1431

1652

1432

1653

case 24:

1433

1654

#line 237 "mofc.y"

1434

{(yyval.lval_quals)=(yyvsp[0].lval_quals);}

1655

{(yyval.lval_quals)=(yyvsp[(1) - (1)].lval_quals);}

1435

1656

break;

1436

1657

1437

1658

case 25:

1438

1659

#line 238 "mofc.y"

1439

{qualifier_list_add((yyvsp[-2].lval_quals),(yyvsp[0].lval_quals));}

1660

{qualifier_list_add((yyvsp[(1) - (3)].lval_quals),(yyvsp[(3) - (3)].lval_quals));}

1440

1661

break;

1441

1662

1442

1663

case 26:

1443

1664

#line 242 "mofc.y"

1444

{(yyval.lval_quals)=make_qualifier(current_qualtab,(yyvsp[-1].lval_id),(yyvsp[0].lval_vals));}

1665

{(yyval.lval_quals)=make_qualifier(current_qualtab,(yyvsp[(1) - (2)].lval_id),(yyvsp[(2) - (2)].lval_vals));}

1445

1666

break;

1446

1667

1447

1668

case 27:

1451

1672

1452

1673

case 28:

1453

1674

#line 246 "mofc.y"

1454

{(yyval.lval_vals)=make_value_list((yyvsp[-1].lval_literal));}

1675

{(yyval.lval_vals)=make_value_list((yyvsp[(2) - (3)].lval_literal));}

1455

1676

break;

1456

1677

1457

1678

case 29:

1458

1679

#line 247 "mofc.y"

1459

{(yyval.lval_vals)=(yyvsp[-1].lval_vals);}

1680

{(yyval.lval_vals)=(yyvsp[(2) - (3)].lval_vals);}

1460

1681

break;

1461

1682

1462

1683

case 30:

1466

1687

1467

1688

case 31:

1468

1689

#line 251 "mofc.y"

1469

{(yyval.lval_vals)=(yyvsp[0].lval_vals);}

1690

{(yyval.lval_vals)=(yyvsp[(1) - (1)].lval_vals);}

1470

1691

break;

1471

1692

1472

1693

case 32:

1473

1694

#line 254 "mofc.y"

1474

{(yyval.lval_vals)=make_value_list((yyvsp[0].lval_literal));}

1695

{(yyval.lval_vals)=make_value_list((yyvsp[(1) - (1)].lval_literal));}

1475

1696

break;

1476

1697

1477

1698

case 33:

1478

1699

#line 255 "mofc.y"

1479

{value_list_add((yyvsp[-2].lval_vals),(yyvsp[0].lval_literal));}

1700

{value_list_add((yyvsp[(1) - (3)].lval_vals),(yyvsp[(3) - (3)].lval_literal));}

1480

1701

break;

1481

1702

1482

1703

case 34:

1486

1707

1487

1708

case 35:

1488

1709

#line 259 "mofc.y"

1489

{(yyval.lval_class)=get_class_def(current_symtab,(yyvsp[0].lval_id));}

1710

{(yyval.lval_class)=get_class_def(current_symtab,(yyvsp[(2) - (2)].lval_id));}

1490

1711

break;

1491

1712

1492

1713

case 36:

1496

1717

1497

1718

case 37:

1498

1719

#line 264 "mofc.y"

1499

{(yyval.lval_props)=(yyvsp[0].lval_props);}

1720

{(yyval.lval_props)=(yyvsp[(1) - (1)].lval_props);}

1500

1721

break;

1501

1722

1502

1723

case 38:

1503

1724

#line 267 "mofc.y"

1504

{(yyval.lval_props)=(yyvsp[0].lval_props);}

1725

{(yyval.lval_props)=(yyvsp[(1) - (1)].lval_props);}

1505

1726

break;

1506

1727

1507

1728

case 39:

1508

1729

#line 270 "mofc.y"

1509

{pom_list_add((yyvsp[-1].lval_props),(yyvsp[0].lval_props));}

1730

{pom_list_add((yyvsp[(1) - (2)].lval_props),(yyvsp[(2) - (2)].lval_props));}

1510

1731

break;

1511

1732

1512

1733

case 40:

1513

1734

#line 279 "mofc.y"

1514

{(yyval.lval_props)=make_pom_list((yyvsp[-6].lval_quals),(yyvsp[-5].lval_type),(yyvsp[-4].lval_id),(yyvsp[-3].lval_literal),(yyvsp[-2].lval_params),(yyvsp[-1].lval_vals));}

1735

{(yyval.lval_props)=make_pom_list((yyvsp[(1) - (7)].lval_quals),(yyvsp[(2) - (7)].lval_type),(yyvsp[(3) - (7)].lval_id),(yyvsp[(4) - (7)].lval_literal),(yyvsp[(5) - (7)].lval_params),(yyvsp[(6) - (7)].lval_vals));}

1515

1736

break;

1516

1737

1517

1738

case 41:

1518

1739

#line 282 "mofc.y"

1519

{(yyval.lval_type)=(yyvsp[0].lval_type);}

1740

{(yyval.lval_type)=(yyvsp[(1) - (1)].lval_type);}

1520

1741

break;

1521

1742

1522

1743

case 42:

1523

1744

#line 283 "mofc.y"

1524

{(yyval.lval_type)=make_ref_type(current_symtab,(yyvsp[-1].lval_id));}

1745

{(yyval.lval_type)=make_ref_type(current_symtab,(yyvsp[(1) - (2)].lval_id));}

1525

1746

break;

1526

1747

1527

1748

case 43:

1606

1827

1607

1828

case 59:

1608

1829

#line 304 "mofc.y"

1609

{(yyval.lval_literal)=(yyvsp[-1].lval_literal);}

1830

{(yyval.lval_literal)=(yyvsp[(2) - (3)].lval_literal);}

1610

1831

break;

1611

1832

1612

1833

case 60:

1616

1837

1617

1838

case 61:

1618

1839

#line 308 "mofc.y"

1619

{(yyval.lval_literal)=(yyvsp[0].lval_literal);}

1840

{(yyval.lval_literal)=(yyvsp[(1) - (1)].lval_literal);}

1620

1841

break;

1621

1842

1622

1843

case 62:

1631

1852

1632

1853

case 64:

1633

1854

#line 313 "mofc.y"

1634

{(yyval.lval_params)=(yyvsp[-1].lval_params);}

1855

{(yyval.lval_params)=(yyvsp[(2) - (3)].lval_params);}

1635

1856

break;

1636

1857

1637

1858

case 65:

1638

1859

#line 316 "mofc.y"

1639

{(yyval.lval_params)=(yyvsp[0].lval_params);}

1860

{(yyval.lval_params)=(yyvsp[(1) - (1)].lval_params);}

1640

1861

break;

1641

1862

1642

1863

case 66:

1643

1864

#line 317 "mofc.y"

1644

{param_list_add((yyvsp[-2].lval_params),(yyvsp[0].lval_params));}

1865

{param_list_add((yyvsp[(1) - (3)].lval_params),(yyvsp[(3) - (3)].lval_params));}

1645

1866

break;

1646

1867

1647

1868

case 67:

1648

1869

#line 321 "mofc.y"

1649

{(yyval.lval_params)=make_param_list((yyvsp[-3].lval_quals),(yyvsp[-2].lval_type),(yyvsp[-1].lval_id),(yyvsp[0].lval_literal));}

1870

{(yyval.lval_params)=make_param_list((yyvsp[(1) - (4)].lval_quals),(yyvsp[(2) - (4)].lval_type),(yyvsp[(3) - (4)].lval_id),(yyvsp[(4) - (4)].lval_literal));}

1650

1871

break;

1651

1872

1652

1873

case 68:

1656

1877

1657

1878

case 69:

1658

1879

#line 325 "mofc.y"

1659

{(yyval.lval_vals) = (yyvsp[0].lval_vals);}

1880

{(yyval.lval_vals) = (yyvsp[(2) - (2)].lval_vals);}

1660

1881

break;

1661

1882

1662

1883

case 70:

1663

1884

#line 328 "mofc.y"

1664

{(yyval.lval_vals)=make_value_list((yyvsp[0].lval_literal));}

1885

{(yyval.lval_vals)=make_value_list((yyvsp[(1) - (1)].lval_literal));}

1665

1886

break;

1666

1887

1667

1888

case 71:

1668

1889

#line 329 "mofc.y"

1669

{(yyval.lval_vals)=(yyvsp[-1].lval_vals);}

1890

{(yyval.lval_vals)=(yyvsp[(2) - (3)].lval_vals);}

1670

1891

break;

1671

1892

1672

1893

case 74:

1673

1894

#line 334 "mofc.y"

1674

{(yyval.lval_literal)=make_char((yyvsp[0].lval_literal));}

1895

{(yyval.lval_literal)=make_char((yyvsp[(1) - (1)].lval_literal));}

1675

1896

break;

1676

1897

1677

1898

case 78:

1678

1899

#line 340 "mofc.y"

1679

{(yyval.lval_literal)=make_string((yyvsp[0].lval_literal));}

1900

{(yyval.lval_literal)=make_string((yyvsp[(1) - (1)].lval_literal));}

1680

1901

break;

1681

1902

1682

1903

case 79:

1683

1904

#line 341 "mofc.y"

1684

{(yyval.lval_literal)=append_string((yyvsp[-1].lval_literal),make_string((yyvsp[0].lval_literal)));}

1905

{(yyval.lval_literal)=append_string((yyvsp[(1) - (2)].lval_literal),make_string((yyvsp[(2) - (2)].lval_literal)));}

1685

1906

break;

1686

1907

1687

1908

case 82:

1692

1913

case 83:

1693

1914

#line 350 "mofc.y"

1694

1915

{

1695

(yyval.lval_props)=(yyvsp[0].lval_props);

1916

(yyval.lval_props)=(yyvsp[(1) - (1)].lval_props);

1696

1917

}

1697

1918

break;

1698

1919

1699

1920

case 84:

1700

1921

#line 356 "mofc.y"

1701

1922

{

1702

(yyval.lval_props)=(yyvsp[0].lval_props);

1923

(yyval.lval_props)=(yyvsp[(1) - (1)].lval_props);

1703

1924

}

1704

1925

break;

1705

1926

1706

1927

case 85:

1707

1928

#line 360 "mofc.y"

1708

1929

{

1709

pom_list_add((yyvsp[-1].lval_props),(yyvsp[0].lval_props));

1930

pom_list_add((yyvsp[(1) - (2)].lval_props),(yyvsp[(2) - (2)].lval_props));

1710

1931

}

1711

1932

break;

1712

1933

1713

1934

case 86:

1714

1935

#line 366 "mofc.y"

1715

1936

{

1716

(yyval.lval_props)=make_pom_list(NULL,(type_type)0,(yyvsp[-2].lval_id),NULL,NULL,(yyvsp[-1].lval_vals));

1937

(yyval.lval_props)=make_pom_list(NULL,(type_type)0,(yyvsp[(1) - (3)].lval_id),NULL,NULL,(yyvsp[(2) - (3)].lval_vals));

1717

1938

}

1718

1939

break;

1719

1940

1720

1941

1942

/* Line 1267 of yacc.c. */

1943

#line 1944 "mofc.c"

1721

1944

default: break;

1722

1945

}

1723

1724

/* Line 1126 of yacc.c. */

1725

#line 1726 "mofc.c"

1726

1727

yyvsp -= yylen;

1728

yyssp -= yylen;

1729

1730

1946

YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);

1947

1948

YYPOPSTACK (yylen);

1949

yylen = 0;

1731

1950

YY_STACK_PRINT (yyss, yyssp);

1732

1951

1733

1952

*++yyvsp = yyval;

1756

1975

if (!yyerrstatus)

1757

1976

{

1758

1977

++yynerrs;

1759

#if YYERROR_VERBOSE

1760

yyn = yypact[yystate];

1761

1762

if (YYPACT_NINF < yyn && yyn < YYLAST)

1763

{

1764

int yytype = YYTRANSLATE (yychar);

1765

YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);

1766

YYSIZE_T yysize = yysize0;

1767

YYSIZE_T yysize1;

1768

int yysize_overflow = 0;

1769

char *yymsg = 0;

1770

# define YYERROR_VERBOSE_ARGS_MAXIMUM 5

1771

char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];

1772

int yyx;

1773

1774

#if 0

1775

/* This is so xgettext sees the translatable formats that are

1776

constructed on the fly. */

1777

YY_("syntax error, unexpected %s");

1778

YY_("syntax error, unexpected %s, expecting %s");

1779

YY_("syntax error, unexpected %s, expecting %s or %s");

1780

YY_("syntax error, unexpected %s, expecting %s or %s or %s");

1781

YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");

1782

#endif

1783

char *yyfmt;

1784

char const *yyf;

1785

static char const yyunexpected[] = "syntax error, unexpected %s";

1786

static char const yyexpecting[] = ", expecting %s";

1787

static char const yyor[] = " or %s";

1788

char yyformat[sizeof yyunexpected

1789

+ sizeof yyexpecting - 1

1790

+ ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)

1791

* (sizeof yyor - 1))];

1792

char const *yyprefix = yyexpecting;

1793

1794

/* Start YYX at -YYN if negative to avoid negative indexes in

1795

YYCHECK. */

1796

int yyxbegin = yyn < 0 ? -yyn : 0;

1797

1798

/* Stay within bounds of both yycheck and yytname. */

1799

int yychecklim = YYLAST - yyn;

1800

int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;

1801

int yycount = 1;

1802

1803

yyarg[0] = yytname[yytype];

1804

yyfmt = yystpcpy (yyformat, yyunexpected);

1805

1806

for (yyx = yyxbegin; yyx < yyxend; ++yyx)

1807

if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)

1808

{

1809

if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)

1810

{

1811

yycount = 1;

1812

yysize = yysize0;

1813

yyformat[sizeof yyunexpected - 1] = '\0';

1814

break;

1815

}

1816

yyarg[yycount++] = yytname[yyx];

1817

yysize1 = yysize + yytnamerr (0, yytname[yyx]);

1818

yysize_overflow |= yysize1 < yysize;

1819

yysize = yysize1;

1820

yyfmt = yystpcpy (yyfmt, yyprefix);

1821

yyprefix = yyor;

1822

}

1823

1824

yyf = YY_(yyformat);

1825

yysize1 = yysize + yystrlen (yyf);

1826

yysize_overflow |= yysize1 < yysize;

1827

yysize = yysize1;

1828

1829

if (!yysize_overflow && yysize <= YYSTACK_ALLOC_MAXIMUM)

1830

yymsg = (char *) YYSTACK_ALLOC (yysize);

1831

if (yymsg)

1832

{

1833

/* Avoid sprintf, as that infringes on the user's name space.

1834

Don't have undefined behavior even if the translation

1835

produced a string with the wrong number of "%s"s. */

1836

char *yyp = yymsg;

1837

int yyi = 0;

1838

while ((*yyp = *yyf))

1839

{

1840

if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)

1841

{

1842

yyp += yytnamerr (yyp, yyarg[yyi++]);

1843

yyf += 2;

1844

}

1845

else

1846

{

1847

yyp++;

1848

yyf++;

1849

}

1850

}

1851

yyerror (yymsg);

1978

#if ! YYERROR_VERBOSE

1979

yyerror (YY_("syntax error"));

1980

#else

1981

{

1982

YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);

1983

if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)

1984

{

1985

YYSIZE_T yyalloc = 2 * yysize;

1986

if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))

1987

yyalloc = YYSTACK_ALLOC_MAXIMUM;

1988

if (yymsg != yymsgbuf)

1852

1989

YYSTACK_FREE (yymsg);

1853

}

1854

else

1855

{

1856

yyerror (YY_("syntax error"));

1990

yymsg = (char *) YYSTACK_ALLOC (yyalloc);

1991

if (yymsg)

1992

yymsg_alloc = yyalloc;

1993

else

1994

{

1995

yymsg = yymsgbuf;

1996

yymsg_alloc = sizeof yymsgbuf;

1997

}

1998

}

1999

2000

if (0 < yysize && yysize <= yymsg_alloc)

2001

{

2002

(void) yysyntax_error (yymsg, yystate, yychar);

2003

yyerror (yymsg);

2004

}

2005

else

2006

{

2007

yyerror (YY_("syntax error"));

2008

if (yysize != 0)

1857

2009

goto yyexhaustedlab;

1858

}

1859

}

1860

else

1861

#endif /* YYERROR_VERBOSE */

1862

yyerror (YY_("syntax error"));

2010

}

2011

}

2012

#endif

1863

2013

}

1864

2014

1865

2015

1870

2020

error, discard it. */

1871

2021

1872

2022

if (yychar <= YYEOF)

1873

{

2023

{

1874

2024

/* Return failure if at end of input. */

1875

2025

if (yychar == YYEOF)

1876

2026

YYABORT;

1877

}

2027

}

1878

2028

else

1879

2029

{

1880

yydestruct ("Error: discarding", yytoken, &yylval);

2030

yydestruct ("Error: discarding",

2031

yytoken, &yylval);

1881

2032

yychar = YYEMPTY;

1882

2033

}

1883

2034

}

1895

2046

/* Pacify compilers like GCC when the user code never invokes

1896

2047

YYERROR and the label yyerrorlab therefore never appears in user

1897

2048

code. */

1898

if (0)

2049

if (/*CONSTCOND*/ 0)

1899

2050

goto yyerrorlab;

1900

2051

1901

yyvsp -= yylen;

1902

yyssp -= yylen;

2052

/* Do not reclaim the symbols of the rule which action triggered

2053

this YYERROR. */

2054

YYPOPSTACK (yylen);

2055

yylen = 0;

2056

YY_STACK_PRINT (yyss, yyssp);

1903

2057

yystate = *yyssp;

1904

2058

goto yyerrlab1;

1905

2059

1929

2083

YYABORT;

1930

2084

1931

2085

1932

yydestruct ("Error: popping", yystos[yystate], yyvsp);

1933

YYPOPSTACK;

2086

yydestruct ("Error: popping",

2087

yystos[yystate], yyvsp);

2088

YYPOPSTACK (1);

1934

2089

yystate = *yyssp;

1935

2090

YY_STACK_PRINT (yyss, yyssp);

1936

2091

}

1941

2096

*++yyvsp = yylval;

1942

2097

1943

2098

1944

/* Shift the error token. */

2099

/* Shift the error token. */

1945

2100

YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);

1946

2101

1947

2102

yystate = yyn;

1976

2131

if (yychar != YYEOF && yychar != YYEMPTY)

1977

2132

yydestruct ("Cleanup: discarding lookahead",

1978

2133

yytoken, &yylval);

2134

/* Do not reclaim the symbols of the rule which action triggered

2135

this YYABORT or YYACCEPT. */

2136

YYPOPSTACK (yylen);

2137

YY_STACK_PRINT (yyss, yyssp);

1979

2138

while (yyssp != yyss)

1980

2139

{

1981

2140

yydestruct ("Cleanup: popping",

1982

2141

yystos[*yyssp], yyvsp);

1983

YYPOPSTACK;

2142

YYPOPSTACK (1);

1984

2143

}

1985

2144

#ifndef yyoverflow

1986

2145

if (yyss != yyssa)

1987

2146

YYSTACK_FREE (yyss);

1988

2147

#endif

1989

return yyresult;

2148

#if YYERROR_VERBOSE

2149

if (yymsg != yymsgbuf)

2150

YYSTACK_FREE (yymsg);

2151

#endif

2152

/* Make sure YYID is used. */

2153

return YYID (yyresult);

1990

2154

}

1991

2155

1992

2156