1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ 28 /* All Rights Reserved */ 29 30 /* 31 * UNIX shell 32 */ 33 34 #include "defs.h" 35 #include "sym.h" 36 37 static struct ionod * inout(); 38 static void chkword(void); 39 static void chksym(int); 40 static struct trenod * term(); 41 static struct trenod * makelist(); 42 static struct trenod * list(); 43 static struct regnod * syncase(); 44 static struct trenod * item(); 45 static int skipnl(); 46 static void prsym(int); 47 static void synbad(void); 48 49 50 /* ======== storage allocation for functions ======== */ 51 52 unsigned char * 53 getstor(asize) 54 int asize; 55 { 56 if (fndef) 57 return((unsigned char *)alloc(asize)); 58 else 59 return(getstak(asize)); 60 } 61 62 63 /* ======== command line decoding ========*/ 64 65 66 67 68 struct trenod * 69 makefork(flgs, i) 70 int flgs; 71 struct trenod *i; 72 { 73 struct forknod *t; 74 75 t = (struct forknod *)getstor(sizeof(struct forknod)); 76 t->forktyp = flgs|TFORK; 77 t->forktre = i; 78 t->forkio = 0; 79 return((struct trenod *)t); 80 } 81 82 static struct trenod * 83 makelist(type, i, r) 84 int type; 85 struct trenod *i, *r; 86 { 87 struct lstnod *t; 88 89 if (i == 0 || r == 0) 90 synbad(); 91 else 92 { 93 t = (struct lstnod *)getstor(sizeof(struct lstnod)); 94 t->lsttyp = type; 95 t->lstlef = i; 96 t->lstrit = r; 97 } 98 return((struct trenod *)t); 99 } 100 101 /* 102 * cmd 103 * empty 104 * list 105 * list & [ cmd ] 106 * list [ ; cmd ] 107 */ 108 struct trenod * 109 cmd(sym, flg) 110 int sym; 111 int flg; 112 { 113 struct trenod *i, *e; 114 i = list(flg); 115 if (wdval == NL) 116 { 117 if (flg & NLFLG) 118 { 119 wdval = ';'; 120 chkpr(); 121 } 122 } 123 else if (i == 0 && (flg & MTFLG) == 0) 124 synbad(); 125 126 switch (wdval) 127 { 128 case '&': 129 if (i) 130 i = makefork(FAMP, i); 131 else 132 synbad(); 133 134 case ';': 135 if (e = cmd(sym, flg | MTFLG)) 136 i = makelist(TLST, i, e); 137 else if (i == 0) 138 synbad(); 139 break; 140 141 case EOFSYM: 142 if (sym == NL) 143 break; 144 145 default: 146 if (sym) 147 chksym(sym); 148 } 149 return(i); 150 } 151 152 /* 153 * list 154 * term 155 * list && term 156 * list || term 157 */ 158 static struct trenod * 159 list(flg) 160 { 161 struct trenod *r; 162 int b; 163 r = term(flg); 164 while (r && ((b = (wdval == ANDFSYM)) || wdval == ORFSYM)) 165 r = makelist((b ? TAND : TORF), r, term(NLFLG)); 166 return(r); 167 } 168 169 /* 170 * term 171 * item 172 * item |^ term 173 */ 174 static struct trenod * 175 term(flg) 176 { 177 struct trenod *t; 178 179 reserv++; 180 if (flg & NLFLG) 181 skipnl(); 182 else 183 word(); 184 if ((t = item(TRUE)) && (wdval == '^' || wdval == '|')) 185 { 186 struct trenod *left; 187 struct trenod *right; 188 189 left = makefork(FPOU, t); 190 right = makefork(FPIN, term(NLFLG)); 191 return(makefork(0, makelist(TFIL, left, right))); 192 } 193 else 194 return(t); 195 } 196 197 198 static struct regnod * 199 syncase(esym) 200 int esym; 201 { 202 skipnl(); 203 if (wdval == esym) 204 return(0); 205 else 206 { 207 struct regnod *r = 208 (struct regnod *)getstor(sizeof (struct regnod)); 209 struct argnod *argp; 210 211 r->regptr = 0; 212 for (;;) 213 { 214 if (fndef) 215 { 216 argp= wdarg; 217 wdarg = (struct argnod *)alloc(length(argp->argval) + BYTESPERWORD); 218 movstr(argp->argval, wdarg->argval); 219 } 220 221 wdarg->argnxt = r->regptr; 222 r->regptr = wdarg; 223 224 /* 'in' is not a reserved word in this case */ 225 if (wdval == INSYM){ 226 wdval = 0; 227 } 228 if (wdval || (word() != ')' && wdval != '|')) 229 synbad(); 230 if (wdval == '|') 231 word(); 232 else 233 break; 234 } 235 r->regcom = cmd(0, NLFLG | MTFLG); 236 if (wdval == ECSYM) 237 r->regnxt = syncase(esym); 238 else 239 { 240 chksym(esym); 241 r->regnxt = 0; 242 } 243 return(r); 244 } 245 } 246 247 /* 248 * item 249 * 250 * ( cmd ) [ < in ] [ > out ] 251 * word word* [ < in ] [ > out ] 252 * if ... then ... else ... fi 253 * for ... while ... do ... done 254 * case ... in ... esac 255 * begin ... end 256 */ 257 static struct trenod * 258 item(flag) 259 BOOL flag; 260 { 261 struct trenod *r; 262 struct ionod *io; 263 264 if (flag) 265 io = inout((struct ionod *)0); 266 else 267 io = 0; 268 switch (wdval) 269 { 270 case CASYM: 271 { 272 struct swnod *t; 273 274 t = (struct swnod *)getstor(sizeof(struct swnod)); 275 r = (struct trenod *)t; 276 277 chkword(); 278 if (fndef) 279 t->swarg = make(wdarg->argval); 280 else 281 t->swarg = wdarg->argval; 282 skipnl(); 283 chksym(INSYM | BRSYM); 284 t->swlst = syncase(wdval == INSYM ? ESSYM : KTSYM); 285 t->swtyp = TSW; 286 break; 287 } 288 289 case IFSYM: 290 { 291 int w; 292 struct ifnod *t; 293 294 t = (struct ifnod *)getstor(sizeof(struct ifnod)); 295 r = (struct trenod *)t; 296 297 t->iftyp = TIF; 298 t->iftre = cmd(THSYM, NLFLG); 299 t->thtre = cmd(ELSYM | FISYM | EFSYM, NLFLG); 300 t->eltre = ((w = wdval) == ELSYM ? cmd(FISYM, NLFLG) : (w == EFSYM ? (wdval = IFSYM, item(0)) : 0)); 301 if (w == EFSYM) 302 return(r); 303 break; 304 } 305 306 case FORSYM: 307 { 308 struct fornod *t; 309 310 t = (struct fornod *)getstor(sizeof(struct fornod)); 311 r = (struct trenod *)t; 312 313 t->fortyp = TFOR; 314 t->forlst = 0; 315 chkword(); 316 if (fndef) 317 t->fornam = make(wdarg->argval); 318 else 319 t->fornam = wdarg->argval; 320 if (skipnl() == INSYM) 321 { 322 chkword(); 323 324 nohash++; 325 t->forlst = (struct comnod *)item(0); 326 nohash--; 327 328 if (wdval != NL && wdval != ';') 329 synbad(); 330 if (wdval == NL) 331 chkpr(); 332 skipnl(); 333 } 334 chksym(DOSYM | BRSYM); 335 t->fortre = cmd(wdval == DOSYM ? ODSYM : KTSYM, NLFLG); 336 break; 337 } 338 339 case WHSYM: 340 case UNSYM: 341 { 342 struct whnod *t; 343 344 t = (struct whnod *)getstor(sizeof(struct whnod)); 345 r = (struct trenod *)t; 346 347 t->whtyp = (wdval == WHSYM ? TWH : TUN); 348 t->whtre = cmd(DOSYM, NLFLG); 349 t->dotre = cmd(ODSYM, NLFLG); 350 break; 351 } 352 353 case BRSYM: 354 r = cmd(KTSYM, NLFLG); 355 break; 356 357 case '(': 358 { 359 struct parnod *p; 360 361 p = (struct parnod *)getstor(sizeof(struct parnod)); 362 p->partre = cmd(')', NLFLG); 363 p->partyp = TPAR; 364 r = makefork(0, p); 365 break; 366 } 367 368 default: 369 if (io == 0) 370 return(0); 371 372 case 0: 373 { 374 struct comnod *t; 375 struct argnod *argp; 376 struct argnod **argtail; 377 struct argnod **argset = 0; 378 int keywd = 1; 379 unsigned char *com; 380 381 if ((wdval != NL) && ((peekn = skipwc()) == '(')) 382 { 383 struct fndnod *f; 384 struct ionod *saveio; 385 386 saveio = iotemp; 387 peekn = 0; 388 if (skipwc() != ')') 389 synbad(); 390 391 /* 392 * We increase fndef before calling getstor(), 393 * so that getstor() uses malloc to allocate 394 * memory instead of stack. This is necessary 395 * since fndnod will be hung on np->namenv, 396 * which persists over command executions. 397 */ 398 fndef++; 399 f = (struct fndnod *)getstor(sizeof(struct fndnod)); 400 r = (struct trenod *)f; 401 402 f->fndtyp = TFND; 403 f->fndnam = make(wdarg->argval); 404 f->fndref = 0; 405 reserv++; 406 skipnl(); 407 f->fndval = (struct trenod *)item(0); 408 fndef--; 409 410 if (iotemp != saveio) 411 { 412 struct ionod *ioptr = iotemp; 413 414 while (ioptr->iolst != saveio) 415 ioptr = ioptr->iolst; 416 417 ioptr->iolst = fiotemp; 418 fiotemp = iotemp; 419 iotemp = saveio; 420 } 421 return(r); 422 } 423 else 424 { 425 t = (struct comnod *)getstor(sizeof(struct comnod)); 426 r = (struct trenod *)t; 427 428 t->comio = io; /*initial io chain*/ 429 argtail = &(t->comarg); 430 431 while (wdval == 0) 432 { 433 if (fndef) 434 { 435 argp = wdarg; 436 wdarg = (struct argnod *)alloc(length(argp->argval) + BYTESPERWORD); 437 movstr(argp->argval, wdarg->argval); 438 } 439 440 argp = wdarg; 441 if (wdset && keywd) 442 { 443 argp->argnxt = (struct argnod *)argset; 444 argset = (struct argnod **)argp; 445 } 446 else 447 { 448 *argtail = argp; 449 argtail = &(argp->argnxt); 450 keywd = flags & keyflg; 451 } 452 word(); 453 if (flag) 454 { 455 if (io) 456 { 457 while(io->ionxt) 458 io = io->ionxt; 459 io->ionxt = inout((struct ionod *)0); 460 } 461 else 462 t->comio = io = inout((struct ionod *)0); 463 } 464 } 465 466 t->comtyp = TCOM; 467 t->comset = (struct argnod *)argset; 468 *argtail = 0; 469 470 if (nohash == 0 && (fndef == 0 || (flags & hashflg))) 471 { 472 if (t->comarg) 473 { 474 com = t->comarg->argval; 475 if (*com && *com != DOLLAR) 476 pathlook(com, 0, t->comset); 477 } 478 } 479 480 return(r); 481 } 482 } 483 484 } 485 reserv++; 486 word(); 487 if (io = inout(io)) 488 { 489 r = makefork(0,r); 490 r->treio = io; 491 } 492 return(r); 493 } 494 495 496 static int 497 skipnl() 498 { 499 while ((reserv++, word() == NL)) 500 chkpr(); 501 return(wdval); 502 } 503 504 static struct ionod * 505 inout(lastio) 506 struct ionod *lastio; 507 { 508 int iof; 509 struct ionod *iop; 510 unsigned int c; 511 512 iof = wdnum; 513 switch (wdval) 514 { 515 case DOCSYM: /* << */ 516 iof |= IODOC|IODOC_SUBST; 517 break; 518 519 case APPSYM: /* >> */ 520 case '>': 521 if (wdnum == 0) 522 iof |= 1; 523 iof |= IOPUT; 524 if (wdval == APPSYM) 525 { 526 iof |= IOAPP; 527 break; 528 } 529 530 case '<': 531 if ((c = nextwc()) == '&') 532 iof |= IOMOV; 533 else if (c == '>') 534 iof |= IORDW; 535 else 536 peekn = c | MARK; 537 break; 538 539 default: 540 return(lastio); 541 } 542 543 chkword(); 544 iop = (struct ionod *)getstor(sizeof(struct ionod)); 545 546 if (fndef) 547 iop->ioname = (char *) make(wdarg->argval); 548 else 549 iop->ioname = (char *) (wdarg->argval); 550 551 iop->iolink = 0; 552 iop->iofile = iof; 553 if (iof & IODOC) 554 { 555 iop->iolst = iopend; 556 iopend = iop; 557 } 558 word(); 559 iop->ionxt = inout(lastio); 560 return(iop); 561 } 562 563 static void 564 chkword(void) 565 { 566 if (word()) 567 synbad(); 568 } 569 570 static void 571 chksym(int sym) 572 { 573 int x = sym & wdval; 574 575 if (((x & SYMFLG) ? x : sym) != wdval) 576 synbad(); 577 } 578 579 static void 580 prsym(int sym) 581 { 582 if (sym & SYMFLG) 583 { 584 const struct sysnod *sp = reserved; 585 586 while (sp->sysval && sp->sysval != sym) 587 sp++; 588 prs(sp->sysnam); 589 } 590 else if (sym == EOFSYM) 591 prs(_gettext(endoffile)); 592 else 593 { 594 if (sym & SYMREP) 595 prc(sym); 596 if (sym == NL) 597 prs(_gettext(nlorsemi)); 598 else 599 prc(sym); 600 } 601 } 602 603 static void 604 synbad(void) 605 { 606 prp(); 607 prs(_gettext(synmsg)); 608 if ((flags & ttyflg) == 0) 609 { 610 prs(_gettext(atline)); 611 prn(standin->flin); 612 } 613 prs(colon); 614 prc(LQ); 615 if (wdval) 616 prsym(wdval); 617 else 618 prs_cntl(wdarg->argval); 619 prc(RQ); 620 prs(_gettext(unexpected)); 621 newline(); 622 exitsh(SYNBAD); 623 } 624