~vcs-imports/gawk/master : revision 9

1

2

# line 27 "awk.y"

3

#ifdef DEBUG

4

#define YYDEBUG 12

5

#endif

6

7

#define YYMAXDEPTH 300

8

9

#include "awk.h"

10

11

static void yyerror (); /* va_alist */

12

static char *get_src_buf P((void));

13

static int yylex P((void));

14

static NODE *node_common P((NODETYPE op));

15

static NODE *snode P((NODE *subn, NODETYPE op, int index));

16

static NODE *mkrangenode P((NODE *cpair));

17

static NODE *make_for_loop P((NODE *init, NODE *cond, NODE *incr));

18

static NODE *append_right P((NODE *list, NODE *new));

19

static void func_install P((NODE *params, NODE *def));

20

static void pop_var P((NODE *np, int freeit));

21

static void pop_params P((NODE *params));

22

static NODE *make_param P((char *name));

23

static NODE *mk_rexp P((NODE *exp));

24

25

static int want_assign; /* lexical scanning kludge */

26

static int want_regexp; /* lexical scanning kludge */

27

static int can_return; /* lexical scanning kludge */

28

static int io_allowed = 1; /* lexical scanning kludge */

29

static char *lexptr; /* pointer to next char during parsing */

30

static char *lexend;

31

static char *lexptr_begin; /* keep track of where we were for error msgs */

32

static char *lexeme; /* beginning of lexeme for debugging */

33

static char *thisline = NULL;

34

#define YYDEBUG_LEXER_TEXT (lexeme)

35

static int param_counter;

36

static char *tokstart = NULL;

37

static char *token = NULL;

38

static char *tokend;

39

40

NODE *variables[HASHSIZE];

41

42

extern char *source;

43

extern int sourceline;

44

extern char *cmdline_src;

45

extern char **srcfiles;

46

extern int errcount;

47

extern NODE *begin_block;

48

extern NODE *end_block;

49

50

# line 75 "awk.y"

51

typedef union {

52

long lval;

53

AWKNUM fval;

54

NODE *nodeval;

55

NODETYPE nodetypeval;

56

char *sval;

57

NODE *(*ptrval)();

58

} YYSTYPE;

59

# define FUNC_CALL 257

60

# define NAME 258

61

# define REGEXP 259

62

# define ERROR 260

63

# define YNUMBER 261

64

# define YSTRING 262

65

# define RELOP 263

66

# define APPEND_OP 264

67

# define ASSIGNOP 265

68

# define MATCHOP 266

69

# define NEWLINE 267

70

# define CONCAT_OP 268

71

# define LEX_BEGIN 269

72

# define LEX_END 270

73

# define LEX_IF 271

74

# define LEX_ELSE 272

75

# define LEX_RETURN 273

76

# define LEX_DELETE 274

77

# define LEX_WHILE 275

78

# define LEX_DO 276

79

# define LEX_FOR 277

80

# define LEX_BREAK 278

81

# define LEX_CONTINUE 279

82

# define LEX_PRINT 280

83

# define LEX_PRINTF 281

84

# define LEX_NEXT 282

85

# define LEX_EXIT 283

86

# define LEX_FUNCTION 284

87

# define LEX_GETLINE 285

88

# define LEX_IN 286

89

# define LEX_AND 287

90

# define LEX_OR 288

91

# define INCREMENT 289

92

# define DECREMENT 290

93

# define LEX_BUILTIN 291

94

# define LEX_LENGTH 292

95

# define UNARY 293

96

#define yyclearin yychar = -1

97

#define yyerrok yyerrflag = 0

98

extern int yychar;

99

extern int yyerrflag;

100

#ifndef YYMAXDEPTH

101

#define YYMAXDEPTH 150

102

#endif

103

YYSTYPE yylval, yyval;

104

# define YYERRCODE 256

105

106

# line 709 "awk.y"

107

108

109

struct token {

110

char *operator; /* text to match */

111

NODETYPE value; /* node type */

112

int class; /* lexical class */

113

unsigned flags; /* # of args. allowed and compatability */

114

# define ARGS 0xFF /* 0, 1, 2, 3 args allowed (any combination */

115

# define A(n) (1<<(n))

116

# define VERSION 0xFF00 /* old awk is zero */

117

# define NOT_OLD 0x0100 /* feature not in old awk */

118

# define NOT_POSIX 0x0200 /* feature not in POSIX */

119

# define GAWK 0x0400 /* gawk extension */

120

NODE *(*ptr) (); /* function that implements this keyword */

121

};

122

123

extern NODE

124

*do_exp(), *do_getline(), *do_index(), *do_length(),

125

*do_sqrt(), *do_log(), *do_sprintf(), *do_substr(),

126

*do_split(), *do_system(), *do_int(), *do_close(),

127

*do_atan2(), *do_sin(), *do_cos(), *do_rand(),

128

*do_srand(), *do_match(), *do_tolower(), *do_toupper(),

129

*do_sub(), *do_gsub(), *do_strftime(), *do_systime();

130

131

/* Tokentab is sorted ascii ascending order, so it can be binary searched. */

132

133

static struct token tokentab[] = {

134

{"BEGIN", Node_illegal, LEX_BEGIN, 0, 0},

135

{"END", Node_illegal, LEX_END, 0, 0},

136

{"atan2", Node_builtin, LEX_BUILTIN, NOT_OLD|A(2), do_atan2},

137

{"break", Node_K_break, LEX_BREAK, 0, 0},

138

{"close", Node_builtin, LEX_BUILTIN, NOT_OLD|A(1), do_close},

139

{"continue", Node_K_continue, LEX_CONTINUE, 0, 0},

140

{"cos", Node_builtin, LEX_BUILTIN, NOT_OLD|A(1), do_cos},

141

{"delete", Node_K_delete, LEX_DELETE, NOT_OLD, 0},

142

{"do", Node_K_do, LEX_DO, NOT_OLD, 0},

143

{"else", Node_illegal, LEX_ELSE, 0, 0},

144

{"exit", Node_K_exit, LEX_EXIT, 0, 0},

145

{"exp", Node_builtin, LEX_BUILTIN, A(1), do_exp},

146

{"for", Node_K_for, LEX_FOR, 0, 0},

147

{"func", Node_K_function, LEX_FUNCTION, NOT_POSIX|NOT_OLD, 0},

148

{"function", Node_K_function, LEX_FUNCTION, NOT_OLD, 0},

149

{"getline", Node_K_getline, LEX_GETLINE, NOT_OLD, 0},

150

{"gsub", Node_builtin, LEX_BUILTIN, NOT_OLD|A(2)|A(3), do_gsub},

151

{"if", Node_K_if, LEX_IF, 0, 0},

152

{"in", Node_illegal, LEX_IN, 0, 0},

153

{"index", Node_builtin, LEX_BUILTIN, A(2), do_index},

154

{"int", Node_builtin, LEX_BUILTIN, A(1), do_int},

155

{"length", Node_builtin, LEX_LENGTH, A(0)|A(1), do_length},

156

{"log", Node_builtin, LEX_BUILTIN, A(1), do_log},

157

{"match", Node_builtin, LEX_BUILTIN, NOT_OLD|A(2), do_match},

158

{"next", Node_K_next, LEX_NEXT, 0, 0},

159

{"print", Node_K_print, LEX_PRINT, 0, 0},

160

{"printf", Node_K_printf, LEX_PRINTF, 0, 0},

161

{"rand", Node_builtin, LEX_BUILTIN, NOT_OLD|A(0), do_rand},

162

{"return", Node_K_return, LEX_RETURN, NOT_OLD, 0},

163

{"sin", Node_builtin, LEX_BUILTIN, NOT_OLD|A(1), do_sin},

164

{"split", Node_builtin, LEX_BUILTIN, A(2)|A(3), do_split},

165

{"sprintf", Node_builtin, LEX_BUILTIN, 0, do_sprintf},

166

{"sqrt", Node_builtin, LEX_BUILTIN, A(1), do_sqrt},

167

{"srand", Node_builtin, LEX_BUILTIN, NOT_OLD|A(0)|A(1), do_srand},

168

{"strftime", Node_builtin, LEX_BUILTIN, GAWK|A(1)|A(2), do_strftime},

169

{"sub", Node_builtin, LEX_BUILTIN, NOT_OLD|A(2)|A(3), do_sub},

170

{"substr", Node_builtin, LEX_BUILTIN, A(2)|A(3), do_substr},

171

{"system", Node_builtin, LEX_BUILTIN, NOT_OLD|A(1), do_system},

172

{"systime", Node_builtin, LEX_BUILTIN, GAWK|A(0), do_systime},

173

{"tolower", Node_builtin, LEX_BUILTIN, NOT_OLD|A(1), do_tolower},

174

{"toupper", Node_builtin, LEX_BUILTIN, NOT_OLD|A(1), do_toupper},

175

{"while", Node_K_while, LEX_WHILE, 0, 0},

176

};

177

178

/* VARARGS0 */

179

static void

180

yyerror(va_alist)

181

va_dcl

182

{

183

va_list args;

184

char *mesg;

185

register char *ptr, *beg;

186

char *scan;

187

188

errcount++;

189

/* Find the current line in the input file */

190

if (lexptr) {

191

if (!thisline) {

192

for (beg = lexeme; beg != lexptr_begin && *beg != '\n'; --beg)

193

;

194

if (*beg == '\n')

195

beg++;

196

thisline = beg;

197

}

198

/* NL isn't guaranteed */

199

ptr = lexeme;

200

while (ptr < lexend && *ptr && *ptr != '\n')

201

ptr++;

202

} else {

203

thisline = "(END OF FILE)";

204

ptr = thisline + 13;

205

}

206

msg("syntax error");

207

fprintf(stderr, "%.*s\n", (int) (ptr - thisline), thisline);

208

if (lexptr) {

209

scan = thisline;

210

while (scan < lexeme)

211

if (*scan++ == '\t')

212

putc('\t', stderr);

213

else

214

putc(' ', stderr);

215

putc('^', stderr);

216

putc(' ', stderr);

217

}

218

va_start(args);

219

mesg = va_arg(args, char *);

220

vfprintf(stderr, mesg, args);

221

va_end(args);

222

putc('\n', stderr);

223

exit(2);

224

}

225

226

static char *

227

get_src_buf()

228

{

229

static int samefile = 0;

230

static int nextfile = 0;

231

static char *buf = NULL;

232

static int fd;

233

int n;

234

register char *scan;

235

static int len = 0;

236

static int did_newline = 0;

237

# define SLOP 128 /* enough space to hold most source lines */

238

239

if (cmdline_src) {

240

if (len == 0) {

241

len = strlen(cmdline_src);

242

if (len == 0)

243

cmdline_src = NULL;

244

sourceline = 1;

245

lexptr = lexptr_begin = cmdline_src;

246

lexend = lexptr + len;

247

} else if (!did_newline && *(lexptr-1) != '\n') {

248

/*

249

* The following goop is to ensure that the source

250

* ends with a newline and that the entire current

251

* line is available for error messages.

252

*/

253

int offset;

254

255

did_newline = 1;

256

offset = lexptr - lexeme;

257

for (scan = lexeme; scan > lexptr_begin; scan--)

258

if (*scan == '\n') {

259

scan++;

260

break;

261

}

262

len = lexptr - scan;

263

emalloc(buf, char *, len+1, "get_src_buf");

264

memcpy(buf, scan, len);

265

thisline = buf;

266

lexptr = buf + len;

267

*lexptr = '\n';

268

lexeme = lexptr - offset;

269

lexptr_begin = buf;

270

lexend = lexptr + 1;

271

} else

272

lexptr = lexptr_begin = NULL;

273

return lexptr;

274

}

275

if (!samefile) {

276

source = srcfiles[nextfile];

277

if (source == NULL) {

278

if (buf)

279

free(buf);

280

return lexptr = lexptr_begin = NULL;

281

}

282

fd = pathopen(source);

283

if (fd == -1)

284

fatal("can't open source file \"%s\" for reading (%s)",

285

source, strerror(errno));

286

len = optimal_bufsize(fd);

287

if (buf)

288

free(buf);

289

emalloc(buf, char *, len + SLOP, "get_src_buf");

290

lexptr_begin = buf + SLOP;

291

samefile = 1;

292

sourceline = 1;

293

} else {

294

/*

295

* Here, we retain the current source line (up to length SLOP)

296

* in the beginning of the buffer that was overallocated above

297

*/

298

int offset;

299

int linelen;

300

301

offset = lexptr - lexeme;

302

for (scan = lexeme; scan > lexptr_begin; scan--)

303

if (*scan == '\n') {

304

scan++;

305

break;

306

}

307

linelen = lexptr - scan;

308

if (linelen > SLOP)

309

len = SLOP;

310

thisline = buf + SLOP - linelen;

311

memcpy(thisline, scan, linelen);

312

lexeme = buf + SLOP - offset;

313

lexptr_begin = thisline;

314

}

315

n = read(fd, buf + SLOP, len);

316

if (n == -1)

317

fatal("can't read sourcefile \"%s\" (%s)",

318

source, strerror(errno));

319

if (n == 0) {

320

samefile = 0;

321

nextfile++;

322

return get_src_buf();

323

}

324

lexptr = buf + SLOP;

325

lexend = lexptr + n;

326

return buf;

327

}

328

329

#define tokadd(x) (*token++ = (x), token == tokend ? tokexpand() : token)

330

331

char *

332

tokexpand()

333

{

334

static int toksize = 60;

335

int tokoffset;

336

337

tokoffset = token - tokstart;

338

toksize *= 2;

339

if (tokstart)

340

erealloc(tokstart, char *, toksize, "tokexpand");

341

else

342

emalloc(tokstart, char *, toksize, "tokexpand");

343

tokend = tokstart + toksize;

344

token = tokstart + tokoffset;

345

return token;

346

}

347

348

#ifdef DEBUG

349

char

350

nextc() {

351

if (lexptr && lexptr < lexend)

352

return *lexptr++;

353

if (get_src_buf())

354

return *lexptr++;

355

return '\0';

356

}

357

#else

358

#define nextc() ((lexptr && lexptr < lexend) ? \

359

*lexptr++ : \

360

(get_src_buf() ? *lexptr++ : '\0') \

361

)

362

#endif

363

#define pushback() (lexptr && lexptr > lexptr_begin ? lexptr-- : lexptr)

364

365

/*

366

* Read the input and turn it into tokens.

367

*/

368

369

static int

370

yylex()

371

{

372

register int c;

373

int seen_e = 0; /* These are for numbers */

374

int seen_point = 0;

375

int esc_seen; /* for literal strings */

376

int low, mid, high;

377

static int did_newline = 0;

378

char *tokkey;

379

380

if (!nextc())

381

return 0;

382

pushback();

383

lexeme = lexptr;

384

thisline = NULL;

385

if (want_regexp) {

386

int in_brack = 0;

387

388

want_regexp = 0;

389

token = tokstart;

390

while (c = nextc()) {

391

switch (c) {

392

case '[':

393

in_brack = 1;

394

break;

395

case ']':

396

in_brack = 0;

397

break;

398

case '\\':

399

if ((c = nextc()) == '\0') {

400

yyerror("unterminated regexp ends with \\ at end of file");

401

} else if (c == '\n') {

402

sourceline++;

403

continue;

404

} else

405

tokadd('\\');

406

break;

407

case '/': /* end of the regexp */

408

if (in_brack)

409

break;

410

411

pushback();

412

tokadd('\0');

413

yylval.sval = tokstart;

414

return REGEXP;

415

case '\n':

416

pushback();

417

yyerror("unterminated regexp");

418

case '\0':

419

yyerror("unterminated regexp at end of file");

420

}

421

tokadd(c);

422

}

423

}

424

retry:

425

while ((c = nextc()) == ' ' || c == '\t')

426

;

427

428

lexeme = lexptr-1;

429

thisline = NULL;

430

token = tokstart;

431

yylval.nodetypeval = Node_illegal;

432

433

switch (c) {

434

case 0:

435

return 0;

436

437

case '\n':

438

sourceline++;

439

return NEWLINE;

440

441

case '#': /* it's a comment */

442

while ((c = nextc()) != '\n') {

443

if (c == '\0')

444

return 0;

445

}

446

sourceline++;

447

return NEWLINE;

448

449

case '\\':

450

#ifdef RELAXED_CONTINUATION

451

if (!strict) { /* strip trailing white-space and/or comment */

452

while ((c = nextc()) == ' ' || c == '\t') continue;

453

if (c == '#')

454

while ((c = nextc()) != '\n') if (!c) break;

455

pushback();

456

}

457

#endif /*RELAXED_CONTINUATION*/

458

if (nextc() == '\n') {

459

sourceline++;

460

goto retry;

461

} else

462

yyerror("inappropriate use of backslash");

463

break;

464

465

case '$':

466

want_assign = 1;

467

return '$';

468

469

case ')':

470

case ']':

471

case '(':

472

case '[':

473

case ';':

474

case ':':

475

case '?':

476

case '{':

477

case ',':

478

return c;

479

480

case '*':

481

if ((c = nextc()) == '=') {

482

yylval.nodetypeval = Node_assign_times;

483

return ASSIGNOP;

484

} else if (do_posix) {

485

pushback();

486

return '*';

487

} else if (c == '*') {

488

/* make ** and **= aliases for ^ and ^= */

489

static int did_warn_op = 0, did_warn_assgn = 0;

490

491

if (nextc() == '=') {

492

if (do_lint && ! did_warn_assgn) {

493

did_warn_assgn = 1;

494

warning("**= is not allowed by POSIX");

495

}

496

yylval.nodetypeval = Node_assign_exp;

497

return ASSIGNOP;

498

} else {

499

pushback();

500

if (do_lint && ! did_warn_op) {

501

did_warn_op = 1;

502

warning("** is not allowed by POSIX");

503

}

504

return '^';

505

}

506

}

507

pushback();

508

return '*';

509

510

case '/':

511

if (want_assign) {

512

if (nextc() == '=') {

513

yylval.nodetypeval = Node_assign_quotient;

514

return ASSIGNOP;

515

}

516

pushback();

517

}

518

return '/';

519

520

case '%':

521

if (nextc() == '=') {

522

yylval.nodetypeval = Node_assign_mod;

523

return ASSIGNOP;

524

}

525

pushback();

526

return '%';

527

528

case '^':

529

{

530

static int did_warn_op = 0, did_warn_assgn = 0;

531

532

if (nextc() == '=') {

533

534

if (do_lint && ! did_warn_assgn) {

535

did_warn_assgn = 1;

536

warning("operator `^=' is not supported in old awk");

537

}

538

yylval.nodetypeval = Node_assign_exp;

539

return ASSIGNOP;

540

}

541

pushback();

542

if (do_lint && ! did_warn_op) {

543

did_warn_op = 1;

544

warning("operator `^' is not supported in old awk");

545

}

546

return '^';

547

}

548

549

case '+':

550

if ((c = nextc()) == '=') {

551

yylval.nodetypeval = Node_assign_plus;

552

return ASSIGNOP;

553

}

554

if (c == '+')

555

return INCREMENT;

556

pushback();

557

return '+';

558

559

case '!':

560

if ((c = nextc()) == '=') {

561

yylval.nodetypeval = Node_notequal;

562

return RELOP;

563

}

564

if (c == '~') {

565

yylval.nodetypeval = Node_nomatch;

566

want_assign = 0;

567

return MATCHOP;

568

}

569

pushback();

570

return '!';

571

572

case '<':

573

if (nextc() == '=') {

574

yylval.nodetypeval = Node_leq;

575

return RELOP;

576

}

577

yylval.nodetypeval = Node_less;

578

pushback();

579

return '<';

580

581

case '=':

582

if (nextc() == '=') {

583

yylval.nodetypeval = Node_equal;

584

return RELOP;

585

}

586

yylval.nodetypeval = Node_assign;

587

pushback();

588

return ASSIGNOP;

589

590

case '>':

591

if ((c = nextc()) == '=') {

592

yylval.nodetypeval = Node_geq;

593

return RELOP;

594

} else if (c == '>') {

595

yylval.nodetypeval = Node_redirect_append;

596

return APPEND_OP;

597

}

598

yylval.nodetypeval = Node_greater;

599

pushback();

600

return '>';

601

602

case '~':

603

yylval.nodetypeval = Node_match;

604

want_assign = 0;

605

return MATCHOP;

606

607

case '}':

608

/*

609

* Added did newline stuff. Easier than

610

* hacking the grammar

611

*/

612

if (did_newline) {

613

did_newline = 0;

614

return c;

615

}

616

did_newline++;

617

--lexptr; /* pick up } next time */

618

return NEWLINE;

619

620

case '"':

621

esc_seen = 0;

622

while ((c = nextc()) != '"') {

623

if (c == '\n') {

624

pushback();

625

yyerror("unterminated string");

626

}

627

if (c == '\\') {

628

c = nextc();

629

if (c == '\n') {

630

sourceline++;

631

continue;

632

}

633

esc_seen = 1;

634

tokadd('\\');

635

}

636

if (c == '\0') {

637

pushback();

638

yyerror("unterminated string");

639

}

640

tokadd(c);

641

}

642

yylval.nodeval = make_str_node(tokstart,

643

token - tokstart, esc_seen ? SCAN : 0);

644

yylval.nodeval->flags |= PERM;

645

return YSTRING;

646

647

case '-':

648

if ((c = nextc()) == '=') {

649

yylval.nodetypeval = Node_assign_minus;

650

return ASSIGNOP;

651

}

652

if (c == '-')

653

return DECREMENT;

654

pushback();

655

return '-';

656

657

case '0':

658

case '1':

659

case '2':

660

case '3':

661

case '4':

662

case '5':

663

case '6':

664

case '7':

665

case '8':

666

case '9':

667

case '.':

668

/* It's a number */

669

for (;;) {

670

int gotnumber = 0;

671

672

tokadd(c);

673

switch (c) {

674

case '.':

675

if (seen_point) {

676

gotnumber++;

677

break;

678

}

679

++seen_point;

680

break;

681

case 'e':

682

case 'E':

683

if (seen_e) {

684

gotnumber++;

685

break;

686

}

687

++seen_e;

688

if ((c = nextc()) == '-' || c == '+')

689

tokadd(c);

690

else

691

pushback();

692

break;

693

case '0':

694

case '1':

695

case '2':

696

case '3':

697

case '4':

698

case '5':

699

case '6':

700

case '7':

701

case '8':

702

case '9':

703

break;

704

default:

705

gotnumber++;

706

}

707

if (gotnumber)

708

break;

709

c = nextc();

710

}

711

pushback();

712

yylval.nodeval = make_number(atof(tokstart));

713

yylval.nodeval->flags |= PERM;

714

return YNUMBER;

715

716

case '&':

717

if ((c = nextc()) == '&') {

718

yylval.nodetypeval = Node_and;

719

for (;;) {

720

c = nextc();

721

if (c == '\0')

722

break;

723

if (c == '#') {

724

while ((c = nextc()) != '\n' && c != '\0')

725

;

726

if (c == '\0')

727

break;

728

}

729

if (c == '\n')

730

sourceline++;

731

if (! isspace(c)) {

732

pushback();

733

break;

734

}

735

}

736

want_assign = 0;

737

return LEX_AND;

738

}

739

pushback();

740

return '&';

741

742

case '|':

743

if ((c = nextc()) == '|') {

744

yylval.nodetypeval = Node_or;

745

for (;;) {

746

c = nextc();

747

if (c == '\0')

748

break;

749

if (c == '#') {

750

while ((c = nextc()) != '\n' && c != '\0')

751

;

752

if (c == '\0')

753

break;

754

}

755

if (c == '\n')

756

sourceline++;

757

if (! isspace(c)) {

758

pushback();

759

break;

760

}

761

}

762

want_assign = 0;

763

return LEX_OR;

764

}

765

pushback();

766

return '|';

767

}

768

769

if (c != '_' && ! isalpha(c))

770

yyerror("Invalid char '%c' in expression\n", c);

771

772

/* it's some type of name-type-thing. Find its length */

773

token = tokstart;

774

while (is_identchar(c)) {

775

tokadd(c);

776

c = nextc();

777

}

778

tokadd('\0');

779

emalloc(tokkey, char *, token - tokstart, "yylex");

780

memcpy(tokkey, tokstart, token - tokstart);

781

pushback();

782

783

/* See if it is a special token. */

784

low = 0;

785

high = (sizeof (tokentab) / sizeof (tokentab[0])) - 1;

786

while (low <= high) {

787

int i, c;

788

789

mid = (low + high) / 2;

790

c = *tokstart - tokentab[mid].operator[0];

791

i = c ? c : strcmp (tokstart, tokentab[mid].operator);

792

793

if (i < 0) { /* token < mid */

794

high = mid - 1;

795

} else if (i > 0) { /* token > mid */

796

low = mid + 1;

797

} else {

798

if (do_lint) {

799

if (tokentab[mid].flags & GAWK)

800

warning("%s() is a gawk extension",

801

tokentab[mid].operator);

802

if (tokentab[mid].flags & NOT_POSIX)

803

warning("POSIX does not allow %s",

804

tokentab[mid].operator);

805

if (tokentab[mid].flags & NOT_OLD)

806

warning("%s is not supported in old awk",

807

tokentab[mid].operator);

808

}

809

if ((strict && (tokentab[mid].flags & GAWK))

810

|| (do_posix && (tokentab[mid].flags & NOT_POSIX)))

811

break;

812

if (tokentab[mid].class == LEX_BUILTIN

813

|| tokentab[mid].class == LEX_LENGTH

814

)

815

yylval.lval = mid;

816

else

817

yylval.nodetypeval = tokentab[mid].value;

818

819

return tokentab[mid].class;

820

}

821

}

822

823

yylval.sval = tokkey;

824

if (*lexptr == '(')

825

return FUNC_CALL;

826

else {

827

want_assign = 1;

828

return NAME;

829

}

830

}

831

832

static NODE *

833

node_common(op)

834

NODETYPE op;

835

{

836

register NODE *r;

837

838

getnode(r);

839

r->type = op;

840

r->flags = MALLOC;

841

/* if lookahead is NL, lineno is 1 too high */

842

if (lexeme && *lexeme == '\n')

843

r->source_line = sourceline - 1;

844

else

845

r->source_line = sourceline;

846

r->source_file = source;

847

return r;

848

}

849

850

/*

851

* This allocates a node with defined lnode and rnode.

852

*/

853

NODE *

854

node(left, op, right)

855

NODE *left, *right;

856

NODETYPE op;

857

{

858

register NODE *r;

859

860

r = node_common(op);

861

r->lnode = left;

862

r->rnode = right;

863

return r;

864

}

865

866

/*

867

* This allocates a node with defined subnode and proc for builtin functions

868

* Checks for arg. count and supplies defaults where possible.

869

*/

870

static NODE *

871

snode(subn, op, index)

872

NODETYPE op;

873

int index;

874

NODE *subn;

875

{

876

register NODE *r;

877

register NODE *n;

878

int nexp = 0;

879

int args_allowed;

880

881

r = node_common(op);

882

883

/* traverse expression list to see how many args. given */

884

for (n= subn; n; n= n->rnode) {

885

nexp++;

886

if (nexp > 3)

887

break;

888

}

889

890

/* check against how many args. are allowed for this builtin */

891

args_allowed = tokentab[index].flags & ARGS;

892

if (args_allowed && !(args_allowed & A(nexp)))

893

fatal("%s() cannot have %d argument%c",

894

tokentab[index].operator, nexp, nexp == 1 ? ' ' : 's');

895

896

r->proc = tokentab[index].ptr;

897

898

/* special case processing for a few builtins */

899

if (nexp == 0 && r->proc == do_length) {

900

subn = node(node(make_number(0.0),Node_field_spec,(NODE *)NULL),

901

Node_expression_list,

902

(NODE *) NULL);

903

} else if (r->proc == do_match) {

904

if (subn->rnode->lnode->type != Node_regex)

905

subn->rnode->lnode = mk_rexp(subn->rnode->lnode);

906

} else if (r->proc == do_sub || r->proc == do_gsub) {

907

if (subn->lnode->type != Node_regex)

908

subn->lnode = mk_rexp(subn->lnode);

909

if (nexp == 2)

910

append_right(subn, node(node(make_number(0.0),

911

Node_field_spec,

912

(NODE *) NULL),

913

Node_expression_list,

914

(NODE *) NULL));

915

else if (do_lint && subn->rnode->rnode->lnode->type == Node_val)

916

warning("string literal as last arg of substitute");

917

} else if (r->proc == do_split) {

918

if (nexp == 2)

919

append_right(subn,

920

node(FS_node, Node_expression_list, (NODE *) NULL));

921

n = subn->rnode->rnode->lnode;

922

if (n->type != Node_regex)

923

subn->rnode->rnode->lnode = mk_rexp(n);

924

if (nexp == 2)

925

subn->rnode->rnode->lnode->re_flags |= FS_DFLT;

926

}

927

928

r->subnode = subn;

929

return r;

930

}

931

932

/*

933

* This allocates a Node_line_range node with defined condpair and

934

* zeroes the trigger word to avoid the temptation of assuming that calling

935

* 'node( foo, Node_line_range, 0)' will properly initialize 'triggered'.

936

*/

937

/* Otherwise like node() */

938

static NODE *

939

mkrangenode(cpair)

940

NODE *cpair;

941

{

942

register NODE *r;

943

944

getnode(r);

945

r->type = Node_line_range;

946

r->condpair = cpair;

947

r->triggered = 0;

948

return r;

949

}

950

951

/* Build a for loop */

952

static NODE *

953

make_for_loop(init, cond, incr)

954

NODE *init, *cond, *incr;

955

{

956

register FOR_LOOP_HEADER *r;

957

NODE *n;

958

959

emalloc(r, FOR_LOOP_HEADER *, sizeof(FOR_LOOP_HEADER), "make_for_loop");

960

getnode(n);

961

n->type = Node_illegal;

962

r->init = init;

963

r->cond = cond;

964

r->incr = incr;

965

n->sub.nodep.r.hd = r;

966

return n;

967

}

968

969

/*

970

* Install a name in the symbol table, even if it is already there.

971

* Caller must check against redefinition if that is desired.

972

*/

973

NODE *

974

install(name, value)

975

char *name;

976

NODE *value;

977

{

978

register NODE *hp;

979

register int len, bucket;

980

981

len = strlen(name);

982

bucket = hash(name, len);

983

getnode(hp);

984

hp->type = Node_hashnode;

985

hp->hnext = variables[bucket];

986

variables[bucket] = hp;

987

hp->hlength = len;

988

hp->hvalue = value;

989

hp->hname = name;

990

return hp->hvalue;

991

}

992

993

/* find the most recent hash node for name installed by install */

994

NODE *

995

lookup(name)

996

char *name;

997

{

998

register NODE *bucket;

999

register int len;

1000

1001

len = strlen(name);

1002

bucket = variables[hash(name, len)];

1003

while (bucket) {

1004

if (bucket->hlength == len && STREQN(bucket->hname, name, len))

1005

return bucket->hvalue;

1006

bucket = bucket->hnext;

1007

}

1008

return NULL;

1009

}

1010

1011

/*

1012

* Add new to the rightmost branch of LIST. This uses n^2 time, so we make

1013

* a simple attempt at optimizing it.

1014

*/

1015

static NODE *

1016

append_right(list, new)

1017

NODE *list, *new;

1018

{

1019

register NODE *oldlist;

1020

static NODE *savefront = NULL, *savetail = NULL;

1021

1022

oldlist = list;

1023

if (savefront == oldlist) {

1024

savetail = savetail->rnode = new;

1025

return oldlist;

1026

} else

1027

savefront = oldlist;

1028

while (list->rnode != NULL)

1029

list = list->rnode;

1030

savetail = list->rnode = new;

1031

return oldlist;

1032

}

1033

1034

/*

1035

* check if name is already installed; if so, it had better have Null value,

1036

* in which case def is added as the value. Otherwise, install name with def

1037

* as value.

1038

*/

1039

static void

1040

func_install(params, def)

1041

NODE *params;

1042

NODE *def;

1043

{

1044

NODE *r;

1045

1046

pop_params(params->rnode);

1047

pop_var(params, 0);

1048

r = lookup(params->param);

1049

if (r != NULL) {

1050

fatal("function name `%s' previously defined", params->param);

1051

} else

1052

(void) install(params->param, node(params, Node_func, def));

1053

}

1054

1055

static void

1056

pop_var(np, freeit)

1057

NODE *np;

1058

int freeit;

1059

{

1060

register NODE *bucket, **save;

1061

register int len;

1062

char *name;

1063

1064

name = np->param;

1065

len = strlen(name);

1066

save = &(variables[hash(name, len)]);

1067

for (bucket = *save; bucket; bucket = bucket->hnext) {

1068

if (len == bucket->hlength && STREQN(bucket->hname, name, len)) {

1069

*save = bucket->hnext;

1070

freenode(bucket);

1071

if (freeit)

1072

free(np->param);

1073

return;

1074

}

1075

save = &(bucket->hnext);

1076

}

1077

}

1078

1079

static void

1080

pop_params(params)

1081

NODE *params;

1082

{

1083

register NODE *np;

1084

1085

for (np = params; np != NULL; np = np->rnode)

1086

pop_var(np, 1);

1087

}

1088

1089

static NODE *

1090

make_param(name)

1091

char *name;

1092

{

1093

NODE *r;

1094

1095

getnode(r);

1096

r->type = Node_param_list;

1097

r->rnode = NULL;

1098

r->param = name;

1099

r->param_cnt = param_counter++;

1100

return (install(name, r));

1101

}

1102

1103

/* Name points to a variable name. Make sure its in the symbol table */

1104

NODE *

1105

variable(name, can_free)

1106

char *name;

1107

int can_free;

1108

{

1109

register NODE *r;

1110

static int env_loaded = 0;

1111

1112

if (!env_loaded && STREQ(name, "ENVIRON")) {

1113

load_environ();

1114

env_loaded = 1;

1115

}

1116

if ((r = lookup(name)) == NULL)

1117

r = install(name, node(Nnull_string, Node_var, (NODE *) NULL));

1118

else if (can_free)

1119

free(name);

1120

return r;

1121

}

1122

1123

static NODE *

1124

mk_rexp(exp)

1125

NODE *exp;

1126

{

1127

if (exp->type == Node_regex)

1128

return exp;

1129

else {

1130

NODE *n;

1131

1132

getnode(n);

1133

n->type = Node_regex;

1134

n->re_exp = exp;

1135

n->re_text = NULL;

1136

n->re_reg = NULL;

1137

n->re_flags = 0;

1138

n->re_cnt = 1;

1139

return n;

1140

}

1141

}

1142

int yyexca[] ={

1143

-1, 1,

1144

0, -1,

1145

-2, 0,

1146

-1, 5,

1147

0, 59,

1148

-2, 0,

1149

-1, 77,

1150

264, 76,

1151

267, 76,

1152

62, 76,

1153

124, 76,

1154

59, 76,

1155

-2, 0,

1156

-1, 111,

1157

41, 84,

1158

-2, 0,

1159

-1, 112,

1160

41, 84,

1161

-2, 0,

1162

-1, 113,

1163

41, 84,

1164

-2, 0,

1165

-1, 126,

1166

266, 0,

1167

-2, 99,

1168

-1, 128,

1169

263, 0,

1170

60, 0,

1171

62, 0,

1172

124, 0,

1173

-2, 103,

1174

-1, 129,

1175

263, 0,

1176

60, 0,

1177

62, 0,

1178

124, 0,

1179

-2, 104,

1180

-1, 130,

1181

263, 0,

1182

60, 0,

1183

62, 0,

1184

124, 0,

1185

-2, 105,

1186

-1, 149,

1187

264, 77,

1188

267, 77,

1189

62, 77,

1190

124, 77,

1191

59, 77,

1192

-2, 0,

1193

-1, 186,

1194

41, 85,

1195

-2, 0,

1196

-1, 220,

1197

41, 67,

1198

-2, 0,

1199

-1, 248,

1200

266, 0,

1201

-2, 116,

1202

-1, 250,

1203

263, 0,

1204

-2, 118,

1205

-1, 258,

1206

41, 68,

1207

-2, 0,

1208

};

1209

# define YYNPROD 158

1210

# define YYLAST 1843

1211

int yyact[]={

1212

1213

62, 212, 20, 13, 107, 24, 13, 87, 225, 17,

1214

88, 89, 36, 123, 35, 82, 25, 291, 91, 235,

1215

45, 45, 4, 37, 168, 88, 89, 286, 45, 285,

1216

264, 88, 89, 200, 260, 24, 259, 261, 52, 184,

1217

166, 165, 249, 161, 63, 127, 199, 22, 100, 186,

1218

158, 173, 82, 122, 65, 124, 125, 126, 63, 128,

1219

129, 130, 131, 20, 218, 82, 24, 90, 107, 171,

1220

17, 82, 63, 36, 45, 35, 64, 25, 63, 174,

1221

159, 136, 63, 93, 22, 171, 228, 63, 263, 45,

1222

220, 185, 22, 270, 68, 202, 163, 144, 142, 175,

1223

113, 103, 112, 111, 6, 252, 101, 227, 183, 167,

1224

39, 102, 183, 183, 183, 160, 26, 157, 110, 133,

1225

20, 86, 82, 24, 11, 140, 97, 17, 121, 24,

1226

36, 46, 35, 98, 25, 48, 36, 41, 35, 164,

1227

25, 108, 82, 194, 82, 159, 45, 141, 91, 77,

1228

257, 71, 148, 22, 149, 68, 258, 182, 100, 10,

1229

27, 159, 5, 1, 219, 50, 118, 12, 221, 222,

1230

224, 120, 20, 0, 203, 24, 189, 0, 97, 17,

1231

0, 24, 36, 0, 35, 98, 25, 0, 36, 0,

1232

35, 0, 233, 0, 0, 197, 193, 198, 45, 236,

1233

0, 240, 241, 242, 187, 188, 0, 190, 0, 0,

1234

22, 217, 0, 0, 0, 192, 0, 0, 0, 183,

1235

0, 0, 0, 0, 0, 135, 30, 23, 4, 4,

1236

33, 34, 0, 0, 0, 201, 0, 213, 265, 0,

1237

83, 0, 80, 81, 72, 73, 74, 75, 76, 84,

1238

85, 78, 79, 0, 18, 0, 169, 23, 31, 32,

1239

28, 29, 22, 82, 276, 253, 20, 159, 255, 24,

1240

169, 232, 82, 17, 0, 0, 36, 0, 35, 159,

1241

25, 0, 0, 273, 169, 267, 67, 30, 23, 82,

1242

274, 33, 34, 59, 169, 60, 82, 82, 82, 204,

1243

0, 83, 19, 80, 81, 72, 73, 74, 75, 76,

1244

84, 85, 78, 79, 0, 18, 0, 279, 0, 31,

1245

32, 28, 29, 95, 0, 0, 0, 0, 0, 289,

1246

103, 0, 0, 0, 0, 101, 104, 0, 105, 0,

1247

102, 0, 0, 67, 30, 23, 0, 0, 33, 34,

1248

30, 23, 0, 0, 33, 34, 0, 53, 83, 0,

1249

80, 81, 72, 73, 74, 75, 76, 84, 85, 78,

1250

79, 0, 18, 0, 0, 0, 31, 32, 28, 29,

1251

154, 0, 31, 32, 28, 29, 0, 100, 0, 0,

1252

0, 0, 0, 0, 0, 211, 30, 23, 0, 0,

1253

33, 34, 30, 23, 0, 0, 33, 34, 0, 0,

1254

83, 0, 80, 81, 72, 73, 74, 75, 76, 84,

1255

85, 78, 79, 16, 18, 0, 0, 0, 31, 32,

1256

28, 29, 0, 0, 31, 32, 28, 29, 0, 0,

1257

0, 0, 94, 0, 99, 0, 0, 0, 109, 0,

1258

0, 0, 0, 154, 20, 114, 115, 24, 214, 99,

1259

99, 17, 0, 0, 36, 0, 35, 0, 25, 0,

1260

0, 0, 0, 150, 0, 0, 0, 0, 0, 0,

1261

45, 59, 0, 60, 61, 0, 0, 0, 0, 0,

1262

20, 23, 0, 24, 33, 34, 58, 17, 171, 0,

1263

36, 152, 35, 0, 25, 0, 154, 154, 154, 154,

1264

154, 0, 154, 154, 154, 0, 0, 59, 0, 60,

1265

61, 99, 31, 32, 99, 99, 99, 99, 99, 99,

1266

20, 0, 0, 24, 0, 0, 0, 17, 0, 0,

1267

36, 0, 35, 0, 25, 53, 154, 94, 154, 154,

1268

154, 154, 0, 154, 154, 154, 45, 59, 0, 60,

1269

61, 0, 0, 0, 0, 0, 20, 0, 0, 24,

1270

0, 154, 154, 17, 152, 0, 36, 94, 35, 99,

1271

25, 53, 0, 0, 154, 0, 0, 0, 0, 0,

1272

0, 191, 0, 59, 0, 60, 61, 0, 99, 243,

1273

245, 246, 247, 248, 0, 250, 251, 70, 0, 0,

1274

14, 0, 20, 14, 0, 24, 0, 0, 14, 17,

1275

51, 53, 36, 63, 35, 0, 25, 152, 152, 152,

1276

152, 152, 0, 152, 152, 152, 0, 0, 0, 59,

1277

0, 60, 61, 0, 0, 0, 0, 0, 269, 14,

1278

0, 0, 0, 0, 14, 0, 0, 53, 0, 0,

1279

0, 0, 0, 0, 281, 0, 0, 152, 0, 152,

1280

152, 152, 152, 0, 152, 152, 152, 0, 30, 23,

1281

0, 0, 33, 34, 58, 0, 0, 56, 4, 0,

1282

0, 0, 152, 152, 0, 0, 0, 0, 0, 0,

1283

0, 0, 0, 53, 0, 152, 18, 57, 54, 55,

1284

31, 32, 28, 29, 30, 23, 0, 0, 33, 34,

1285

58, 0, 0, 56, 0, 0, 155, 0, 0, 24,

1286

0, 0, 0, 98, 0, 0, 36, 0, 35, 0,

1287

25, 0, 18, 57, 54, 55, 31, 32, 28, 29,

1288

0, 268, 0, 0, 30, 23, 210, 0, 33, 34,

1289

58, 0, 155, 56, 0, 24, 0, 0, 0, 98,

1290

0, 0, 36, 0, 35, 0, 25, 0, 0, 0,

1291

0, 0, 18, 57, 54, 55, 31, 32, 28, 29,

1292

30, 23, 210, 0, 33, 34, 58, 0, 0, 56,

1293

20, 0, 0, 24, 0, 0, 0, 17, 0, 0,

1294

36, 0, 35, 0, 25, 0, 0, 0, 18, 57,

1295

54, 55, 31, 32, 28, 29, 0, 59, 0, 60,

1296

61, 0, 0, 0, 0, 0, 30, 23, 21, 0,

1297

33, 34, 58, 0, 0, 56, 0, 0, 155, 0,

1298

0, 24, 0, 0, 0, 98, 0, 0, 36, 96,

1299

35, 0, 25, 0, 18, 57, 54, 55, 31, 32,

1300

28, 29, 0, 20, 116, 117, 24, 0, 0, 0,

1301

17, 0, 0, 36, 0, 35, 0, 25, 0, 0,

1302

0, 53, 0, 0, 0, 0, 0, 0, 0, 0,

1303

59, 0, 60, 0, 0, 0, 0, 0, 0, 0,

1304

155, 0, 0, 24, 0, 0, 156, 98, 20, 0,

1305

36, 24, 35, 0, 25, 17, 0, 0, 36, 0,

1306

35, 0, 25, 0, 0, 0, 96, 0, 0, 176,

1307

177, 178, 179, 180, 181, 59, 0, 60, 0, 0,

1308

30, 23, 0, 0, 33, 34, 209, 0, 0, 207,

1309

0, 0, 0, 20, 53, 0, 24, 0, 0, 0,

1310

17, 0, 0, 36, 0, 35, 0, 25, 153, 208,

1311

205, 206, 31, 32, 28, 29, 30, 23, 0, 156,

1312

33, 34, 209, 20, 96, 207, 24, 0, 0, 0,

1313

17, 0, 0, 36, 0, 35, 0, 25, 0, 53,

1314

0, 0, 0, 226, 153, 208, 205, 206, 31, 32,

1315

28, 29, 0, 0, 30, 23, 0, 0, 33, 34,

1316

58, 0, 0, 56, 0, 0, 0, 0, 0, 0,

1317

0, 0, 156, 156, 156, 156, 156, 0, 156, 156,

1318

156, 0, 18, 57, 54, 55, 31, 32, 28, 29,

1319

20, 0, 0, 24, 0, 0, 0, 17, 0, 0,

1320

36, 0, 35, 23, 25, 0, 33, 34, 209, 0,

1321

0, 0, 156, 22, 156, 156, 156, 156, 0, 156,

1322

156, 156, 0, 0, 0, 0, 0, 30, 23, 0,

1323

0, 33, 34, 58, 31, 32, 56, 156, 156, 155,

1324

0, 0, 24, 0, 0, 0, 98, 0, 0, 36,

1325

156, 35, 0, 25, 0, 18, 57, 54, 0, 31,

1326

32, 28, 29, 0, 0, 23, 0, 0, 33, 34,

1327

0, 0, 30, 23, 0, 0, 33, 34, 58, 155,

1328

22, 56, 24, 0, 0, 0, 98, 0, 0, 36,

1329

0, 35, 2, 25, 0, 0, 31, 32, 38, 0,

1330

18, 57, 0, 0, 31, 32, 28, 29, 0, 0,

1331

0, 0, 0, 0, 0, 106, 20, 0, 23, 24,

1332

0, 33, 34, 17, 0, 0, 36, 0, 35, 0,

1333

25, 0, 0, 0, 0, 0, 0, 119, 0, 0,

1334

0, 0, 45, 0, 0, 0, 40, 30, 23, 31,

1335

32, 33, 34, 0, 0, 0, 132, 4, 0, 8,

1336

9, 138, 139, 0, 0, 0, 143, 0, 0, 0,

1337

0, 0, 0, 0, 15, 18, 0, 0, 0, 31,

1338

32, 28, 29, 20, 0, 0, 24, 0, 0, 0,

1339

17, 155, 0, 36, 24, 35, 0, 25, 98, 0,

1340

0, 36, 0, 35, 0, 25, 0, 0, 0, 0,

1341

0, 66, 0, 7, 30, 23, 0, 0, 33, 34,

1342

0, 0, 0, 0, 0, 0, 8, 9, 0, 0,

1343

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

1344

0, 15, 18, 0, 0, 0, 31, 32, 28, 29,

1345

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

1346

0, 0, 0, 30, 23, 172, 0, 33, 34, 209,

1347

20, 0, 207, 24, 0, 0, 134, 17, 0, 0,

1348

36, 0, 35, 0, 25, 0, 0, 0, 0, 0,

1349

0, 153, 208, 205, 0, 31, 32, 28, 29, 0,

1350

0, 0, 0, 30, 23, 0, 0, 33, 34, 209,

1351

155, 0, 207, 24, 0, 0, 0, 147, 0, 0,

1352

36, 0, 35, 0, 25, 0, 0, 262, 0, 0,

1353

0, 153, 208, 134, 0, 31, 32, 28, 29, 0,

1354

30, 23, 0, 0, 33, 34, 0, 20, 0, 271,

1355

24, 0, 0, 134, 17, 195, 170, 36, 0, 35,

1356

0, 25, 0, 0, 0, 284, 0, 0, 18, 0,

1357

288, 0, 31, 32, 28, 29, 0, 0, 0, 0,

1358

292, 0, 0, 295, 296, 155, 0, 297, 24, 0,

1359

42, 0, 98, 0, 0, 36, 0, 35, 0, 25,

1360

47, 49, 0, 0, 0, 0, 92, 30, 23, 0,

1361

0, 33, 34, 0, 244, 30, 23, 0, 0, 33,

1362

34, 0, 20, 0, 0, 24, 0, 0, 0, 17,

1363

0, 0, 36, 0, 35, 18, 25, 0, 0, 31,

1364

32, 28, 29, 153, 0, 0, 0, 31, 32, 28,

1365

29, 229, 0, 230, 231, 0, 0, 0, 0, 0,

1366

234, 0, 0, 0, 238, 0, 145, 146, 0, 0,

1367

0, 0, 0, 162, 275, 0, 0, 69, 0, 0,

1368

0, 0, 0, 283, 0, 256, 44, 44, 44, 0,

1369

0, 0, 0, 223, 30, 23, 0, 0, 33, 34,

1370

293, 3, 0, 0, 0, 0, 0, 298, 299, 300,

1371

43, 43, 43, 0, 0, 0, 0, 0, 0, 0,

1372

0, 0, 18, 272, 0, 0, 31, 32, 28, 29,

1373

277, 0, 0, 151, 30, 23, 0, 0, 33, 34,

1374

0, 0, 287, 137, 0, 290, 0, 0, 215, 216,

1375

0, 0, 0, 44, 44, 294, 0, 0, 0, 0,

1376

44, 0, 153, 0, 0, 0, 31, 32, 28, 29,

1377

0, 30, 23, 0, 0, 33, 34, 43, 43, 0,

1378

0, 0, 0, 0, 43, 0, 0, 0, 0, 0,

1379

239, 0, 0, 0, 0, 0, 0, 0, 0, 18,

1380

0, 0, 0, 31, 32, 28, 29, 0, 254, 30,

1381

23, 137, 0, 33, 34, 0, 0, 0, 0, 0,

1382

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

1383

0, 0, 0, 0, 0, 44, 44, 153, 0, 0,

1384

0, 31, 32, 28, 29, 0, 30, 196, 0, 0,

1385

33, 34, 0, 0, 0, 0, 0, 0, 280, 43,

1386

43, 282, 0, 0, 0, 0, 0, 137, 0, 0,

1387

0, 0, 0, 0, 18, 237, 0, 44, 31, 32,

1388

28, 29, 0, 0, 0, 0, 0, 0, 0, 0,

1389

0, 0, 0, 0, 0, 44, 0, 0, 0, 0,

1390

0, 43, 0, 0, 0, 0, 0, 0, 0, 0,

1391

0, 0, 0, 0, 0, 266, 0, 0, 0, 43,

1392

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

1393

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

1394

0, 0, 0, 278, 0, 44, 0, 0, 44, 0,

1395

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

1396

0, 0, 0, 0, 0, 0, 0, 0, 0, 43,

1397

0, 0, 43 };

1398

int yypact[]={

1399

1400

-245, -1000, 1027, -244, -1000, 960, -1000, -1000, -38, -38,

1401

-39, -1000, -76, 579, 30, -1000, -258, 1220, -1, -1000,

1402

93, 293, -245, -23, 145, -1000, -1000, -1000, 63, 62,

1403

60, -1, -1, -1000, -1000, 145, 145, -1000, -1000, -1000,

1404

-1000, -76, -1000, -244, -245, -1000, -76, -1000, -1000, -1000,

1405

-1000, 87, 1384, -272, 1384, 1384, 1384, -213, 1384, 1384,

1406

1384, 1384, 930, -245, -31, 15, -1000, -1000, -245, -245,

1407

30, -1000, 58, -245, 57, -38, -38, 1347, -1000, 1384,

1408

-1000, -215, 421, 56, -1000, -1000, -217, -1000, -1000, -1000,

1409

28, 457, -1000, 19, -1000, -1000, -46, 145, 1384, -279,

1410

145, 145, 145, 145, 145, 145, -1000, 1220, -1000, -1000,

1411

-220, 1220, 1220, 1220, -1000, -1000, -46, -46, -1000, -1000,

1412

-1000, -31, 767, -1, 885, 840, 233, -1000, 930, 930,

1413

930, 533, -1000, 15, -1000, -1000, -1000, -1000, -1000, -1000,

1414

-1000, -31, 1384, 139, 1459, -1000, -1000, 1220, -29, 43,

1415

729, -1000, -264, -1, -1000, 93, 293, -38, -38, 767,

1416

1384, -27, -1000, 1384, 50, -1000, -1000, 1384, 1307, 1384,

1417

-278, -1000, -1000, -1000, 145, 457, -46, -46, -46, -46,

1418

64, 64, 14, 767, 39, 44, 38, 44, 44, 15,

1419

-1000, 1384, -1000, -1000, 457, -256, -87, 15, 28, -38,

1420

1384, 1384, 1384, 1228, 1422, 1422, 1422, 1422, -216, 1422,

1421

1422, 877, -1000, 19, -1000, -1000, -1000, -38, 1220, 457,

1422

-222, 767, 767, -1000, 767, -221, 293, -1000, -1000, -1000,

1423

-1000, -1000, -1000, 767, -245, 48, -228, 1153, -29, -1000,

1424

767, 767, 767, 729, -1000, 729, 1116, 1076, 815, -1000,

1425

877, 693, 1422, -1000, -1000, 0, -245, 44, 34, -1000,

1426

-1000, -1000, 139, 1384, 44, 497, 1384, -38, 1422, 729,

1427

-38, 139, -245, -229, -1000, -1000, 457, -245, 1384, 44,

1428

-1000, 729, -1000, -255, -1000, -1000, -1000, -245, 139, 44,

1429

-245, -245, -1000, -1000, -245, 139, 139, 139, -1000, -1000,

1430

-1000 };

1431

int yypgo[]={

1432

1433

0, 167, 165, 395, 0, 163, 162, 104, 838, 116,

1434

160, 159, 124, 423, 156, 154, 152, 49, 91, 76,

1435

1281, 151, 150, 50, 83, 302, 51, 46, 149, 139,

1436

1162, 137, 131, 1460, 121, 1335, 607, 54, 81, 24,

1437

118, 1571, 1547, 117, 115, 109, 105 };

1438

int yyr1[]={

1439

1440

0, 5, 6, 6, 6, 6, 31, 7, 32, 7,

1441

7, 7, 7, 7, 7, 7, 29, 29, 34, 1,

1442

2, 11, 11, 40, 25, 12, 12, 19, 19, 19,

1443

19, 33, 33, 20, 20, 20, 20, 20, 20, 20,

1444

20, 20, 20, 20, 20, 20, 43, 20, 20, 44,

1445

20, 20, 20, 28, 28, 21, 21, 41, 41, 30,

1446

30, 26, 26, 27, 27, 27, 27, 22, 22, 14,

1447

14, 14, 14, 14, 23, 23, 16, 16, 15, 15,

1448

15, 15, 15, 15, 18, 18, 17, 17, 17, 17,

1449

17, 17, 45, 4, 4, 4, 4, 4, 4, 4,

1450

4, 4, 4, 4, 4, 4, 4, 4, 4, 46,

1451

3, 3, 3, 3, 3, 3, 3, 3, 3, 3,

1452

3, 3, 8, 8, 8, 8, 8, 8, 8, 8,

1453

9, 9, 9, 9, 9, 9, 9, 9, 9, 9,

1454

9, 9, 10, 10, 10, 24, 24, 13, 13, 13,

1455

13, 36, 37, 35, 38, 38, 42, 39 };

1456

int yyr2[]={

1457

1458

0, 7, 3, 5, 3, 5, 1, 7, 1, 7,

1459

5, 5, 5, 3, 5, 5, 3, 3, 1, 15,

1460

9, 3, 7, 1, 9, 9, 7, 3, 5, 3,

1461

5, 2, 4, 5, 5, 7, 3, 13, 17, 17,

1462

21, 19, 5, 5, 13, 9, 1, 7, 7, 1,

1463

9, 13, 5, 3, 3, 13, 19, 3, 4, 0,

1464

2, 1, 5, 1, 5, 5, 5, 1, 3, 3,

1465

7, 3, 5, 7, 1, 3, 1, 3, 3, 7,

1466

3, 5, 7, 7, 1, 3, 3, 7, 3, 5,

1467

7, 7, 1, 9, 11, 9, 7, 7, 7, 7,

1468

3, 5, 7, 7, 7, 7, 11, 3, 5, 1,

1469

9, 7, 7, 7, 3, 5, 7, 7, 7, 11,

1470

3, 5, 2, 2, 7, 7, 7, 7, 7, 7,

1471

5, 7, 9, 9, 3, 9, 5, 5, 3, 3,

1472

5, 5, 5, 5, 2, 1, 3, 3, 9, 5,

1473

5, 4, 5, 3, 0, 2, 3, 5 };

1474

int yychk[]={

1475

1476

-1000, -5, -30, -41, 267, -6, -7, 256, 269, 270,

1477

-11, -12, -1, -4, -36, 284, -13, 40, 285, -25,

1478

33, -8, 123, 258, 36, 47, -9, -10, 291, 292,

1479

257, 289, 290, 261, 262, 45, 43, 267, -30, -7,

1480

256, -31, -33, -41, -42, 59, -32, -33, -12, -33,

1481

-2, -36, -39, 124, 287, 288, 266, 286, 263, 60,

1482

62, 63, -4, 44, -19, -37, -20, 256, 125, -42,

1483

-36, -21, 275, 276, 277, 278, 279, -28, 282, 283,

1484

273, 274, -4, 271, 280, 281, -34, 265, 289, 290,

1485

-17, -4, 256, -24, -13, -25, -8, 33, 40, -13,

1486

94, 42, 47, 37, 43, 45, -30, 91, -9, -13,

1487

-40, 40, 40, 40, -13, -13, -8, -8, -12, -30,

1488

-12, -19, -4, 285, -4, -4, -4, 258, -4, -4,

1489

-4, -4, -30, -37, -20, 256, -38, -42, -30, -30,

1490

-37, -19, 40, -30, 40, -33, -33, 40, -16, -15,

1491

-3, 256, -13, 285, -25, 33, -8, -43, -23, -4,

1492

-44, 258, -33, 40, -29, 258, 257, -45, -39, 256,

1493

-35, 41, -35, -26, 60, -4, -8, -8, -8, -8,

1494

-8, -8, -17, -4, 259, -18, -17, -18, -18, -37,

1495

-24, 58, -38, -37, -4, -20, 258, -23, -17, -27,

1496

62, 264, 124, -39, 256, 287, 288, 266, 286, 263,

1497

63, -3, 265, -24, -25, -33, -33, -23, 91, -4,

1498

40, -4, -4, 256, -4, 286, -8, 93, 47, -35,

1499

-35, -35, -38, -4, -35, 275, 286, -42, -35, -33,

1500

-4, -4, -4, -3, 256, -3, -3, -3, -3, 258,

1501

-3, -3, -46, -26, -33, -17, -35, -22, -14, 258,

1502

256, 258, -30, 40, 258, -4, -42, -27, 58, -3,

1503

93, -30, -35, -39, 256, -20, -4, -35, -42, -23,

1504

-33, -3, -33, -20, -30, 258, 256, -35, -30, -23,

1505

-35, 272, -30, -20, -35, -30, -30, -30, -20, -20,

1506

-20 };

1507

int yydef[]={

1508

1509

59, -2, 0, 60, 57, -2, 2, 4, 6, 8,

1510

0, 13, 0, 21, 0, 18, 144, 0, 145, 100,

1511

0, 107, 59, 147, 0, 23, 122, 123, 0, 134,

1512

0, 0, 0, 138, 139, 0, 0, 58, 1, 3,

1513

5, 0, 10, 31, 59, 156, 0, 11, 12, 14,

1514

15, 0, 0, 0, 0, 0, 0, 0, 0, 0,

1515

0, 0, 108, 59, 0, 154, 27, 29, 59, 59,

1516

0, 36, 0, 59, 0, 0, 0, -2, 46, 74,

1517

49, 0, 0, 0, 53, 54, 0, 92, 142, 143,

1518

0, 86, 88, 61, 146, 101, 130, 0, 0, 144,

1519

0, 0, 0, 0, 0, 0, 151, 0, 149, 150,

1520

0, -2, -2, -2, 136, 137, 140, 141, 7, 32,

1521

9, 0, 22, 145, 97, 98, -2, 102, -2, -2,

1522

-2, 0, 157, 154, 28, 30, 26, 155, 152, 33,

1523

34, 0, 0, 0, 74, 42, 43, 0, 63, -2,

1524

78, 80, 144, 145, 114, 0, 120, 0, 0, 75,

1525

74, 0, 52, 0, 0, 16, 17, 0, 0, 89,

1526

0, 153, 131, 96, 0, 0, 124, 125, 126, 127,

1527

128, 129, 0, 86, 0, 0, -2, 0, 0, 154,

1528

95, 0, 25, 35, 0, 0, 147, 0, 0, 0,

1529

0, 0, 0, 0, 81, 0, 0, 0, 0, 0,

1530

0, 121, 109, 61, 115, 47, 48, 0, 0, 0,

1531

-2, 93, 87, 91, 90, 0, 62, 148, 24, 132,

1532

133, 135, 20, 106, 59, 0, 0, 0, 63, 45,

1533

64, 65, 66, 79, 83, 82, 111, 112, -2, 117,

1534

-2, 0, 0, 113, 50, 0, 59, 0, -2, 69,

1535

71, 94, 0, 0, 0, 0, 74, 0, 0, 110,

1536

0, 0, 59, 0, 72, 37, 0, 59, 74, 0,

1537

44, 119, 51, 55, 19, 70, 73, 59, 0, 0,

1538

59, 59, 38, 39, 59, 0, 0, 0, 41, 56,

1539

40 };

1540

typedef struct { char *t_name; int t_val; } yytoktype;

1541

#ifndef YYDEBUG

1542

# define YYDEBUG 0 /* don't allow debugging */

1543

#endif

1544

1545

#if YYDEBUG

1546

1547

yytoktype yytoks[] =

1548

{

1549

"FUNC_CALL", 257,

1550

"NAME", 258,

1551

"REGEXP", 259,

1552

"ERROR", 260,

1553

"YNUMBER", 261,

1554

"YSTRING", 262,

1555

"RELOP", 263,

1556

"APPEND_OP", 264,

1557

"ASSIGNOP", 265,

1558

"MATCHOP", 266,

1559

"NEWLINE", 267,

1560

"CONCAT_OP", 268,

1561

"LEX_BEGIN", 269,

1562

"LEX_END", 270,

1563

"LEX_IF", 271,

1564

"LEX_ELSE", 272,

1565

"LEX_RETURN", 273,

1566

"LEX_DELETE", 274,

1567

"LEX_WHILE", 275,

1568

"LEX_DO", 276,

1569

"LEX_FOR", 277,

1570

"LEX_BREAK", 278,

1571

"LEX_CONTINUE", 279,

1572

"LEX_PRINT", 280,

1573

"LEX_PRINTF", 281,

1574

"LEX_NEXT", 282,

1575

"LEX_EXIT", 283,

1576

"LEX_FUNCTION", 284,

1577

"LEX_GETLINE", 285,

1578

"LEX_IN", 286,

1579

"LEX_AND", 287,

1580

"LEX_OR", 288,

1581

"INCREMENT", 289,

1582

"DECREMENT", 290,

1583

"LEX_BUILTIN", 291,

1584

"LEX_LENGTH", 292,

1585

"?", 63,

1586

":", 58,

1587

"<", 60,

1588

">", 62,

1589

"|", 124,

1590

"+", 43,

1591

"-", 45,

1592

"*", 42,

1593

"/", 47,

1594

"%", 37,

1595

"!", 33,

1596

"UNARY", 293,

1597

"^", 94,

1598

"$", 36,

1599

"(", 40,

1600

")", 41,

1601

"-unknown-", -1 /* ends search */

1602

};

1603

1604

char * yyreds[] =

1605

{

1606

"-no such reduction-",

1607

"start : opt_nls program opt_nls",

1608

"program : rule",

1609

"program : program rule",

1610

"program : error",

1611

"program : program error",

1612

"rule : LEX_BEGIN",

1613

"rule : LEX_BEGIN action",

1614

"rule : LEX_END",

1615

"rule : LEX_END action",

1616

"rule : LEX_BEGIN statement_term",

1617

"rule : LEX_END statement_term",

1618

"rule : pattern action",

1619

"rule : action",

1620

"rule : pattern statement_term",

1621

"rule : function_prologue function_body",

1622

"func_name : NAME",

1623

"func_name : FUNC_CALL",

1624

"function_prologue : LEX_FUNCTION",

1625

"function_prologue : LEX_FUNCTION func_name '(' opt_param_list r_paren opt_nls",

1626

"function_body : l_brace statements r_brace opt_semi",

1627

"pattern : exp",

1628

"pattern : exp comma exp",

1629

"regexp : '/'",

1630

"regexp : '/' REGEXP '/'",

1631

"action : l_brace statements r_brace opt_semi",

1632

"action : l_brace r_brace opt_semi",

1633

"statements : statement",

1634

"statements : statements statement",

1635

"statements : error",

1636

"statements : statements error",

1637

"statement_term : nls",

1638

"statement_term : semi opt_nls",

1639

"statement : semi opt_nls",

1640

"statement : l_brace r_brace",

1641

"statement : l_brace statements r_brace",

1642

"statement : if_statement",

1643

"statement : LEX_WHILE '(' exp r_paren opt_nls statement",

1644

"statement : LEX_DO opt_nls statement LEX_WHILE '(' exp r_paren opt_nls",

1645

"statement : LEX_FOR '(' NAME LEX_IN NAME r_paren opt_nls statement",

1646

"statement : LEX_FOR '(' opt_exp semi exp semi opt_exp r_paren opt_nls statement",

1647

"statement : LEX_FOR '(' opt_exp semi semi opt_exp r_paren opt_nls statement",

1648

"statement : LEX_BREAK statement_term",

1649

"statement : LEX_CONTINUE statement_term",

1650

"statement : print '(' expression_list r_paren output_redir statement_term",

1651

"statement : print opt_rexpression_list output_redir statement_term",

1652

"statement : LEX_NEXT",

1653

"statement : LEX_NEXT statement_term",

1654

"statement : LEX_EXIT opt_exp statement_term",

1655

"statement : LEX_RETURN",

1656

"statement : LEX_RETURN opt_exp statement_term",

1657

"statement : LEX_DELETE NAME '[' expression_list ']' statement_term",

1658

"statement : exp statement_term",

1659

"print : LEX_PRINT",

1660

"print : LEX_PRINTF",

1661

"if_statement : LEX_IF '(' exp r_paren opt_nls statement",

1662

"if_statement : LEX_IF '(' exp r_paren opt_nls statement LEX_ELSE opt_nls statement",

1663

"nls : NEWLINE",

1664

"nls : nls NEWLINE",

1665

"opt_nls : /* empty */",

1666

"opt_nls : nls",

1667

"input_redir : /* empty */",

1668

"input_redir : '<' simp_exp",

1669

"output_redir : /* empty */",

1670

"output_redir : '>' exp",

1671

"output_redir : APPEND_OP exp",

1672

"output_redir : '|' exp",

1673

"opt_param_list : /* empty */",

1674

"opt_param_list : param_list",

1675

"param_list : NAME",

1676

"param_list : param_list comma NAME",

1677

"param_list : error",

1678

"param_list : param_list error",

1679

"param_list : param_list comma error",

1680

"opt_exp : /* empty */",

1681

"opt_exp : exp",

1682

"opt_rexpression_list : /* empty */",

1683

"opt_rexpression_list : rexpression_list",

1684

"rexpression_list : rexp",

1685

"rexpression_list : rexpression_list comma rexp",

1686

"rexpression_list : error",

1687

"rexpression_list : rexpression_list error",

1688

"rexpression_list : rexpression_list error rexp",

1689

"rexpression_list : rexpression_list comma error",

1690

"opt_expression_list : /* empty */",

1691

"opt_expression_list : expression_list",

1692

"expression_list : exp",

1693

"expression_list : expression_list comma exp",

1694

"expression_list : error",

1695

"expression_list : expression_list error",

1696

"expression_list : expression_list error exp",

1697

"expression_list : expression_list comma error",

1698

"exp : variable ASSIGNOP",

1699

"exp : variable ASSIGNOP exp",

1700

"exp : '(' expression_list r_paren LEX_IN NAME",

1701

"exp : exp '|' LEX_GETLINE opt_variable",

1702

"exp : LEX_GETLINE opt_variable input_redir",

1703

"exp : exp LEX_AND exp",

1704

"exp : exp LEX_OR exp",

1705

"exp : exp MATCHOP exp",

1706

"exp : regexp",

1707

"exp : '!' regexp",

1708

"exp : exp LEX_IN NAME",

1709

"exp : exp RELOP exp",

1710

"exp : exp '<' exp",

1711

"exp : exp '>' exp",

1712

"exp : exp '?' exp ':' exp",

1713

"exp : simp_exp",

1714

"exp : exp exp",

1715

"rexp : variable ASSIGNOP",

1716

"rexp : variable ASSIGNOP rexp",

1717

"rexp : rexp LEX_AND rexp",

1718

"rexp : rexp LEX_OR rexp",

1719

"rexp : LEX_GETLINE opt_variable input_redir",

1720

"rexp : regexp",

1721

"rexp : '!' regexp",

1722

"rexp : rexp MATCHOP rexp",

1723

"rexp : rexp LEX_IN NAME",

1724

"rexp : rexp RELOP rexp",

1725

"rexp : rexp '?' rexp ':' rexp",

1726

"rexp : simp_exp",

1727

"rexp : rexp rexp",

1728

"simp_exp : non_post_simp_exp",

1729

"simp_exp : post_inc_dec_exp",

1730

"simp_exp : simp_exp '^' simp_exp",

1731

"simp_exp : simp_exp '*' simp_exp",

1732

"simp_exp : simp_exp '/' simp_exp",

1733

"simp_exp : simp_exp '%' simp_exp",

1734

"simp_exp : simp_exp '+' simp_exp",

1735

"simp_exp : simp_exp '-' simp_exp",

1736

"non_post_simp_exp : '!' simp_exp",

1737

"non_post_simp_exp : '(' exp r_paren",

1738

"non_post_simp_exp : LEX_BUILTIN '(' opt_expression_list r_paren",

1739

"non_post_simp_exp : LEX_LENGTH '(' opt_expression_list r_paren",

1740

"non_post_simp_exp : LEX_LENGTH",

1741

"non_post_simp_exp : FUNC_CALL '(' opt_expression_list r_paren",

1742

"non_post_simp_exp : INCREMENT variable",

1743

"non_post_simp_exp : DECREMENT variable",

1744

"non_post_simp_exp : YNUMBER",

1745

"non_post_simp_exp : YSTRING",

1746

"non_post_simp_exp : '-' simp_exp",

1747

"non_post_simp_exp : '+' simp_exp",

1748

"post_inc_dec_exp : variable INCREMENT",

1749

"post_inc_dec_exp : variable DECREMENT",

1750

"post_inc_dec_exp : variable",

1751

"opt_variable : /* empty */",

1752

"opt_variable : variable",

1753

"variable : NAME",

1754

"variable : NAME '[' expression_list ']'",

1755

"variable : '$' non_post_simp_exp",

1756

"variable : '$' variable",

1757

"l_brace : '{' opt_nls",

1758

"r_brace : '}' opt_nls",

1759

"r_paren : ')'",

1760

"opt_semi : /* empty */",

1761

"opt_semi : semi",

1762

"semi : ';'",

1763

"comma : ',' opt_nls",

1764

};

1765

#endif /* YYDEBUG */

1766

#line 1 "/usr/lib/yaccpar"

1767

/* @(#)yaccpar 1.10 89/04/04 SMI; from S5R3 1.10 */

1768

1769

/*

1770

** Skeleton parser driver for yacc output

1771

*/

1772

1773

/*

1774

** yacc user known macros and defines

1775

*/

1776

#define YYERROR goto yyerrlab

1777

#define YYACCEPT { free(yys); free(yyv); return(0); }

1778

#define YYABORT { free(yys); free(yyv); return(1); }

1779

#define YYBACKUP( newtoken, newvalue )\

1780

{\

1781

if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\

1782

{\

1783

yyerror( "syntax error - cannot backup" );\

1784

goto yyerrlab;\

1785

}\

1786

yychar = newtoken;\

1787

yystate = *yyps;\

1788

yylval = newvalue;\

1789

goto yynewstate;\

1790

}

1791

#define YYRECOVERING() (!!yyerrflag)

1792

#ifndef YYDEBUG

1793

# define YYDEBUG 1 /* make debugging available */

1794

#endif

1795

1796

/*

1797

** user known globals

1798

*/

1799

int yydebug; /* set to 1 to get debugging */

1800

1801

/*

1802

** driver internal defines

1803

*/

1804

#define YYFLAG (-1000)

1805

1806

/*

1807

** static variables used by the parser

1808

*/

1809

static YYSTYPE *yyv; /* value stack */

1810

static int *yys; /* state stack */

1811

1812

static YYSTYPE *yypv; /* top of value stack */

1813

static int *yyps; /* top of state stack */

1814

1815

static int yystate; /* current state */

1816

static int yytmp; /* extra var (lasts between blocks) */

1817

1818

int yynerrs; /* number of errors */

1819

1820

int yyerrflag; /* error recovery flag */

1821

int yychar; /* current input token number */

1822

1823

1824

/*

1825

** yyparse - return 0 if worked, 1 if syntax error not recovered from

1826

*/

1827

int

1828

yyparse()

1829

{

1830

register YYSTYPE *yypvt; /* top of value stack for $vars */

1831

unsigned yymaxdepth = YYMAXDEPTH;

1832

1833

/*

1834

** Initialize externals - yyparse may be called more than once

1835

*/

1836

yyv = (YYSTYPE*)malloc(yymaxdepth*sizeof(YYSTYPE));

1837

yys = (int*)malloc(yymaxdepth*sizeof(int));

1838

if (!yyv || !yys)

1839

{

1840

yyerror( "out of memory" );

1841

return(1);

1842

}

1843

yypv = &yyv[-1];

1844

yyps = &yys[-1];

1845

yystate = 0;

1846

yytmp = 0;

1847

yynerrs = 0;

1848

yyerrflag = 0;

1849

yychar = -1;

1850

1851

goto yystack;

1852

{

1853

register YYSTYPE *yy_pv; /* top of value stack */

1854

register int *yy_ps; /* top of state stack */

1855

register int yy_state; /* current state */

1856

register int yy_n; /* internal state number info */

1857

1858

/*

1859

** get globals into registers.

1860

** branch to here only if YYBACKUP was called.

1861

*/

1862

yynewstate:

1863

yy_pv = yypv;

1864

yy_ps = yyps;

1865

yy_state = yystate;

1866

goto yy_newstate;

1867

1868

/*

1869

** get globals into registers.

1870

** either we just started, or we just finished a reduction

1871

*/

1872

yystack:

1873

yy_pv = yypv;

1874

yy_ps = yyps;

1875

yy_state = yystate;

1876

1877

/*

1878

** top of for (;;) loop while no reductions done

1879

*/

1880

yy_stack:

1881

/*

1882

** put a state and value onto the stacks

1883

*/

1884

#if YYDEBUG

1885

/*

1886

** if debugging, look up token value in list of value vs.

1887

** name pairs. 0 and negative (-1) are special values.

1888

** Note: linear search is used since time is not a real

1889

** consideration while debugging.

1890

*/

1891

if ( yydebug )

1892

{

1893

register int yy_i;

1894

1895

(void)printf( "State %d, token ", yy_state );

1896

if ( yychar == 0 )

1897

(void)printf( "end-of-file\n" );

1898

else if ( yychar < 0 )

1899

(void)printf( "-none-\n" );

1900

else

1901

{

1902

for ( yy_i = 0; yytoks[yy_i].t_val >= 0;

1903

yy_i++ )

1904

{

1905

if ( yytoks[yy_i].t_val == yychar )

1906

break;

1907

}

1908

(void)printf( "%s\n", yytoks[yy_i].t_name );

1909

}

1910

}

1911

#endif /* YYDEBUG */

1912

if ( ++yy_ps >= &yys[ yymaxdepth ] ) /* room on stack? */

1913

{

1914

/*

1915

** reallocate and recover. Note that pointers

1916

** have to be reset, or bad things will happen

1917

*/

1918

int yyps_index = (yy_ps - yys);

1919

int yypv_index = (yy_pv - yyv);

1920

int yypvt_index = (yypvt - yyv);

1921

yymaxdepth += YYMAXDEPTH;

1922

yyv = (YYSTYPE*)realloc((char*)yyv,

1923

yymaxdepth * sizeof(YYSTYPE));

1924

yys = (int*)realloc((char*)yys,

1925

yymaxdepth * sizeof(int));

1926

if (!yyv || !yys)

1927

{

1928

yyerror( "yacc stack overflow" );

1929

return(1);

1930

}

1931

yy_ps = yys + yyps_index;

1932

yy_pv = yyv + yypv_index;

1933

yypvt = yyv + yypvt_index;

1934

}

1935

*yy_ps = yy_state;

1936

*++yy_pv = yyval;

1937

1938

/*

1939

** we have a new state - find out what to do

1940

*/

1941

yy_newstate:

1942

if ( ( yy_n = yypact[ yy_state ] ) <= YYFLAG )

1943

goto yydefault; /* simple state */

1944

#if YYDEBUG

1945

/*

1946

** if debugging, need to mark whether new token grabbed

1947

*/

1948

yytmp = yychar < 0;

1949

#endif

1950

if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) )

1951

yychar = 0; /* reached EOF */

1952

#if YYDEBUG

1953

if ( yydebug && yytmp )

1954

{

1955

register int yy_i;

1956

1957

(void)printf( "Received token " );

1958

if ( yychar == 0 )

1959

(void)printf( "end-of-file\n" );

1960

else if ( yychar < 0 )

1961

(void)printf( "-none-\n" );

1962

else

1963

{

1964

for ( yy_i = 0; yytoks[yy_i].t_val >= 0;

1965

yy_i++ )

1966

{

1967

if ( yytoks[yy_i].t_val == yychar )

1968

break;

1969

}

1970

(void)printf( "%s\n", yytoks[yy_i].t_name );

1971

}

1972

}

1973

#endif /* YYDEBUG */

1974

if ( ( ( yy_n += yychar ) < 0 ) || ( yy_n >= YYLAST ) )

1975

goto yydefault;

1976

if ( yychk[ yy_n = yyact[ yy_n ] ] == yychar ) /*valid shift*/

1977

{

1978

yychar = -1;

1979

yyval = yylval;

1980

yy_state = yy_n;

1981

if ( yyerrflag > 0 )

1982

yyerrflag--;

1983

goto yy_stack;

1984

}

1985

1986

yydefault:

1987

if ( ( yy_n = yydef[ yy_state ] ) == -2 )

1988

{

1989

#if YYDEBUG

1990

yytmp = yychar < 0;

1991

#endif

1992

if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) )

1993

yychar = 0; /* reached EOF */

1994

#if YYDEBUG

1995

if ( yydebug && yytmp )

1996

{

1997

register int yy_i;

1998

1999

(void)printf( "Received token " );

2000

if ( yychar == 0 )

2001

(void)printf( "end-of-file\n" );

2002

else if ( yychar < 0 )

2003

(void)printf( "-none-\n" );

2004

else

2005

{

2006

for ( yy_i = 0;

2007

yytoks[yy_i].t_val >= 0;

2008

yy_i++ )

2009

{

2010

if ( yytoks[yy_i].t_val

2011

== yychar )

2012

{

2013

break;

2014

}

2015

}

2016

(void)printf( "%s\n", yytoks[yy_i].t_name );

2017

}

2018

}

2019

#endif /* YYDEBUG */

2020

/*

2021

** look through exception table

2022

*/

2023

{

2024

register int *yyxi = yyexca;

2025

2026

while ( ( *yyxi != -1 ) ||

2027

( yyxi[1] != yy_state ) )

2028

{

2029

yyxi += 2;

2030

}

2031

while ( ( *(yyxi += 2) >= 0 ) &&

2032

( *yyxi != yychar ) )

2033

;

2034

if ( ( yy_n = yyxi[1] ) < 0 )

2035

YYACCEPT;

2036

}

2037

}

2038

2039

/*

2040

** check for syntax error

2041

*/

2042

if ( yy_n == 0 ) /* have an error */

2043

{

2044

/* no worry about speed here! */

2045

switch ( yyerrflag )

2046

{

2047

case 0: /* new error */

2048

yyerror( "syntax error" );

2049

goto skip_init;

2050

yyerrlab:

2051

/*

2052

** get globals into registers.

2053

** we have a user generated syntax type error

2054

*/

2055

yy_pv = yypv;

2056

yy_ps = yyps;

2057

yy_state = yystate;

2058

yynerrs++;

2059

skip_init:

2060

case 1:

2061

case 2: /* incompletely recovered error */

2062

/* try again... */

2063

yyerrflag = 3;

2064

/*

2065

** find state where "error" is a legal

2066

** shift action

2067

*/

2068

while ( yy_ps >= yys )

2069

{

2070

yy_n = yypact[ *yy_ps ] + YYERRCODE;

2071

if ( yy_n >= 0 && yy_n < YYLAST &&

2072

yychk[yyact[yy_n]] == YYERRCODE) {

2073

/*

2074

** simulate shift of "error"

2075

*/

2076

yy_state = yyact[ yy_n ];

2077

goto yy_stack;

2078

}

2079

/*

2080

** current state has no shift on

2081

** "error", pop stack

2082

*/

2083

#if YYDEBUG

2084

# define _POP_ "Error recovery pops state %d, uncovers state %d\n"

2085

if ( yydebug )

2086

(void)printf( _POP_, *yy_ps,

2087

yy_ps[-1] );

2088

# undef _POP_

2089

#endif

2090

yy_ps--;

2091

yy_pv--;

2092

}

2093

/*

2094

** there is no state on stack with "error" as

2095

** a valid shift. give up.

2096

*/

2097

YYABORT;

2098

case 3: /* no shift yet; eat a token */

2099

#if YYDEBUG

2100

/*

2101

** if debugging, look up token in list of

2102

** pairs. 0 and negative shouldn't occur,

2103

** but since timing doesn't matter when

2104

** debugging, it doesn't hurt to leave the

2105

** tests here.

2106

*/

2107

if ( yydebug )

2108

{

2109

register int yy_i;

2110

2111

(void)printf( "Error recovery discards " );

2112

if ( yychar == 0 )

2113

(void)printf( "token end-of-file\n" );

2114

else if ( yychar < 0 )

2115

(void)printf( "token -none-\n" );

2116

else

2117

{

2118

for ( yy_i = 0;

2119

yytoks[yy_i].t_val >= 0;

2120

yy_i++ )

2121

{

2122

if ( yytoks[yy_i].t_val

2123

== yychar )

2124

{

2125

break;

2126

}

2127

}

2128

(void)printf( "token %s\n",

2129

yytoks[yy_i].t_name );

2130

}

2131

}

2132

#endif /* YYDEBUG */

2133

if ( yychar == 0 ) /* reached EOF. quit */

2134

YYABORT;

2135

yychar = -1;

2136

goto yy_newstate;

2137

}

2138

}/* end if ( yy_n == 0 ) */

2139

/*

2140

** reduction by production yy_n

2141

** put stack tops, etc. so things right after switch

2142

*/

2143

#if YYDEBUG

2144

/*

2145

** if debugging, print the string that is the user's

2146

** specification of the reduction which is just about

2147

** to be done.

2148

*/

2149

if ( yydebug )

2150

(void)printf( "Reduce by (%d) \"%s\"\n",

2151

yy_n, yyreds[ yy_n ] );

2152

#endif

2153

yytmp = yy_n; /* value to switch over */

2154

yypvt = yy_pv; /* $vars top of value stack */

2155

/*

2156

** Look in goto table for next state

2157

** Sorry about using yy_state here as temporary

2158

** register variable, but why not, if it works...

2159

** If yyr2[ yy_n ] doesn't have the low order bit

2160

** set, then there is no action to be done for

2161

** this reduction. So, no saving & unsaving of

2162

** registers done. The only difference between the

2163

** code just after the if and the body of the if is

2164

** the goto yy_stack in the body. This way the test

2165

** can be made before the choice of what to do is needed.

2166

*/

2167

{

2168

/* length of production doubled with extra bit */

2169

register int yy_len = yyr2[ yy_n ];

2170

2171

if ( !( yy_len & 01 ) )

2172

{

2173

yy_len >>= 1;

2174

yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */

2175

yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +

2176

*( yy_ps -= yy_len ) + 1;

2177

if ( yy_state >= YYLAST ||

2178

yychk[ yy_state =

2179

yyact[ yy_state ] ] != -yy_n )

2180

{

2181

yy_state = yyact[ yypgo[ yy_n ] ];

2182

}

2183

goto yy_stack;

2184

}

2185

yy_len >>= 1;

2186

yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */

2187

yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +

2188

*( yy_ps -= yy_len ) + 1;

2189

if ( yy_state >= YYLAST ||

2190

yychk[ yy_state = yyact[ yy_state ] ] != -yy_n )

2191

{

2192

yy_state = yyact[ yypgo[ yy_n ] ];

2193

}

2194

}

2195

/* save until reenter driver code */

2196

yystate = yy_state;

2197

yyps = yy_ps;

2198

yypv = yy_pv;

2199

}

2200

/*

2201

** code supplied by user is placed in this switch

2202

*/

2203

switch( yytmp )

2204

{

2205

2206

case 1:

2207

# line 135 "awk.y"

2208

{ expression_value = yypvt[-1].nodeval; } break;

2209

case 2:

2210

# line 140 "awk.y"

2211

{

2212

if (yypvt[-0].nodeval != NULL)

2213

yyval.nodeval = yypvt[-0].nodeval;

2214

else

2215

yyval.nodeval = NULL;

2216

yyerrok;

2217

} break;

2218

case 3:

2219

# line 149 "awk.y"

2220

{

2221

if (yypvt[-0].nodeval == NULL)

2222

yyval.nodeval = yypvt[-1].nodeval;

2223

else if (yypvt[-1].nodeval == NULL)

2224

yyval.nodeval = yypvt[-0].nodeval;

2225

else {

2226

if (yypvt[-1].nodeval->type != Node_rule_list)

2227

yypvt[-1].nodeval = node(yypvt[-1].nodeval, Node_rule_list,

2228

(NODE*)NULL);

2229

yyval.nodeval = append_right (yypvt[-1].nodeval,

2230

node(yypvt[-0].nodeval, Node_rule_list,(NODE *) NULL));

2231

}

2232

yyerrok;

2233

} break;

2234

case 4:

2235

# line 163 "awk.y"

2236

{ yyval.nodeval = NULL; } break;

2237

case 5:

2238

# line 164 "awk.y"

2239

{ yyval.nodeval = NULL; } break;

2240

case 6:

2241

# line 168 "awk.y"

2242

{ io_allowed = 0; } break;

2243

case 7:

2244

# line 170 "awk.y"

2245

{

2246

if (begin_block) {

2247

if (begin_block->type != Node_rule_list)

2248

begin_block = node(begin_block, Node_rule_list,

2249

(NODE *)NULL);

2250

(void) append_right (begin_block, node(

2251

node((NODE *)NULL, Node_rule_node, yypvt[-0].nodeval),

2252

Node_rule_list, (NODE *)NULL) );

2253

} else

2254

begin_block = node((NODE *)NULL, Node_rule_node, yypvt[-0].nodeval);

2255

yyval.nodeval = NULL;

2256

io_allowed = 1;

2257

yyerrok;

2258

} break;

2259

case 8:

2260

# line 184 "awk.y"

2261

{ io_allowed = 0; } break;

2262

case 9:

2263

# line 186 "awk.y"

2264

{

2265

if (end_block) {

2266

if (end_block->type != Node_rule_list)

2267

end_block = node(end_block, Node_rule_list,

2268

(NODE *)NULL);

2269

(void) append_right (end_block, node(

2270

node((NODE *)NULL, Node_rule_node, yypvt[-0].nodeval),

2271

Node_rule_list, (NODE *)NULL));

2272

} else

2273

end_block = node((NODE *)NULL, Node_rule_node, yypvt[-0].nodeval);

2274

yyval.nodeval = NULL;

2275

io_allowed = 1;

2276

yyerrok;

2277

} break;

2278

case 10:

2279

# line 201 "awk.y"

2280

{

2281

warning("BEGIN blocks must have an action part");

2282

errcount++;

2283

yyerrok;

2284

} break;

2285

case 11:

2286

# line 207 "awk.y"

2287

{

2288

warning("END blocks must have an action part");

2289

errcount++;

2290

yyerrok;

2291

} break;

2292

case 12:

2293

# line 213 "awk.y"

2294

{ yyval.nodeval = node (yypvt[-1].nodeval, Node_rule_node, yypvt[-0].nodeval); yyerrok; } break;

2295

case 13:

2296

# line 215 "awk.y"

2297

{ yyval.nodeval = node ((NODE *)NULL, Node_rule_node, yypvt[-0].nodeval); yyerrok; } break;

2298

case 14:

2299

# line 217 "awk.y"

2300

{

2301

yyval.nodeval = node (yypvt[-1].nodeval,

2302

Node_rule_node,

2303

node(node(node(make_number(0.0),

2304

Node_field_spec,

2305

(NODE *) NULL),

2306

Node_expression_list,

2307

(NODE *) NULL),

2308

Node_K_print,

2309

(NODE *) NULL));

2310

yyerrok;

2311

} break;

2312

case 15:

2313

# line 230 "awk.y"

2314

{

2315

func_install(yypvt[-1].nodeval, yypvt[-0].nodeval);

2316

yyval.nodeval = NULL;

2317

yyerrok;

2318

} break;

2319

case 16:

2320

# line 239 "awk.y"

2321

{ yyval.sval = yypvt[-0].sval; } break;

2322

case 17:

2323

# line 241 "awk.y"

2324

{ yyval.sval = yypvt[-0].sval; } break;

2325

case 18:

2326

# line 246 "awk.y"

2327

{

2328

param_counter = 0;

2329

} break;

2330

case 19:

2331

# line 250 "awk.y"

2332

{

2333

yyval.nodeval = append_right(make_param(yypvt[-4].sval), yypvt[-2].nodeval);

2334

can_return = 1;

2335

} break;

2336

case 20:

2337

# line 258 "awk.y"

2338

{

2339

yyval.nodeval = yypvt[-2].nodeval;

2340

can_return = 0;

2341

} break;

2342

case 21:

2343

# line 267 "awk.y"

2344

{ yyval.nodeval = yypvt[-0].nodeval; } break;

2345

case 22:

2346

# line 269 "awk.y"

2347

{ yyval.nodeval = mkrangenode ( node(yypvt[-2].nodeval, Node_cond_pair, yypvt[-0].nodeval) ); } break;

2348

case 23:

2349

# line 278 "awk.y"

2350

{ ++want_regexp; } break;

2351

case 24:

2352

# line 280 "awk.y"

2353

{

2354

NODE *n;

2355

2356

getnode(n);

2357

n->type = Node_regex;

2358

n->re_exp = make_string(yypvt[-1].sval, strlen(yypvt[-1].sval));

2359

n->re_reg = mk_re_parse(yypvt[-1].sval, 0);

2360

n->re_text = NULL;

2361

n->re_flags = CONST;

2362

n->re_cnt = 1;

2363

yyval.nodeval = n;

2364

} break;

2365

case 25:

2366

# line 296 "awk.y"

2367

{ yyval.nodeval = yypvt[-2].nodeval ; } break;

2368

case 26:

2369

# line 298 "awk.y"

2370

{ yyval.nodeval = NULL; } break;

2371

case 27:

2372

# line 303 "awk.y"

2373

{ yyval.nodeval = yypvt[-0].nodeval; } break;

2374

case 28:

2375

# line 305 "awk.y"

2376

{

2377

if (yypvt[-1].nodeval == NULL || yypvt[-1].nodeval->type != Node_statement_list)

2378

yypvt[-1].nodeval = node(yypvt[-1].nodeval, Node_statement_list,(NODE *)NULL);

2379

yyval.nodeval = append_right(yypvt[-1].nodeval,

2380

node( yypvt[-0].nodeval, Node_statement_list, (NODE *)NULL));

2381

yyerrok;

2382

} break;

2383

case 29:

2384

# line 313 "awk.y"

2385

{ yyval.nodeval = NULL; } break;

2386

case 30:

2387

# line 315 "awk.y"

2388

{ yyval.nodeval = NULL; } break;

2389

case 33:

2390

# line 325 "awk.y"

2391

{ yyval.nodeval = NULL; } break;

2392

case 34:

2393

# line 327 "awk.y"

2394

{ yyval.nodeval = NULL; } break;

2395

case 35:

2396

# line 329 "awk.y"

2397

{ yyval.nodeval = yypvt[-1].nodeval; } break;

2398

case 36:

2399

# line 331 "awk.y"

2400

{ yyval.nodeval = yypvt[-0].nodeval; } break;

2401

case 37:

2402

# line 333 "awk.y"

2403

{ yyval.nodeval = node (yypvt[-3].nodeval, Node_K_while, yypvt[-0].nodeval); } break;

2404

case 38:

2405

# line 335 "awk.y"

2406

{ yyval.nodeval = node (yypvt[-2].nodeval, Node_K_do, yypvt[-5].nodeval); } break;

2407

case 39:

2408

# line 337 "awk.y"

2409

{

2410

yyval.nodeval = node (yypvt[-0].nodeval, Node_K_arrayfor, make_for_loop(variable(yypvt[-5].sval,1),

2411

(NODE *)NULL, variable(yypvt[-3].sval,1)));

2412

} break;

2413

case 40:

2414

# line 342 "awk.y"

2415

{

2416

yyval.nodeval = node(yypvt[-0].nodeval, Node_K_for, (NODE *)make_for_loop(yypvt[-7].nodeval, yypvt[-5].nodeval, yypvt[-3].nodeval));

2417

} break;

2418

case 41:

2419

# line 346 "awk.y"

2420

{

2421

yyval.nodeval = node (yypvt[-0].nodeval, Node_K_for,

2422

(NODE *)make_for_loop(yypvt[-6].nodeval, (NODE *)NULL, yypvt[-3].nodeval));

2423

} break;

2424

case 42:

2425

# line 352 "awk.y"

2426

{ yyval.nodeval = node ((NODE *)NULL, Node_K_break, (NODE *)NULL); } break;

2427

case 43:

2428

# line 355 "awk.y"

2429

{ yyval.nodeval = node ((NODE *)NULL, Node_K_continue, (NODE *)NULL); } break;

2430

case 44:

2431

# line 357 "awk.y"

2432

{ yyval.nodeval = node (yypvt[-3].nodeval, yypvt[-5].nodetypeval, yypvt[-1].nodeval); } break;

2433

case 45:

2434

# line 359 "awk.y"

2435

{

2436

if (yypvt[-3].nodetypeval == Node_K_print && yypvt[-2].nodeval == NULL)

2437

yypvt[-2].nodeval = node(node(make_number(0.0),

2438

Node_field_spec,

2439

(NODE *) NULL),

2440

Node_expression_list,

2441

(NODE *) NULL);

2442

2443

yyval.nodeval = node (yypvt[-2].nodeval, yypvt[-3].nodetypeval, yypvt[-1].nodeval);

2444

} break;

2445

case 46:

2446

# line 370 "awk.y"

2447

{ if (! io_allowed) yyerror("next used in BEGIN or END action"); } break;

2448

case 47:

2449

# line 372 "awk.y"

2450

{ yyval.nodeval = node ((NODE *)NULL, Node_K_next, (NODE *)NULL); } break;

2451

case 48:

2452

# line 374 "awk.y"

2453

{ yyval.nodeval = node (yypvt[-1].nodeval, Node_K_exit, (NODE *)NULL); } break;

2454

case 49:

2455

# line 376 "awk.y"

2456

{ if (! can_return) yyerror("return used outside function context"); } break;

2457

case 50:

2458

# line 378 "awk.y"

2459

{ yyval.nodeval = node (yypvt[-1].nodeval, Node_K_return, (NODE *)NULL); } break;

2460

case 51:

2461

# line 380 "awk.y"

2462

{ yyval.nodeval = node (variable(yypvt[-4].sval,1), Node_K_delete, yypvt[-2].nodeval); } break;

2463

case 52:

2464

# line 382 "awk.y"

2465

{ yyval.nodeval = yypvt[-1].nodeval; } break;

2466

case 53:

2467

# line 387 "awk.y"

2468

{ yyval.nodetypeval = yypvt[-0].nodetypeval; } break;

2469

case 54:

2470

# line 389 "awk.y"

2471

{ yyval.nodetypeval = yypvt[-0].nodetypeval; } break;

2472

case 55:

2473

# line 394 "awk.y"

2474

{

2475

yyval.nodeval = node(yypvt[-3].nodeval, Node_K_if,

2476

node(yypvt[-0].nodeval, Node_if_branches, (NODE *)NULL));

2477

} break;

2478

case 56:

2479

# line 400 "awk.y"

2480

{ yyval.nodeval = node (yypvt[-6].nodeval, Node_K_if,

2481

node (yypvt[-3].nodeval, Node_if_branches, yypvt[-0].nodeval)); } break;

2482

case 57:

2483

# line 406 "awk.y"

2484

{ want_assign = 0; } break;

2485

case 61:

2486

# line 417 "awk.y"

2487

{ yyval.nodeval = NULL; } break;

2488

case 62:

2489

# line 419 "awk.y"

2490

{ yyval.nodeval = node (yypvt[-0].nodeval, Node_redirect_input, (NODE *)NULL); } break;

2491

case 63:

2492

# line 424 "awk.y"

2493

{ yyval.nodeval = NULL; } break;

2494

case 64:

2495

# line 426 "awk.y"

2496

{ yyval.nodeval = node (yypvt[-0].nodeval, Node_redirect_output, (NODE *)NULL); } break;

2497

case 65:

2498

# line 428 "awk.y"

2499

{ yyval.nodeval = node (yypvt[-0].nodeval, Node_redirect_append, (NODE *)NULL); } break;

2500

case 66:

2501

# line 430 "awk.y"

2502

{ yyval.nodeval = node (yypvt[-0].nodeval, Node_redirect_pipe, (NODE *)NULL); } break;

2503

case 67:

2504

# line 435 "awk.y"

2505

{ yyval.nodeval = NULL; } break;

2506

case 68:

2507

# line 437 "awk.y"

2508

{ yyval.nodeval = yypvt[-0].nodeval; } break;

2509

case 69:

2510

# line 442 "awk.y"

2511

{ yyval.nodeval = make_param(yypvt[-0].sval); } break;

2512

case 70:

2513

# line 444 "awk.y"

2514

{ yyval.nodeval = append_right(yypvt[-2].nodeval, make_param(yypvt[-0].sval)); yyerrok; } break;

2515

case 71:

2516

# line 446 "awk.y"

2517

{ yyval.nodeval = NULL; } break;

2518

case 72:

2519

# line 448 "awk.y"

2520

{ yyval.nodeval = NULL; } break;

2521

case 73:

2522

# line 450 "awk.y"

2523

{ yyval.nodeval = NULL; } break;

2524

case 74:

2525

# line 456 "awk.y"

2526

{ yyval.nodeval = NULL; } break;

2527

case 75:

2528

# line 458 "awk.y"

2529

{ yyval.nodeval = yypvt[-0].nodeval; } break;

2530

case 76:

2531

# line 463 "awk.y"

2532

{ yyval.nodeval = NULL; } break;

2533

case 77:

2534

# line 465 "awk.y"

2535

{ yyval.nodeval = yypvt[-0].nodeval; } break;

2536

case 78:

2537

# line 470 "awk.y"

2538

{ yyval.nodeval = node (yypvt[-0].nodeval, Node_expression_list, (NODE *)NULL); } break;

2539

case 79:

2540

# line 472 "awk.y"

2541

{

2542

yyval.nodeval = append_right(yypvt[-2].nodeval,

2543

node( yypvt[-0].nodeval, Node_expression_list, (NODE *)NULL));

2544

yyerrok;

2545

} break;

2546

case 80:

2547

# line 478 "awk.y"

2548

{ yyval.nodeval = NULL; } break;

2549

case 81:

2550

# line 480 "awk.y"

2551

{ yyval.nodeval = NULL; } break;

2552

case 82:

2553

# line 482 "awk.y"

2554

{ yyval.nodeval = NULL; } break;

2555

case 83:

2556

# line 484 "awk.y"

2557

{ yyval.nodeval = NULL; } break;

2558

case 84:

2559

# line 489 "awk.y"

2560

{ yyval.nodeval = NULL; } break;

2561

case 85:

2562

# line 491 "awk.y"

2563

{ yyval.nodeval = yypvt[-0].nodeval; } break;

2564

case 86:

2565

# line 496 "awk.y"

2566

{ yyval.nodeval = node (yypvt[-0].nodeval, Node_expression_list, (NODE *)NULL); } break;

2567

case 87:

2568

# line 498 "awk.y"

2569

{

2570

yyval.nodeval = append_right(yypvt[-2].nodeval,

2571

node( yypvt[-0].nodeval, Node_expression_list, (NODE *)NULL));

2572

yyerrok;

2573

} break;

2574

case 88:

2575

# line 504 "awk.y"

2576

{ yyval.nodeval = NULL; } break;

2577

case 89:

2578

# line 506 "awk.y"

2579

{ yyval.nodeval = NULL; } break;

2580

case 90:

2581

# line 508 "awk.y"

2582

{ yyval.nodeval = NULL; } break;

2583

case 91:

2584

# line 510 "awk.y"

2585

{ yyval.nodeval = NULL; } break;

2586

case 92:

2587

# line 515 "awk.y"

2588

{ want_assign = 0; } break;

2589

case 93:

2590

# line 517 "awk.y"

2591

{ yyval.nodeval = node (yypvt[-3].nodeval, yypvt[-2].nodetypeval, yypvt[-0].nodeval); } break;

2592

case 94:

2593

# line 519 "awk.y"

2594

{ yyval.nodeval = node (variable(yypvt[-0].sval,1), Node_in_array, yypvt[-3].nodeval); } break;

2595

case 95:

2596

# line 521 "awk.y"

2597

{

2598

yyval.nodeval = node (yypvt[-0].nodeval, Node_K_getline,

2599

node (yypvt[-3].nodeval, Node_redirect_pipein, (NODE *)NULL));

2600

} break;

2601

case 96:

2602

# line 526 "awk.y"

2603

{

2604

if (do_lint && ! io_allowed && yypvt[-0].nodeval == NULL)

2605

warning("non-redirected getline undefined inside BEGIN or END action");

2606

yyval.nodeval = node (yypvt[-1].nodeval, Node_K_getline, yypvt[-0].nodeval);

2607

} break;

2608

case 97:

2609

# line 532 "awk.y"

2610

{ yyval.nodeval = node (yypvt[-2].nodeval, Node_and, yypvt[-0].nodeval); } break;

2611

case 98:

2612

# line 534 "awk.y"

2613

{ yyval.nodeval = node (yypvt[-2].nodeval, Node_or, yypvt[-0].nodeval); } break;

2614

case 99:

2615

# line 536 "awk.y"

2616

{

2617

if (yypvt[-2].nodeval->type == Node_regex)

2618

warning("Regular expression on left of MATCH operator.");

2619

yyval.nodeval = node (yypvt[-2].nodeval, yypvt[-1].nodetypeval, mk_rexp(yypvt[-0].nodeval));

2620

} break;

2621

case 100:

2622

# line 542 "awk.y"

2623

{ yyval.nodeval = yypvt[-0].nodeval; } break;

2624

case 101:

2625

# line 544 "awk.y"

2626

{

2627

yyval.nodeval = node(node(make_number(0.0),

2628

Node_field_spec,

2629

(NODE *) NULL),

2630

Node_nomatch,

2631

yypvt[-0].nodeval);

2632

} break;

2633

case 102:

2634

# line 552 "awk.y"

2635

{ yyval.nodeval = node (variable(yypvt[-0].sval,1), Node_in_array, yypvt[-2].nodeval); } break;

2636

case 103:

2637

# line 554 "awk.y"

2638

{ yyval.nodeval = node (yypvt[-2].nodeval, yypvt[-1].nodetypeval, yypvt[-0].nodeval); } break;

2639

case 104:

2640

# line 556 "awk.y"

2641

{ yyval.nodeval = node (yypvt[-2].nodeval, Node_less, yypvt[-0].nodeval); } break;

2642

case 105:

2643

# line 558 "awk.y"

2644

{ yyval.nodeval = node (yypvt[-2].nodeval, Node_greater, yypvt[-0].nodeval); } break;

2645

case 106:

2646

# line 560 "awk.y"

2647

{ yyval.nodeval = node(yypvt[-4].nodeval, Node_cond_exp, node(yypvt[-2].nodeval, Node_if_branches, yypvt[-0].nodeval));} break;

2648

case 107:

2649

# line 562 "awk.y"

2650

{ yyval.nodeval = yypvt[-0].nodeval; } break;

2651

case 108:

2652

# line 564 "awk.y"

2653

{ yyval.nodeval = node (yypvt[-1].nodeval, Node_concat, yypvt[-0].nodeval); } break;

2654

case 109:

2655

# line 569 "awk.y"

2656

{ want_assign = 0; } break;

2657

case 110:

2658

# line 571 "awk.y"

2659

{ yyval.nodeval = node (yypvt[-3].nodeval, yypvt[-2].nodetypeval, yypvt[-0].nodeval); } break;

2660

case 111:

2661

# line 573 "awk.y"

2662

{ yyval.nodeval = node (yypvt[-2].nodeval, Node_and, yypvt[-0].nodeval); } break;

2663

case 112:

2664

# line 575 "awk.y"

2665

{ yyval.nodeval = node (yypvt[-2].nodeval, Node_or, yypvt[-0].nodeval); } break;

2666

case 113:

2667

# line 577 "awk.y"

2668

{

2669

if (do_lint && ! io_allowed && yypvt[-0].nodeval == NULL)

2670

warning("non-redirected getline undefined inside BEGIN or END action");

2671

yyval.nodeval = node (yypvt[-1].nodeval, Node_K_getline, yypvt[-0].nodeval);

2672

} break;

2673

case 114:

2674

# line 583 "awk.y"

2675

{ yyval.nodeval = yypvt[-0].nodeval; } break;

2676

case 115:

2677

# line 585 "awk.y"

2678

{ yyval.nodeval = node((NODE *) NULL, Node_nomatch, yypvt[-0].nodeval); } break;

2679

case 116:

2680

# line 587 "awk.y"

2681

{ yyval.nodeval = node (yypvt[-2].nodeval, yypvt[-1].nodetypeval, mk_rexp(yypvt[-0].nodeval)); } break;

2682

case 117:

2683

# line 589 "awk.y"

2684

{ yyval.nodeval = node (variable(yypvt[-0].sval,1), Node_in_array, yypvt[-2].nodeval); } break;

2685

case 118:

2686

# line 591 "awk.y"

2687

{ yyval.nodeval = node (yypvt[-2].nodeval, yypvt[-1].nodetypeval, yypvt[-0].nodeval); } break;

2688

case 119:

2689

# line 593 "awk.y"

2690

{ yyval.nodeval = node(yypvt[-4].nodeval, Node_cond_exp, node(yypvt[-2].nodeval, Node_if_branches, yypvt[-0].nodeval));} break;

2691

case 120:

2692

# line 595 "awk.y"

2693

{ yyval.nodeval = yypvt[-0].nodeval; } break;

2694

case 121:

2695

# line 597 "awk.y"

2696

{ yyval.nodeval = node (yypvt[-1].nodeval, Node_concat, yypvt[-0].nodeval); } break;

2697

case 124:

2698

# line 605 "awk.y"

2699

{ yyval.nodeval = node (yypvt[-2].nodeval, Node_exp, yypvt[-0].nodeval); } break;

2700

case 125:

2701

# line 607 "awk.y"

2702

{ yyval.nodeval = node (yypvt[-2].nodeval, Node_times, yypvt[-0].nodeval); } break;

2703

case 126:

2704

# line 609 "awk.y"

2705

{ yyval.nodeval = node (yypvt[-2].nodeval, Node_quotient, yypvt[-0].nodeval); } break;

2706

case 127:

2707

# line 611 "awk.y"

2708

{ yyval.nodeval = node (yypvt[-2].nodeval, Node_mod, yypvt[-0].nodeval); } break;

2709

case 128:

2710

# line 613 "awk.y"

2711

{ yyval.nodeval = node (yypvt[-2].nodeval, Node_plus, yypvt[-0].nodeval); } break;

2712

case 129:

2713

# line 615 "awk.y"

2714

{ yyval.nodeval = node (yypvt[-2].nodeval, Node_minus, yypvt[-0].nodeval); } break;

2715

case 130:

2716

# line 620 "awk.y"

2717

{ yyval.nodeval = node (yypvt[-0].nodeval, Node_not,(NODE *) NULL); } break;

2718

case 131:

2719

# line 622 "awk.y"

2720

{ yyval.nodeval = yypvt[-1].nodeval; } break;

2721

case 132:

2722

# line 624 "awk.y"

2723

{ yyval.nodeval = snode (yypvt[-1].nodeval, Node_builtin, (int) yypvt[-3].lval); } break;

2724

case 133:

2725

# line 626 "awk.y"

2726

{ yyval.nodeval = snode (yypvt[-1].nodeval, Node_builtin, (int) yypvt[-3].lval); } break;

2727

case 134:

2728

# line 628 "awk.y"

2729

{ yyval.nodeval = snode ((NODE *)NULL, Node_builtin, (int) yypvt[-0].lval); } break;

2730

case 135:

2731

# line 630 "awk.y"

2732

{

2733

yyval.nodeval = node (yypvt[-1].nodeval, Node_func_call, make_string(yypvt[-3].sval, strlen(yypvt[-3].sval)));

2734

} break;

2735

case 136:

2736

# line 634 "awk.y"

2737

{ yyval.nodeval = node (yypvt[-0].nodeval, Node_preincrement, (NODE *)NULL); } break;

2738

case 137:

2739

# line 636 "awk.y"

2740

{ yyval.nodeval = node (yypvt[-0].nodeval, Node_predecrement, (NODE *)NULL); } break;

2741

case 138:

2742

# line 638 "awk.y"

2743

{ yyval.nodeval = yypvt[-0].nodeval; } break;

2744

case 139:

2745

# line 640 "awk.y"

2746

{ yyval.nodeval = yypvt[-0].nodeval; } break;

2747

case 140:

2748

# line 643 "awk.y"

2749

{ if (yypvt[-0].nodeval->type == Node_val) {

2750

yypvt[-0].nodeval->numbr = -(force_number(yypvt[-0].nodeval));

2751

yyval.nodeval = yypvt[-0].nodeval;

2752

} else

2753

yyval.nodeval = node (yypvt[-0].nodeval, Node_unary_minus, (NODE *)NULL);

2754

} break;

2755

case 141:

2756

# line 650 "awk.y"

2757

{ yyval.nodeval = yypvt[-0].nodeval; } break;

2758

case 142:

2759

# line 655 "awk.y"

2760

{ yyval.nodeval = node (yypvt[-1].nodeval, Node_postincrement, (NODE *)NULL); } break;

2761

case 143:

2762

# line 657 "awk.y"

2763

{ yyval.nodeval = node (yypvt[-1].nodeval, Node_postdecrement, (NODE *)NULL); } break;

2764

case 145:

2765

# line 663 "awk.y"

2766

{ yyval.nodeval = NULL; } break;

2767

case 146:

2768

# line 665 "awk.y"

2769

{ yyval.nodeval = yypvt[-0].nodeval; } break;

2770

case 147:

2771

# line 670 "awk.y"

2772

{ yyval.nodeval = variable(yypvt[-0].sval,1); } break;

2773

case 148:

2774

# line 672 "awk.y"

2775

{

2776

if (yypvt[-1].nodeval->rnode == NULL) {

2777

yyval.nodeval = node (variable(yypvt[-3].sval,1), Node_subscript, yypvt[-1].nodeval->lnode);

2778

freenode(yypvt[-1].nodeval);

2779

} else

2780

yyval.nodeval = node (variable(yypvt[-3].sval,1), Node_subscript, yypvt[-1].nodeval);

2781

} break;

2782

case 149:

2783

# line 680 "awk.y"

2784

{ yyval.nodeval = node (yypvt[-0].nodeval, Node_field_spec, (NODE *)NULL); } break;

2785

case 150:

2786

# line 682 "awk.y"

2787

{ yyval.nodeval = node (yypvt[-0].nodeval, Node_field_spec, (NODE *)NULL); } break;

2788

case 152:

2789

# line 690 "awk.y"

2790

{ yyerrok; } break;

2791

case 153:

2792

# line 694 "awk.y"

2793

{ yyerrok; } break;

2794

case 156:

2795

# line 703 "awk.y"

2796

{ yyerrok; want_assign = 0; } break;

2797

case 157:

2798

# line 706 "awk.y"

2799

{ yyerrok; } break;

2800

}

2801

goto yystack; /* reset registers in driver code */

2802

}