| 1 | /* |
| 2 | */ |
| 3 | |
| 4 | #include <setjmp.h> |
| 5 | #define INTR 2 |
| 6 | #define QUIT 3 |
| 7 | #define LINSIZ 1000 |
| 8 | #define ARGSIZ 50 |
| 9 | #define TRESIZ 100 |
| 10 | |
| 11 | #define QUOTE 0200 |
| 12 | #define FAND 1 |
| 13 | #define FCAT 2 |
| 14 | #define FPIN 4 |
| 15 | #define FPOU 8 |
| 16 | #define FPAR 16 |
| 17 | #define FINT 32 |
| 18 | #define FPRS 64 |
| 19 | #define TCOM 1 |
| 20 | #define TPAR 2 |
| 21 | #define TFIL 3 |
| 22 | #define TLST 4 |
| 23 | #define DTYP 0 |
| 24 | #define DLEF 1 |
| 25 | #define DRIT 2 |
| 26 | #define DFLG 3 |
| 27 | #define DSPR 4 |
| 28 | #define DCOM 5 |
| 29 | #define ENOMEM 12 |
| 30 | #define ENOEXEC 8 |
| 31 | |
| 32 | int errval; |
| 33 | char *dolp; |
| 34 | char pidp[6]; |
| 35 | char **dolv; |
| 36 | jmp_buf jmpbuf; |
| 37 | int dolc; |
| 38 | char *promp; |
| 39 | char *linep; |
| 40 | char *elinep; |
| 41 | char **argp; |
| 42 | char **eargp; |
| 43 | int *treep; |
| 44 | int *treeend; |
| 45 | char peekc; |
| 46 | char gflg; |
| 47 | char error; |
| 48 | char uid; |
| 49 | char setintr; |
| 50 | char *arginp; |
| 51 | int onelflg; |
| 52 | int stoperr; |
| 53 | |
| 54 | #define NSIG 16 |
| 55 | char *mesg[NSIG] { |
| 56 | 0, |
| 57 | "Hangup", |
| 58 | 0, |
| 59 | "Quit", |
| 60 | "Illegal instruction", |
| 61 | "Trace/BPT trap", |
| 62 | "IOT trap", |
| 63 | "EMT trap", |
| 64 | "Floating exception", |
| 65 | "Killed", |
| 66 | "Bus error", |
| 67 | "Memory fault", |
| 68 | "Bad system call", |
| 69 | 0, |
| 70 | "Alarm clock", |
| 71 | "Terminated", |
| 72 | }; |
| 73 | |
| 74 | char line[LINSIZ]; |
| 75 | char *args[ARGSIZ]; |
| 76 | int trebuf[TRESIZ]; |
| 77 | |
| 78 | main(c, av) |
| 79 | int c; |
| 80 | char **av; |
| 81 | { |
| 82 | register f; |
| 83 | register char *acname, **v; |
| 84 | |
| 85 | for(f=3; f<15; f++) |
| 86 | close(f); |
| 87 | dolc = getpid(); |
| 88 | for(f=4; f>=0; f--) { |
| 89 | dolc = dolc/10; |
| 90 | pidp[f] = dolc%10 + '0'; |
| 91 | } |
| 92 | v = av; |
| 93 | acname = "<none>"; |
| 94 | promp = "% "; |
| 95 | if((uid = getuid()) == 0) |
| 96 | promp = "# "; |
| 97 | if(c>1 && v[1][0]=='-' && v[1][1]=='e') { |
| 98 | ++stoperr; |
| 99 | v[1] = v[0]; |
| 100 | ++v; |
| 101 | --c; |
| 102 | } |
| 103 | if(c > 1) { |
| 104 | promp = 0; |
| 105 | if (*v[1]=='-') { |
| 106 | **v = '-'; |
| 107 | if (v[1][1]=='c' && c>2) |
| 108 | arginp = v[2]; |
| 109 | else if (v[1][1]=='t') |
| 110 | onelflg = 2; |
| 111 | } else { |
| 112 | close(0); |
| 113 | f = open(v[1], 0); |
| 114 | if(f < 0) { |
| 115 | prs(v[1]); |
| 116 | err(": cannot open",255); |
| 117 | } |
| 118 | } |
| 119 | } |
| 120 | if(**v == '-') { |
| 121 | signal(QUIT, 1); |
| 122 | f = signal(INTR, 1); |
| 123 | if ((arginp==0&&onelflg==0) || (f&01)==0) |
| 124 | setintr++; |
| 125 | } |
| 126 | dolv = v+1; |
| 127 | dolc = c-1; |
| 128 | |
| 129 | loop: |
| 130 | if(promp != 0) |
| 131 | prs(promp); |
| 132 | peekc = getc(); |
| 133 | main1(); |
| 134 | goto loop; |
| 135 | } |
| 136 | |
| 137 | main1() |
| 138 | { |
| 139 | register char *cp; |
| 140 | register *t; |
| 141 | |
| 142 | argp = args; |
| 143 | eargp = args+ARGSIZ-5; |
| 144 | linep = line; |
| 145 | elinep = line+LINSIZ-5; |
| 146 | error = 0; |
| 147 | gflg = 0; |
| 148 | do { |
| 149 | cp = linep; |
| 150 | word(); |
| 151 | } while(*cp != '\n'); |
| 152 | treep = trebuf; |
| 153 | treeend = &trebuf[TRESIZ]; |
| 154 | if(gflg == 0) { |
| 155 | if(error == 0) { |
| 156 | setjmp(jmpbuf); |
| 157 | if (error) |
| 158 | return; |
| 159 | t = syntax(args, argp); |
| 160 | } |
| 161 | if(error != 0) |
| 162 | err("syntax error",255); else |
| 163 | execute(t); |
| 164 | } |
| 165 | } |
| 166 | |
| 167 | word() |
| 168 | { |
| 169 | register char c, c1; |
| 170 | |
| 171 | *argp++ = linep; |
| 172 | |
| 173 | loop: |
| 174 | switch(c = getc()) { |
| 175 | |
| 176 | case ' ': |
| 177 | case '\t': |
| 178 | goto loop; |
| 179 | |
| 180 | case '\'': |
| 181 | case '"': |
| 182 | c1 = c; |
| 183 | while((c=readc()) != c1) { |
| 184 | if(c == '\n') { |
| 185 | error++; |
| 186 | peekc = c; |
| 187 | return; |
| 188 | } |
| 189 | *linep++ = c|QUOTE; |
| 190 | } |
| 191 | goto pack; |
| 192 | |
| 193 | case '&': |
| 194 | case ';': |
| 195 | case '<': |
| 196 | case '>': |
| 197 | case '(': |
| 198 | case ')': |
| 199 | case '|': |
| 200 | case '^': |
| 201 | case '\n': |
| 202 | *linep++ = c; |
| 203 | *linep++ = '\0'; |
| 204 | return; |
| 205 | } |
| 206 | |
| 207 | peekc = c; |
| 208 | |
| 209 | pack: |
| 210 | for(;;) { |
| 211 | c = getc(); |
| 212 | if(any(c, " '\"\t;&<>()|^\n")) { |
| 213 | peekc = c; |
| 214 | if(any(c, "\"'")) |
| 215 | goto loop; |
| 216 | *linep++ = '\0'; |
| 217 | return; |
| 218 | } |
| 219 | *linep++ = c; |
| 220 | } |
| 221 | } |
| 222 | |
| 223 | tree(n) |
| 224 | int n; |
| 225 | { |
| 226 | register *t; |
| 227 | |
| 228 | t = treep; |
| 229 | treep =+ n; |
| 230 | if (treep>treeend) { |
| 231 | prs("Command line overflow\n"); |
| 232 | error++; |
| 233 | longjmp(jmpbuf, 1); |
| 234 | } |
| 235 | return(t); |
| 236 | } |
| 237 | |
| 238 | getc() |
| 239 | { |
| 240 | register char c; |
| 241 | |
| 242 | if(peekc) { |
| 243 | c = peekc; |
| 244 | peekc = 0; |
| 245 | return(c); |
| 246 | } |
| 247 | if(argp > eargp) { |
| 248 | argp =- 10; |
| 249 | while((c=getc()) != '\n'); |
| 250 | argp =+ 10; |
| 251 | err("Too many args",255); |
| 252 | gflg++; |
| 253 | return(c); |
| 254 | } |
| 255 | if(linep > elinep) { |
| 256 | linep =- 10; |
| 257 | while((c=getc()) != '\n'); |
| 258 | linep =+ 10; |
| 259 | err("Too many characters",255); |
| 260 | gflg++; |
| 261 | return(c); |
| 262 | } |
| 263 | getd: |
| 264 | if(dolp) { |
| 265 | c = *dolp++; |
| 266 | if(c != '\0') |
| 267 | return(c); |
| 268 | dolp = 0; |
| 269 | } |
| 270 | c = readc(); |
| 271 | if(c == '\\') { |
| 272 | c = readc(); |
| 273 | if(c == '\n') |
| 274 | return(' '); |
| 275 | return(c|QUOTE); |
| 276 | } |
| 277 | if(c == '$') { |
| 278 | c = readc(); |
| 279 | if(c>='0' && c<='9') { |
| 280 | if(c-'0' < dolc) |
| 281 | dolp = dolv[c-'0']; |
| 282 | goto getd; |
| 283 | } |
| 284 | if(c == '$') { |
| 285 | dolp = pidp; |
| 286 | goto getd; |
| 287 | } |
| 288 | } |
| 289 | return(c&0177); |
| 290 | } |
| 291 | |
| 292 | readc() |
| 293 | { |
| 294 | int rdstat; |
| 295 | char cc; |
| 296 | register c; |
| 297 | |
| 298 | if (arginp) { |
| 299 | if (arginp == 1) |
| 300 | exit(errval); |
| 301 | if ((c = *arginp++) == 0) { |
| 302 | arginp = 1; |
| 303 | c = '\n'; |
| 304 | } |
| 305 | return(c); |
| 306 | } |
| 307 | if (onelflg==1) |
| 308 | exit(255); |
| 309 | if((rdstat = read(0, &cc, 1)) != 1) |
| 310 | if(rdstat==0) exit(errval); /* end of file*/ |
| 311 | else exit(255); /* error */ |
| 312 | if (cc=='\n' && onelflg) |
| 313 | onelflg--; |
| 314 | return(cc); |
| 315 | } |
| 316 | |
| 317 | /* |
| 318 | * syntax |
| 319 | * empty |
| 320 | * syn1 |
| 321 | */ |
| 322 | |
| 323 | syntax(p1, p2) |
| 324 | char **p1, **p2; |
| 325 | { |
| 326 | |
| 327 | while(p1 != p2) { |
| 328 | if(any(**p1, ";&\n")) |
| 329 | p1++; else |
| 330 | return(syn1(p1, p2)); |
| 331 | } |
| 332 | return(0); |
| 333 | } |
| 334 | |
| 335 | /* |
| 336 | * syn1 |
| 337 | * syn2 |
| 338 | * syn2 & syntax |
| 339 | * syn2 ; syntax |
| 340 | */ |
| 341 | |
| 342 | syn1(p1, p2) |
| 343 | char **p1, **p2; |
| 344 | { |
| 345 | register char **p; |
| 346 | register *t, *t1; |
| 347 | int l; |
| 348 | |
| 349 | l = 0; |
| 350 | for(p=p1; p!=p2; p++) |
| 351 | switch(**p) { |
| 352 | |
| 353 | case '(': |
| 354 | l++; |
| 355 | continue; |
| 356 | |
| 357 | case ')': |
| 358 | l--; |
| 359 | if(l < 0) |
| 360 | error++; |
| 361 | continue; |
| 362 | |
| 363 | case '&': |
| 364 | case ';': |
| 365 | case '\n': |
| 366 | if(l == 0) { |
| 367 | l = **p; |
| 368 | t = tree(4); |
| 369 | t[DTYP] = TLST; |
| 370 | t[DLEF] = syn2(p1, p); |
| 371 | t[DFLG] = 0; |
| 372 | if(l == '&') { |
| 373 | t1 = t[DLEF]; |
| 374 | t1[DFLG] =| FAND|FPRS|FINT; |
| 375 | } |
| 376 | t[DRIT] = syntax(p+1, p2); |
| 377 | return(t); |
| 378 | } |
| 379 | } |
| 380 | if(l == 0) |
| 381 | return(syn2(p1, p2)); |
| 382 | error++; |
| 383 | return(0); |
| 384 | } |
| 385 | |
| 386 | /* |
| 387 | * syn2 |
| 388 | * syn3 |
| 389 | * syn3 | syn2 |
| 390 | */ |
| 391 | |
| 392 | syn2(p1, p2) |
| 393 | char **p1, **p2; |
| 394 | { |
| 395 | register char **p; |
| 396 | register int l, *t; |
| 397 | |
| 398 | l = 0; |
| 399 | for(p=p1; p!=p2; p++) |
| 400 | switch(**p) { |
| 401 | |
| 402 | case '(': |
| 403 | l++; |
| 404 | continue; |
| 405 | |
| 406 | case ')': |
| 407 | l--; |
| 408 | continue; |
| 409 | |
| 410 | case '|': |
| 411 | case '^': |
| 412 | if(l == 0) { |
| 413 | t = tree(4); |
| 414 | t[DTYP] = TFIL; |
| 415 | t[DLEF] = syn3(p1, p); |
| 416 | t[DRIT] = syn2(p+1, p2); |
| 417 | t[DFLG] = 0; |
| 418 | return(t); |
| 419 | } |
| 420 | } |
| 421 | return(syn3(p1, p2)); |
| 422 | } |
| 423 | |
| 424 | /* |
| 425 | * syn3 |
| 426 | * ( syn1 ) [ < in ] [ > out ] |
| 427 | * word word* [ < in ] [ > out ] |
| 428 | */ |
| 429 | |
| 430 | syn3(p1, p2) |
| 431 | char **p1, **p2; |
| 432 | { |
| 433 | register char **p; |
| 434 | char **lp, **rp; |
| 435 | register *t; |
| 436 | int n, l, i, o, c, flg; |
| 437 | |
| 438 | flg = 0; |
| 439 | if(**p2 == ')') |
| 440 | flg =| FPAR; |
| 441 | lp = 0; |
| 442 | rp = 0; |
| 443 | i = 0; |
| 444 | o = 0; |
| 445 | n = 0; |
| 446 | l = 0; |
| 447 | for(p=p1; p!=p2; p++) |
| 448 | switch(c = **p) { |
| 449 | |
| 450 | case '(': |
| 451 | if(l == 0) { |
| 452 | if(lp != 0) |
| 453 | error++; |
| 454 | lp = p+1; |
| 455 | } |
| 456 | l++; |
| 457 | continue; |
| 458 | |
| 459 | case ')': |
| 460 | l--; |
| 461 | if(l == 0) |
| 462 | rp = p; |
| 463 | continue; |
| 464 | |
| 465 | case '>': |
| 466 | p++; |
| 467 | if(p!=p2 && **p=='>') |
| 468 | flg =| FCAT; else |
| 469 | p--; |
| 470 | |
| 471 | case '<': |
| 472 | if(l == 0) { |
| 473 | p++; |
| 474 | if(p == p2) { |
| 475 | error++; |
| 476 | p--; |
| 477 | } |
| 478 | if(any(**p, "<>(")) |
| 479 | error++; |
| 480 | if(c == '<') { |
| 481 | if(i != 0) |
| 482 | error++; |
| 483 | i = *p; |
| 484 | continue; |
| 485 | } |
| 486 | if(o != 0) |
| 487 | error++; |
| 488 | o = *p; |
| 489 | } |
| 490 | continue; |
| 491 | |
| 492 | default: |
| 493 | if(l == 0) |
| 494 | p1[n++] = *p; |
| 495 | } |
| 496 | if(lp != 0) { |
| 497 | if(n != 0) |
| 498 | error++; |
| 499 | t = tree(5); |
| 500 | t[DTYP] = TPAR; |
| 501 | t[DSPR] = syn1(lp, rp); |
| 502 | goto out; |
| 503 | } |
| 504 | if(n == 0) |
| 505 | error++; |
| 506 | p1[n++] = 0; |
| 507 | t = tree(n+5); |
| 508 | t[DTYP] = TCOM; |
| 509 | for(l=0; l<n; l++) |
| 510 | t[l+DCOM] = p1[l]; |
| 511 | out: |
| 512 | t[DFLG] = flg; |
| 513 | t[DLEF] = i; |
| 514 | t[DRIT] = o; |
| 515 | return(t); |
| 516 | } |
| 517 | |
| 518 | scan(at, f) |
| 519 | int *at; |
| 520 | int (*f)(); |
| 521 | { |
| 522 | register char *p, c; |
| 523 | register *t; |
| 524 | |
| 525 | t = at+DCOM; |
| 526 | while(p = *t++) |
| 527 | while(c = *p) |
| 528 | *p++ = (*f)(c); |
| 529 | } |
| 530 | |
| 531 | tglob(c) |
| 532 | int c; |
| 533 | { |
| 534 | |
| 535 | if(any(c, "[?*")) |
| 536 | gflg = 1; |
| 537 | return(c); |
| 538 | } |
| 539 | |
| 540 | trim(c) |
| 541 | int c; |
| 542 | { |
| 543 | |
| 544 | return(c&0177); |
| 545 | } |
| 546 | |
| 547 | execute(t, pf1, pf2) |
| 548 | int *t, *pf1, *pf2; |
| 549 | { |
| 550 | int i, f, pv[2]; |
| 551 | register *t1; |
| 552 | register char *cp1, *cp2; |
| 553 | extern errno; |
| 554 | |
| 555 | if(t != 0) |
| 556 | switch(t[DTYP]) { |
| 557 | |
| 558 | case TCOM: |
| 559 | cp1 = t[DCOM]; |
| 560 | if(equal(cp1, "chdir")) { |
| 561 | if(t[DCOM+1] != 0) { |
| 562 | if(chdir(t[DCOM+1]) < 0) |
| 563 | err("chdir: bad directory",255); |
| 564 | } else |
| 565 | err("chdir: arg count",255); |
| 566 | return; |
| 567 | } |
| 568 | if(equal(cp1, "shift")) { |
| 569 | if(dolc < 1) { |
| 570 | prs("shift: no args\n"); |
| 571 | return; |
| 572 | } |
| 573 | dolv[1] = dolv[0]; |
| 574 | dolv++; |
| 575 | dolc--; |
| 576 | return; |
| 577 | } |
| 578 | if(equal(cp1, "login")) { |
| 579 | if(promp != 0) { |
| 580 | execv("/bin/login", t+DCOM); |
| 581 | } |
| 582 | prs("login: cannot execute\n"); |
| 583 | return; |
| 584 | } |
| 585 | if(equal(cp1, "newgrp")) { |
| 586 | if(promp != 0) { |
| 587 | execv("/bin/newgrp", t+DCOM); |
| 588 | } |
| 589 | prs("newgrp: cannot execute\n"); |
| 590 | return; |
| 591 | } |
| 592 | if(equal(cp1, "wait")) { |
| 593 | pwait(-1, 0); |
| 594 | return; |
| 595 | } |
| 596 | if(equal(cp1, ":")) |
| 597 | return; |
| 598 | |
| 599 | case TPAR: |
| 600 | f = t[DFLG]; |
| 601 | i = 0; |
| 602 | if((f&FPAR) == 0) |
| 603 | i = fork(); |
| 604 | if(i == -1) { |
| 605 | err("try again",255); |
| 606 | return; |
| 607 | } |
| 608 | if(i != 0) { |
| 609 | if((f&FPIN) != 0) { |
| 610 | close(pf1[0]); |
| 611 | close(pf1[1]); |
| 612 | } |
| 613 | if((f&FPRS) != 0) { |
| 614 | prn(i); |
| 615 | prs("\n"); |
| 616 | } |
| 617 | if((f&FAND) != 0) |
| 618 | return; |
| 619 | if((f&FPOU) == 0) |
| 620 | pwait(i, t); |
| 621 | return; |
| 622 | } |
| 623 | if(t[DLEF] != 0) { |
| 624 | close(0); |
| 625 | i = open(t[DLEF], 0); |
| 626 | if(i < 0) { |
| 627 | prs(t[DLEF]); |
| 628 | err(": cannot open",255); |
| 629 | exit(255); |
| 630 | } |
| 631 | } |
| 632 | if(t[DRIT] != 0) { |
| 633 | if((f&FCAT) != 0) { |
| 634 | i = open(t[DRIT], 1); |
| 635 | if(i >= 0) { |
| 636 | lseek(i, 0L, 2); |
| 637 | goto f1; |
| 638 | } |
| 639 | } |
| 640 | i = creat(t[DRIT], 0666); |
| 641 | if(i < 0) { |
| 642 | prs(t[DRIT]); |
| 643 | err(": cannot create",255); |
| 644 | exit(255); |
| 645 | } |
| 646 | f1: |
| 647 | close(1); |
| 648 | dup(i); |
| 649 | close(i); |
| 650 | } |
| 651 | if((f&FPIN) != 0) { |
| 652 | close(0); |
| 653 | dup(pf1[0]); |
| 654 | close(pf1[0]); |
| 655 | close(pf1[1]); |
| 656 | } |
| 657 | if((f&FPOU) != 0) { |
| 658 | close(1); |
| 659 | dup(pf2[1]); |
| 660 | close(pf2[0]); |
| 661 | close(pf2[1]); |
| 662 | } |
| 663 | if((f&FINT)!=0 && t[DLEF]==0 && (f&FPIN)==0) { |
| 664 | close(0); |
| 665 | open("/dev/null", 0); |
| 666 | } |
| 667 | if((f&FINT) == 0 && setintr) { |
| 668 | signal(INTR, 0); |
| 669 | signal(QUIT, 0); |
| 670 | } |
| 671 | if(t[DTYP] == TPAR) { |
| 672 | if(t1 = t[DSPR]) |
| 673 | t1[DFLG] =| f&FINT; |
| 674 | execute(t1); |
| 675 | exit(255); |
| 676 | } |
| 677 | gflg = 0; |
| 678 | scan(t, tglob); |
| 679 | if(gflg) { |
| 680 | t[DSPR] = "/etc/glob"; |
| 681 | execv(t[DSPR], t+DSPR); |
| 682 | prs("glob: cannot execute\n"); |
| 683 | exit(255); |
| 684 | } |
| 685 | scan(t, trim); |
| 686 | *linep = 0; |
| 687 | texec(t[DCOM], t); |
| 688 | cp1 = linep; |
| 689 | cp2 = "/usr/bin/"; |
| 690 | while(*cp1 = *cp2++) |
| 691 | cp1++; |
| 692 | cp2 = t[DCOM]; |
| 693 | while(*cp1++ = *cp2++); |
| 694 | texec(linep+4, t); |
| 695 | texec(linep, t); |
| 696 | prs(t[DCOM]); |
| 697 | err(": not found",255); |
| 698 | exit(255); |
| 699 | |
| 700 | case TFIL: |
| 701 | f = t[DFLG]; |
| 702 | pipe(pv); |
| 703 | t1 = t[DLEF]; |
| 704 | t1[DFLG] =| FPOU | (f&(FPIN|FINT|FPRS)); |
| 705 | execute(t1, pf1, pv); |
| 706 | t1 = t[DRIT]; |
| 707 | t1[DFLG] =| FPIN | (f&(FPOU|FINT|FAND|FPRS)); |
| 708 | execute(t1, pv, pf2); |
| 709 | return; |
| 710 | |
| 711 | case TLST: |
| 712 | f = t[DFLG]&FINT; |
| 713 | if(t1 = t[DLEF]) |
| 714 | t1[DFLG] =| f; |
| 715 | execute(t1); |
| 716 | if(t1 = t[DRIT]) |
| 717 | t1[DFLG] =| f; |
| 718 | execute(t1); |
| 719 | return; |
| 720 | |
| 721 | } |
| 722 | } |
| 723 | |
| 724 | texec(f, at) |
| 725 | int *at; |
| 726 | { |
| 727 | extern errno; |
| 728 | register int *t; |
| 729 | |
| 730 | t = at; |
| 731 | execv(f, t+DCOM); |
| 732 | if (errno==ENOEXEC) { |
| 733 | if (*linep) |
| 734 | t[DCOM] = linep; |
| 735 | t[DSPR] = "/usr/bin/osh"; |
| 736 | execv(t[DSPR], t+DSPR); |
| 737 | prs("No shell!\n"); |
| 738 | exit(255); |
| 739 | } |
| 740 | if (errno==ENOMEM) { |
| 741 | prs(t[DCOM]); |
| 742 | err(": too large",255); |
| 743 | exit(255); |
| 744 | } |
| 745 | } |
| 746 | |
| 747 | err(s, exitno) |
| 748 | char *s; |
| 749 | int exitno; |
| 750 | { |
| 751 | |
| 752 | prs(s); |
| 753 | prs("\n"); |
| 754 | if(promp == 0) { |
| 755 | lseek(0, 0L, 2); |
| 756 | exit(exitno); |
| 757 | } |
| 758 | } |
| 759 | |
| 760 | prs(as) |
| 761 | char *as; |
| 762 | { |
| 763 | register char *s; |
| 764 | |
| 765 | s = as; |
| 766 | while(*s) |
| 767 | putc(*s++); |
| 768 | } |
| 769 | |
| 770 | putc(c) |
| 771 | { |
| 772 | char cc; |
| 773 | |
| 774 | cc = c; |
| 775 | write(2, &cc, 1); |
| 776 | } |
| 777 | |
| 778 | prn(n) |
| 779 | int n; |
| 780 | { |
| 781 | register a; |
| 782 | |
| 783 | if (a = n/10) |
| 784 | prn(a); |
| 785 | putc(n%10 + '0'); |
| 786 | } |
| 787 | |
| 788 | any(c, as) |
| 789 | int c; |
| 790 | char *as; |
| 791 | { |
| 792 | register char *s; |
| 793 | |
| 794 | s = as; |
| 795 | while(*s) |
| 796 | if(*s++ == c) |
| 797 | return(1); |
| 798 | return(0); |
| 799 | } |
| 800 | |
| 801 | equal(as1, as2) |
| 802 | char *as1, *as2; |
| 803 | { |
| 804 | register char *s1, *s2; |
| 805 | |
| 806 | s1 = as1; |
| 807 | s2 = as2; |
| 808 | while(*s1++ == *s2) |
| 809 | if(*s2++ == '\0') |
| 810 | return(1); |
| 811 | return(0); |
| 812 | } |
| 813 | |
| 814 | pwait(i, t) |
| 815 | int i, *t; |
| 816 | { |
| 817 | register p, e; |
| 818 | int s; |
| 819 | |
| 820 | if(i != 0) |
| 821 | for(;;) { |
| 822 | p = wait(&s); |
| 823 | if(p == -1) |
| 824 | break; |
| 825 | e = s&0177; |
| 826 | if (e>=NSIG || mesg[e]) { |
| 827 | if(p != i) { |
| 828 | prn(p); |
| 829 | prs(": "); |
| 830 | } |
| 831 | if (e < NSIG) |
| 832 | prs(mesg[e]); |
| 833 | else { |
| 834 | prs("Signal "); |
| 835 | prn(e); |
| 836 | } |
| 837 | if(s&0200) |
| 838 | prs(" -- Core dumped"); |
| 839 | } |
| 840 | if (e || s&&stoperr) |
| 841 | err("", (s>>8)|e ); |
| 842 | errval =| (s>>8); |
| 843 | } |
| 844 | } |