Source Code 1992 March/Source_Code_CD-ROM_Walnut_Creek_March_1992.iso/usenet/altsrcs/2/2270

Internet Message Format | 1990-12-28 | 38.9 KB

From: [e-mail] (USENET Administration)
Newsgroups: alt.sources
Subject: Public Domain Korn Shell - Part.05 of 7
Message-ID: <[e-mail]>
Date: 12 Dec 90 11:38:04 GMT

#!/bin/sh
# This is part 05 of ksh-pd
# ============= src/c_ksh.c ==============
if test ! -d 'src'; then
    echo 'x - creating directory src'
    mkdir 'src'
fi
if test -f 'src/c_ksh.c' -a X"$1" != X"-c"; then
    echo 'x - skipping src/c_ksh.c (File already exists)'
else
echo 'x - extracting src/c_ksh.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'src/c_ksh.c' &&
X/*
X * built-in Korn commands: c_*
X */
X
Xstatic char *RCSid = "$Id: c_ksh.c,v 3.2 89/01/23 10:57:38 egisin Exp $";
X
X#include <stddef.h>
X#include <stdio.h>
X#include <string.h>
X#include <errno.h>
X#include <setjmp.h>
X#include "sh.h"
X#include "table.h"
X
Xint
Xc_hash(wp)
X    register char **wp;
X{
X    register int i;
X    register struct tbl *tp, **p;
X
X    wp++;
X    if (*wp == NULL) {
X        for (p = tsort(&commands); (tp = *p++) != NULL; )
X            if ((tp->flag&ISSET))
X                printf("%s\n", tp->val.s);
X        return 0;
X    }
X
X    if (strcmp(*wp, "-r") == 0)
X        flushcom(1);
X    while (*wp != NULL)
X        findcom(*wp++, 1);
X    return 0;
X}
X
Xint
Xc_print(wp)
X    register char **wp;
X{
X    int nl = 1;
X    int expand = 1;
X    FILE *f = stdout;
X
X    for (wp++; *wp != NULL && **wp == '-'; wp++) {
X        register char *s = *wp + 1;
X        if (*s == '\0') {
X            wp++;
X            break;
X        }
X        while (*s) switch (*s++) {
X          case 'n':
X            nl = 0;
X            break;
X          case 'e':
X            expand = 1;
X            break;
X          case 'r':
X            expand = 0;
X            break;
X          case 'u':
X            if (!digit(*s) || (f = shf[*s++-'0']) == NULL)
X                errorf("bad -u argument\n");
X            break;
X        }
X    }
X
X    while (*wp != NULL) {
X        register char *s = *wp;
X        register int c;
X        while ((c = *s++) != '\0')
X            if (expand && c == '\\') {
X                switch ((c = *s++)) {
X                case 'b': c = '\b'; break;
X                case 'c': nl = 0; continue; /* AT&T brain damage */
X                case 'f': c = '\f'; break;
X                case 'n': c = '\n'; break;
X                case 'r': c = '\r'; break;
X                case 't': c = '\t'; break;
X                case 'v': c = 0x0B; break;
X                case '0': case '1': case '2': case '3':
X                case '4': case '5': case '6': case '7':
X                    c = c - '0';
X                    if (*s >= '0' && *s <= '7')
X                        c = 8*c + *s++ - '0';
X                    if (*s >= '0' && *s <= '7')
X                        c = 8*c + *s++ - '0';
X                    break;
X                case '\\': break;
X                default:
X                    putc('\\', f);
X                }
X                putc(c, f);
X            } else
X                putc(c, f);
X        if (*++wp != NULL)
X            putc(' ', f);
X    }
X    if (nl)
X        putc('\n', f);
X    return 0;
X}
X
X/* todo: handle case where id is both lexical and command */
Xint
Xc_whence(wp)
X    register char **wp;
X{
X    register struct tbl *tp;
X    char *id;
X    int vflag = 0;
X
X    for (wp++; (id = *wp) != NULL && *id == '-'; wp++)
X        if (id[1] == 'v')
X            vflag = 1;
X
X    while ((id = *wp++) != NULL) {
X        tp = tsearch(&lexicals, id, hash(id));
X        if (tp == NULL)
X            tp = findcom(id, 1);
X        if (vflag)
X            switch ((tp == NULL) ? CNONE : tp->type) {
X              case CNONE:
X                printf("%s is unknown\n", id);
X                break;
X              case CSHELL:
X                printf("%s is a shell builtin\n", id);
X                break;
X              case CFUNC:
X                printf("%s is a function\n", id);
X                fptreef(stdout, "function %s %T\n", id, tp->val.t);
X                break;
X              case CEXEC:
X                printf("%s is %s\n", id,
X                       (tp->flag&ISSET) ? tp->val.s : "unknown");
X                break;
X              case CALIAS:
X                printf("%s is the alias '%s'\n", id, tp->val.s);
X                break;
X              case CKEYWD:
X                printf("%s is a shell keyword\n", id);
X                break;
X              default:
X                printf("%s is *GOK*\n", id);
X                break;
X            }
X        else
X            switch ((tp == NULL) ? CNONE : tp->type) {
X              case CNONE:
X                printf("\n");
X                break;
X              case CSHELL:
X                printf("builtin %s\n", id);
X                break;
X              case CFUNC:
X                printf("%s\n", id);
X                break;
X              case CEXEC:
X                printf("%s\n", (tp->flag&ISSET) ? tp->val.s : id);
X                break;
X              case CALIAS:
X                printf("%s\n", tp->val.s);
X                break;
X              case CKEYWD:
X                printf("%s\n", id);
X                break;
X              default:
X                printf("*GOK*\n");
X                break;
X            }
X    }
X    return 0;
X}
X
X/* typeset, export, and readonly */
Xint
Xc_typeset(wp)
X    register char **wp;
X{
X    register char *id;
X    struct block *l = e.loc;
X    register struct tbl *vp, **p;
X    int fset = 0, fclr = 0;
X    int thing = 0, func = 0, local = 0;
X
X    switch (**wp) {
X      case 'e':        /* export */
X        fset |= EXPORT;
X        break;
X      case 'r':        /* readonly */
X        fset |= RDONLY;
X        break;
X      case 't':        /* typeset */
X        local = 1;
X        break;
X    }
X
X    for (wp++; (id = *wp) != NULL && (*id == '-' || *id == '+'); wp++) {
X        int flag = 0;
X        thing = *id;
X        while (*++id != '\0') switch (*id) {
X          case 'f':
X            flag |= FUNCT;
X            func = 1;
X            break;
X          case 'i':
X            flag |= INTEGER;
X            break;
X          case 'r':
X            flag |= RDONLY;
X            break;
X          case 'x':
X            flag |= EXPORT;
X            break;
X          case 't':
X            flag |= TRACE;
X            break;
X          default:
X            errorf("unknown flag -%c\n", *id);
X        }
X        if (flag != 0) { /* + or - with options */
X            if (thing == '-')
X                fset |= flag;
X            else
X                fclr |= flag;
X            thing = 0;
X        }
X    }
X
X    /* list variables and attributes */
X    if (*wp == NULL) {
X        for (l = e.loc; l != NULL; l = l->next) {
X            for (p = tsort((func==0) ? &l->vars : &l->funs);
X             (vp = *p++) != NULL; )
X            if ((vp->flag&ISSET))
X                if (thing == 0 && fclr == 0 && fset == 0) {
X                printf("typeset ");
X                if ((vp->flag&INTEGER))
X                    printf("-i ");
X                if ((vp->flag&EXPORT))
X                    printf("-x ");
X                if ((vp->flag&RDONLY))
X                    printf("-r ");
X                if ((vp->flag&TRACE))
X                    printf("-t ");
X                printf("%s\n", vp->name);
X                } else
X                if (thing == '+' ||
X                fclr && (vp->flag&fclr) == fclr) {
X                printf("%s\n", vp->name);
X                } else
X                if (thing == '-' ||
X                fset && (vp->flag&fset) == fset) {
X                if (fset&FUNCT)
X                    printf("function %s\n", vp->name);
X                else
X                    printf("%s=%s\n", vp->name, strval(vp));
X                }
X        }
X        return (0);
X    }
X
X    if (local)
X        fset |= LOCAL;
X    for (; *wp != NULL; wp++)
X#if 0
X        if (func) {
X        } else
X#endif
X        if (typeset(*wp, fset, fclr) == NULL)
X            errorf("%s: not identifier\n", *wp);
X    return 0;
X}
X
Xint
Xc_alias(wp)
X    register char **wp;
X{
X    register struct table *t = &lexicals;
X    register struct tbl *ap, **p;
X    register int i;
X    int rv = 0;
X
X    if (*++wp != NULL && strcmp(*wp, "-d") == 0) {
X        t = &homedirs;
X        wp++;
X    }
X
X    if (*wp == NULL)
X        for (p = tsort(t); (ap = *p++) != NULL; )
X            if (ap->type == CALIAS && (ap->flag&DEFINED))
X                printf("%s='%s'\n", ap->name, ap->val.s);
X
X    for (; *wp != NULL; wp++) {
X        register char *id = *wp;
X        register char *val = strchr(id, '=');
X
X        if (val == NULL) {
X            ap = tsearch(t, id, hash(id));
X            if (ap != NULL && ap->type == CALIAS && (ap->flag&DEFINED))
X                printf("%s='%s'\n", ap->name, ap->val.s);
X            else
X                rv = 1;
X        } else {
X            *val++ = '\0';
X            ap = tenter(t, id, hash(id));
X            if (ap->type == CKEYWD)
X                errorf("cannot alias keyword\n");
X            if ((ap->flag&ALLOC)) {
X                afree((Void*)ap->val.s, APERM);
X                ap->flag &=~ ALLOC|ISSET;
X            }
X            ap->type = CALIAS;
X            ap->val.s = strsave(val, APERM);
X            ap->flag |= DEFINED|ALLOC|ISSET;
X        }
X    }
X    return rv;
X}
X
Xint
Xc_unalias(wp)
X    register char **wp;
X{
X    register struct table *t = &lexicals;
X    register struct tbl *ap;
X
X    if (*++wp != NULL && strcmp(*wp, "-d") == 0) {
X        t = &homedirs;
X        wp++;
X    }
X
X    for (; *wp != NULL; wp++) {
X        ap = tsearch(t, *wp, hash(*wp));
X        if (ap == NULL || ap->type != CALIAS)
X            continue;
X        if ((ap->flag&ALLOC))
X            afree((Void*)ap->val.s, APERM);
X        ap->flag &=~ DEFINED|ISSET|ALLOC;
X    }
X    return 0;
X}
X
Xint
Xc_let(wp)
X    char **wp;
X{
X    int rv = 1;
X
X    for (wp++; *wp; wp++)
X        rv = evaluate(*wp) == 0;
X    return rv;
X}
X
Xint
Xc_jobs(wp)
X    char **wp;
X{
X    j_jobs();
X    return 0;
X}
X
X#if JOBS
Xint
Xc_fgbg(wp)
X    register char **wp;
X{
X    int bg = strcmp(*wp, "bg") == 0;
X
X    if (!flag[FMONITOR])
X        errorf("Job control not enabled\n");
X    wp++;
X    j_resume(j_lookup((*wp == NULL) ? "%" : *wp), bg);
X    return 0;
X}
X#endif
X
Xint
Xc_kill(wp)
X    register char **wp;
X{
X    register char *cp;
X    int sig = 15;        /* SIGTERM */
X    int rv = 0;
X
X    if (*++wp == NULL)
X        errorf("Usage: kill [-l] [-signal] {pid|job} ...\n");
X    if (strcmp(*wp, "-l") == 0) {
X        register struct trap *p = sigtraps;
X        for (sig = 0; sig < SIGNALS; sig++, p++)
X            if (p->signal)
X                printf("%2d %8s %s\n", p->signal, p->name, p->mess);
X        return 0;
X    }
X
X    for (; (cp = *wp) != NULL; wp++)
X        if (*cp == '-') {
X            struct trap *p;
X            p = gettrap(cp+1);
X            if (p == NULL)
X                errorf("bad signal %s\n", cp+1);
X            sig = p->signal;
X        } else
X        if (digit(*cp)) {
X            if (kill(atoi(cp), sig) < 0) {
X                shellf("%s: %s\n", cp, strerror(errno));
X                rv++;
X            }
X        } else
X        if (*cp == '%')
X            j_kill(j_lookup(cp), sig);
X        else
X            errorf("invalid argument\n");
X    return rv;
X}
X
Xint
Xc_bind(wp)
X    register char **wp;
X{
X    int macro = 0;
X    register char *cp;
X
X    for (wp++; (cp = *wp) != NULL && *cp == '-'; wp++)
X        if (cp[1] == 'm')
X            macro = 1;
X
X    if (*wp == NULL)    /* list all */
X        x_bind((char*)NULL, (char*)NULL, 0);
X
X    for (; *wp != NULL; wp++) {
X        cp = strchr(*wp, '=');
X        if (cp != NULL)
X            *cp++ = 0;
X        x_bind(*wp, cp, macro);
X    }
X
X    return 0;
X}
X
Xextern    c_fc();
Xextern    c_getopts();
X
XConst struct builtin kshbuiltins [] = {
X    {"print", c_print},
X    {"getopts", c_getopts},
X    {"=typeset", c_typeset},
X    {"=export", c_typeset},
X    {"=readonly", c_typeset},
X    {"whence", c_whence},
X    {"alias", c_alias},
X    {"unalias", c_unalias},
X    {"hash", c_hash},
X    {"let", c_let},
X    {"fc", c_fc},
X    {"jobs", c_jobs},
X    {"kill", c_kill},
X#if JOBS
X    {"fg", c_fgbg},
X    {"bg", c_fgbg},
X#endif
X#if EDIT
X    {"bind", c_bind},
X#endif
X    {NULL, NULL}
X};
X
SHAR_EOF
true || echo 'restore of src/c_ksh.c failed'
fi
# ============= src/c_test.c ==============
if test -f 'src/c_test.c' -a X"$1" != X"-c"; then
    echo 'x - skipping src/c_test.c (File already exists)'
else
echo 'x - extracting src/c_test.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'src/c_test.c' &&
X/*
X * test(1); version 7-like  --  author Erik Baalbergen
X * modified by Eric Gisin to be used as built-in.
X * modified by Arnold Robbins to add SVR3 compatibility
X * (-x -c -b -p -u -g -k) plus Korn's -L -nt -ot -ef and new -S (socket).
X */
X
Xstatic char *RCSid = "$Header: /tmp/egisin/src/RCS/c_test.c,v 3.2 88/12/17 21:39:26 egisin Exp $";
X
X#include <stddef.h>
X#include <string.h>
X#include <signal.h>
X#include <errno.h>
X#include <setjmp.h>
X#include <sys/types.h>
X#include <sys/stat.h>
X#include "sh.h"
X
X/* test(1) accepts the following grammar:
X    oexpr    ::= aexpr | aexpr "-o" oexpr ;
X    aexpr    ::= nexpr | nexpr "-a" aexpr ;
X    nexpr    ::= primary ! "!" primary
X    primary    ::= unary-operator operand
X        | operand binary-operator operand
X        | operand
X        | "(" oexpr ")"
X        ;
X    unary-operator ::= "-r"|"-w"|"-x"|"-f"|"-d"|"-c"|"-b"|"-p"|
X        "-u"|"-g"|"-k"|"-s"|"-t"|"-z"|"-n"|"-o"|"-O"|"-G"|"-L"|"-S";
X
X    binary-operator ::= "="|"!="|"-eq"|"-ne"|"-ge"|"-gt"|"-le"|"-lt"|
X            "-nt"|"-ot"|"-ef";
X    operand ::= <any legal UNIX file name>
X*/
X
X#define EOI    0
X#define FILRD    1
X#define FILWR    2
X#define FILREG    3
X#define FILID    4
X#define FILGZ    5
X#define FILTT    6
X#define STZER    7
X#define STNZE    8
X#define STEQL    9
X#define STNEQ    10
X#define INTEQ    11
X#define INTNE    12
X#define INTGE    13
X#define INTGT    14
X#define INTLE    15
X#define INTLT    16
X#define UNOT    17
X#define BAND    18
X#define BOR    19
X#define LPAREN    20
X#define RPAREN    21
X#define OPERAND    22
X#define FILEX    23
X#define FILCDEV    24
X#define FILBDEV    25
X#define FILFIFO    26
X#define FILSETU    27
X#define FILSETG    28
X#define FILSTCK    29
X#define FILSYM    30
X#define FILNT    31
X#define FILOT    32
X#define FILEQ    33
X#define FILSOCK    34
X#define    FILUID    35
X#define    FILGID    36
X#define    OPTION    37
X
X#define UNOP    1
X#define BINOP    2
X#define BUNOP    3
X#define BBINOP    4
X#define PAREN    5
X
Xstruct t_op {
X    char *op_text;
X    short op_num, op_type;
X} Const ops [] = {
X    {"-r",    FILRD,    UNOP},
X    {"-w",    FILWR,    UNOP},
X    {"-x",    FILEX,    UNOP},
X    {"-f",    FILREG,    UNOP},
X    {"-d",    FILID,    UNOP},
X    {"-c",    FILCDEV,UNOP},
X    {"-b",    FILBDEV,UNOP},
X    {"-p",    FILFIFO,UNOP},
X    {"-u",    FILSETU,UNOP},
X    {"-g",    FILSETG,UNOP},
X    {"-k",    FILSTCK,UNOP},
X    {"-s",    FILGZ,    UNOP},
X    {"-t",    FILTT,    UNOP},
X    {"-z",    STZER,    UNOP},
X    {"-n",    STNZE,    UNOP},
X#if 0                /* conficts with binary -o */
X    {"-o",    OPTION,    UNOP},
X#endif
X    {"-U",    FILUID,    UNOP},
X    {"-G",    FILGID,    UNOP},
X    {"-L",    FILSYM,    UNOP},
X    {"-S",    FILSOCK,UNOP},
X    {"=",    STEQL,    BINOP},
X    {"!=",    STNEQ,    BINOP},
X    {"-eq",    INTEQ,    BINOP},
X    {"-ne",    INTNE,    BINOP},
X    {"-ge",    INTGE,    BINOP},
X    {"-gt",    INTGT,    BINOP},
X    {"-le",    INTLE,    BINOP},
X    {"-lt",    INTLT,    BINOP},
X    {"-nt",    FILNT,    BINOP},
X    {"-ot",    FILOT,    BINOP},
X    {"-ef",    FILEQ,    BINOP},
X    {"!",    UNOT,    BUNOP},
X    {"-a",    BAND,    BBINOP},
X    {"-o",    BOR,    BBINOP},
X    {"(",    LPAREN,    PAREN},
X    {")",    RPAREN,    PAREN},
X    {0,    0,    0}
X};
X
Xchar **t_wp;
Xstruct t_op Const *t_wp_op;
X
Xint
Xc_test(wp)
X    char **wp;
X{
X    t_wp = wp+1;
X    if (strcmp(wp[0], "[") == 0) {
X        while (*wp != NULL)
X            wp++;
X        if (strcmp(*--wp, "]") != 0)
X            errorf("[: missing ]\n");
X        *wp = NULL;
X    }
X    return *t_wp == NULL || !oexpr(t_lex(*t_wp));
X}
X
Xstatic
Xsyntax()
X{
X    errorf("test: syntax error\n");
X}
X
Xoexpr(n)
X{
X    int res;
X
X    res = aexpr(n);
X    if (t_lex(*++t_wp) == BOR)
X        return oexpr(t_lex(*++t_wp)) || res;
X    t_wp--;
X    return res;
X}
X
Xaexpr(n)
X{
X    int res;
X
X    res = nexpr(n);
X    if (t_lex(*++t_wp) == BAND)
X        return aexpr(t_lex(*++t_wp)) && res;
X    t_wp--;
X    return res;
X}
X
Xnexpr(n)
X    int n;            /* token */
X{
X    if (n == UNOT)
X        return !nexpr(t_lex(*++t_wp));
X    return primary(n);
X}
X
Xprimary(n)
X    int n;            /* token */
X{
X    register char *opnd1, *opnd2;
X    int res;
X
X    if (n == EOI)
X        syntax();
X    if (n == LPAREN) {
X        res = oexpr(t_lex(*++t_wp));
X        if (t_lex(*++t_wp) != RPAREN)
X            syntax();
X        return res;
X    }
X    if (n == OPERAND) {
X        opnd1 = *t_wp;
X        (void) t_lex(*++t_wp);
X        if (t_wp_op && t_wp_op->op_type == BINOP) {
X            struct t_op Const *op = t_wp_op;
X
X            if ((opnd2 = *++t_wp) == (char *)0)
X                syntax();
X
X            switch (op->op_num) {
X            case STEQL:
X                return strcmp(opnd1, opnd2) == 0;
X            case STNEQ:
X                return strcmp(opnd1, opnd2) != 0;
X            case INTEQ:
X                return evaluate(opnd1) == evaluate(opnd2);
X            case INTNE:
X                return evaluate(opnd1) != evaluate(opnd2);
X            case INTGE:
X                return evaluate(opnd1) >= evaluate(opnd2);
X            case INTGT:
X                return evaluate(opnd1) > evaluate(opnd2);
X            case INTLE:
X                return evaluate(opnd1) <= evaluate(opnd2);
X            case INTLT:
X                return evaluate(opnd1) < evaluate(opnd2);
X            case FILNT:
X                return newerf (opnd1, opnd2);
X            case FILOT:
X                return olderf (opnd1, opnd2);
X            case FILEQ:
X                return equalf (opnd1, opnd2);
X            }
X        }
X        t_wp--;
X        return strlen(opnd1) > 0;
X    }
X    if (t_wp_op->op_type == UNOP) {
X        /* unary expression */
X        if (*++t_wp == NULL && n != FILTT)
X            syntax();
X        switch (n) {
X          case OPTION:
X            return flag[option(*t_wp)];
X          case STZER:
X            return strlen(*t_wp) == 0;
X          case STNZE:
X            return strlen(*t_wp) != 0;
X          case FILTT:
X            if (!digit(**t_wp))
X                return filstat("0", n);
X          default:    /* all other FIL* */
X            return filstat(*t_wp, n);
X        }
X    }
X    syntax();
X}
X
Xfilstat(nm, mode)
X    char *nm;
X{
X    struct stat s;
X
X    switch (mode) {
X    case FILRD:
X        return eaccess(nm, 4) == 0;
X    case FILWR:
X        return eaccess(nm, 2) == 0;
X    case FILEX:
X        return eaccess(nm, 1) == 0;
X    case FILREG:
X        return stat(nm, &s) == 0 && (s.st_mode & S_IFMT) == S_IFREG;
X    case FILID:
X        return stat(nm, &s) == 0 && (s.st_mode & S_IFMT) == S_IFDIR;
X    case FILCDEV:
X        return stat(nm, &s) == 0 && (s.st_mode & S_IFMT) == S_IFCHR;
X    case FILBDEV:
X        return stat(nm, &s) == 0 && (s.st_mode & S_IFMT) == S_IFBLK;
X    case FILFIFO:
X#ifdef S_IFIFO
X        return stat(nm, &s) == 0 && (s.st_mode & S_IFMT) == S_IFIFO;
X#else
X        return 0;
X#endif
X    case FILSETU:
X        return stat(nm, &s) == 0 && (s.st_mode & S_ISUID) == S_ISUID;
X    case FILSETG:
X        return stat(nm, &s) == 0 && (s.st_mode & S_ISGID) == S_ISGID;
X    case FILSTCK:
X        return stat(nm, &s) == 0 && (s.st_mode & S_ISVTX) == S_ISVTX;
X    case FILGZ:
X        return stat(nm, &s) == 0 && s.st_size > 0L;
X    case FILTT:
X        return isatty(getn(nm));
X      case FILUID:
X        return stat(nm, &s) == 0 && s.st_uid == geteuid();
X      case FILGID:
X        return stat(nm, &s) == 0 && s.st_gid == getegid();
X#ifdef S_IFLNK
X    case FILSYM:
X        return lstat(nm, &s) == 0 && (s.st_mode & S_IFMT) == S_IFLNK;
X#endif
X#ifdef S_IFSOCK
X    case FILSOCK:
X        return stat(nm, &s) == 0 && (s.st_mode & S_IFMT) == S_IFSOCK;
X#endif
X      default:
X        return 1;
X    }
X}
X
Xint
Xt_lex(s)
X    register char *s;
X{
X    register struct t_op Const *op = ops;
X
X    if (s == 0)
X        return EOI;
X    while (op->op_text) {
X        if (strcmp(s, op->op_text) == 0) {
X            t_wp_op = op;
X            return op->op_num;
X        }
X        op++;
X    }
X    t_wp_op = (struct t_op *)0;
X    return OPERAND;
X}
X
Xnewerf (f1, f2)
Xchar *f1, *f2;
X{
X    struct stat b1, b2;
X
X    return (stat (f1, &b1) == 0 &&
X        stat (f2, &b2) == 0 &&
X        b1.st_mtime > b2.st_mtime);
X}
X
Xolderf (f1, f2)
Xchar *f1, *f2;
X{
X    struct stat b1, b2;
X
X    return (stat (f1, &b1) == 0 &&
X        stat (f2, &b2) == 0 &&
X        b1.st_mtime < b2.st_mtime);
X}
X
Xequalf (f1, f2)
Xchar *f1, *f2;
X{
X    struct stat b1, b2;
X
X    return (stat (f1, &b1) == 0 &&
X        stat (f2, &b2) == 0 &&
X        b1.st_dev == b2.st_dev &&
X        b1.st_ino == b2.st_ino);
X}
X
SHAR_EOF
true || echo 'restore of src/c_test.c failed'
fi
# ============= src/getopts.c ==============
if test -f 'src/getopts.c' -a X"$1" != X"-c"; then
    echo 'x - skipping src/getopts.c (File already exists)'
else
echo 'x - extracting src/getopts.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'src/getopts.c' &&
X/*
X * Reimplementation of SysVr3 sh builtin command "getopts" for S5R2 shell.
X *
X * created by Arnold Robbins
X * modified by Doug Gwyn
X * modified for PD ksh by Eric Gisin
X */
X
Xstatic char *RCSid = "$Header: /tmp/egisin/src/RCS/getopts.c,v 3.2 89/01/14 13:29:26 egisin Exp $";
X
X#include <stddef.h>
X#include <string.h>
X#include <errno.h>
X#include <setjmp.h>
X#include "sh.h"
X#include "table.h"
X
X/*
X * The following is derived from getopt() source placed into the public
X * domain by AT&T (the only time they're known to have done that).
X *
X * It has been modified somewhat to fit into the context of the shell.
X *
X * -D"FASCIST" if you really want to strictly enforce ALL the
X * Command Syntax Standard rules (not recommended).
X */
X
X#define GETOPTEOF    (-1)
X#define ERR(S, C)    shellf("%s%c\n", (S), (C))
X
Xstatic    int    optind;
Xstatic char    *optarg;
Xstatic int    sp;
X
Xstatic int
Xgetopt(argc, argv, opts)
X    int argc;
X    register char **argv, *opts;
X{
X    register int c;
X    register char *cp;
X
X    if (sp == 1)
X        if (optind >= argc ||
X           argv[optind][0] != '-' || argv[optind][1] == '\0')
X            return(GETOPTEOF);
X        else if (strcmp(argv[optind], "--") == 0) {
X            optind++;
X            return(GETOPTEOF);
X        }
X    c = argv[optind][sp];
X    if (c == ':' || (cp=strchr(opts, c)) == NULL) {
X        ERR("illegal option -- ", c);
X        if (argv[optind][++sp] == '\0') {
X            optind++;
X            sp = 1;
X        }
X        optarg = NULL;
X        return('?');
X    }
X    if (*++cp == ':') {
X#if FASCIST
X        if (sp != 1) {
X            ERR("option must not be grouped -- ", c );
X            optind++;
X            sp = 1;
X            optarg = NULL;
X            return('?');
X        } else
X#endif
X        if (argv[optind][sp+1] != '\0') {
X#if FASCIST
X            ERR("option must be followed by whitespace -- ", c );
X            optind++;
X            sp = 1;
X            optarg = NULL;
X            return('?');
X#else
X            optarg = &argv[optind++][sp+1];
X#endif
X        } else if (++optind >= argc) {
X            ERR("option requires an argument -- ", c);
X            sp = 1;
X            optarg = NULL;
X            return('?');
X        } else
X            optarg = argv[optind++];
X        sp = 1;
X    } else {
X        if (argv[optind][++sp] == '\0') {
X            sp = 1;
X            optind++;
X        }
X        optarg = NULL;
X    }
X    return(c);
X}
X
X/*
X * The following were created by Arnold Robbins.
X */
X
X/* resetopts --- magic code for when OPTIND is reset to 1 */
X
Xvoid
Xresetopts ()
X{
X    optind = 1;
X    sp = 1;
X}
X
Xint
Xc_getopts(wp)
X    char **wp;
X{
X    int ret;
X    register int argc;
X    char temp[2];
X    char *optstr;            /* list of options */
X    char *name;            /* variable to get flag val */
X
X    if ((optstr = *++wp) == NULL || (name = *++wp) == NULL)
X        errorf("missing arguments\n");
X
X    for (argc = 1; wp[argc] != NULL; argc++)
X        ;
X
X    if (argc > 1)
X        ret = getopt(argc, wp, optstr);
X    else
X        ret = getopt(e.loc->argc+1, e.loc->argv, optstr);
X
X    /*
X     * set the OPTIND variable in any case, to handle "--" skipping
X     */
X
X    setint(global("OPTIND"), (long)optind);
X
X    if (ret == GETOPTEOF)        /* end of args */
X        return (1);
X
X    /*
X     * else, got an arg, set the various shell variables
X     */
X
X    if (optarg != NULL)
X        setstr(global("OPTARG"), optarg);
X
X    temp[0] = (char) ret;
X    temp[1] = '\0';
X    setstr(global(name), temp);
X
X    return (0);
X}
X
SHAR_EOF
true || echo 'restore of src/getopts.c failed'
fi
# ============= src/ulimit.c ==============
if test -f 'src/ulimit.c' -a X"$1" != X"-c"; then
    echo 'x - skipping src/ulimit.c (File already exists)'
else
echo 'x - extracting src/ulimit.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'src/ulimit.c' &&
X/*
X    ulimit -- handle "ulimit" builtin
X
X    Eric Gisin, September 1988
X    Adapted to PD KornShell. Removed AT&T code.
X
X    last edit:    06-Jun-1987    D A Gwyn
X
X    This started out as the BRL UNIX System V system call emulation
X    for 4.nBSD, and was later extended by Doug Kingston to handle
X    the extended 4.nBSD resource limits.  It now includes the code
X    that was originally under case SYSULIMIT in source file "xec.c".
X*/
X
Xstatic char *RCSid = "$Header: /tmp/egisin/src/RCS/ulimit.c,v 3.1 88/11/03 09:18:11 egisin Exp $";
X
X#include <stddef.h>
X#include <errno.h>
X#include <signal.h>
X#include <setjmp.h>
X#if defined(_BSD) || defined(_BSD_SYSV)
X#include <sys/time.h>
X#include <sys/resource.h>
X#else
X#define    RLIMIT_FSIZE    2
X#endif
X#include "sh.h"
X
Xextern    long ulimit();
X
Xint
Xdo_ulimit(a1, a2)
X    char    *a1, *a2;
X{
X    register int    c;
X    long        i;
X#if defined(_BSD) || defined(_BSD_SYSV)
X    struct rlimit    limit;        /* data being gotten/set */
X    int        softonly = 0;    /* set => soft limit, clear => hard limit */
X    int        factor = 1024;    /* unit scaling (1K or 1) */
X#endif
X    int    command = RLIMIT_FSIZE;
X
X    if (a1 && (*a1 == '-'))        /* DAG -- Gould added first test */
X    {    c = *++a1;        /* DAG */
X#if defined(_BSD) || defined(_BSD_SYSV)
X        if (c >= 'A' && c <= 'Z')
X        {
X            ++softonly;
X            c += 'a' - 'A';    /* DAG -- map to lower-case */
X        }
X#endif
X        switch(c)
X        {
X#if defined(_BSD) || defined(_BSD_SYSV)
X            case 'c':
X                command = RLIMIT_CORE;
X                break;
X            case 'd':
X                command = RLIMIT_DATA;
X                break;
X            case 'm':
X                command = RLIMIT_RSS;
X                break;
X            case 's':
X                command = RLIMIT_STACK;
X                break;
X            case 't':
X                factor = 1;
X                command = RLIMIT_CPU;
X                break;
X#endif    /* _BSD || _BSD_SYSV */
X            case 'f':
X                command = RLIMIT_FSIZE;
X#if _BSD_SYSV
X                factor = 512;
X#endif
X                break;
X            default:
X#if _BSD
X                errorf("Usage: %s [-cdmstf] [limit]\n", "ulimit");
X#else
X                errorf("Usage: %s [-f] [limit]\n", "ulimit");
X#endif
X        }
X        a1 = a2;
X    }
X    if (a1)
X    {
X        i = 0;
X        while ((c = *a1++) >= '0' && c <= '9')
X        {
X            i = (i * 10) + (long)(c - '0');
X            if (i < 0)
X                goto Error;
X        }
X        if (c || i < 0)
X            goto Error;
X    }
X#if !(defined(_BSD) || defined(_BSD_SYSV))
X    else
X    {
X        i = -1;
X        command--;
X    }
X
X    if ((i = ulimit(command, i)) < 0L)
X        goto Error;
X
X    if (command != RLIMIT_FSIZE)
X        shellf("%ld\n", i);
X#else                    /* DPK -- generalized for 4.nBSD: */
X    if (getrlimit(command, &limit))
X        goto Error;    /* errno is already set */
X
X    if (a1)
X    {
X        limit.rlim_cur = i * factor;
X
X        if (!softonly)
X            limit.rlim_max = limit.rlim_cur;
X
X        if (setrlimit(command, &limit))
X            goto Error;
X    }
X    else
X    {
X        i = softonly ? limit.rlim_cur : limit.rlim_max;
X#if _BSD            /* DAG -- System V always prints an integer */
X        if (i == RLIM_INFINITY)
X            shellf("unlimited\n");
X        else
X#endif
X            shellf("%ld\n", i/factor);
X    }
X#endif    /* _BSD || _BSD_SYSV */
X    return 0;
X
X  Error:
X    errorf("bad ulimit\n");
X}
X
SHAR_EOF
true || echo 'restore of src/ulimit.c failed'
fi
# ============= src/var.c ==============
if test -f 'src/var.c' -a X"$1" != X"-c"; then
    echo 'x - skipping src/var.c (File already exists)'
else
echo 'x - extracting src/var.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'src/var.c' &&
Xstatic char *RCSid = "$Header: /tmp/egisin/src/RCS/var.c,v 3.1 88/11/03 09:18:22 egisin Exp $";
X
X#include <stddef.h>
X#include <string.h>
X#include <errno.h>
X#include <setjmp.h>
X#include <time.h>
X#include "sh.h"
X#include "table.h"
X#include "expand.h"
X
X/*
X * Variables
X *
X * WARNING: unreadable code, needs a rewrite
X *
X * if (flag&INTEGER), val.i contains integer value, and type contains base.
X * otherwise, (val.s + type) contains string value.
X * if (flag&EXPORT), val.s contains "name=value" for E-Z exporting.
X */
Xchar    null []    = "";
Xstatic    struct tbl vtemp;
Xstatic    void getspec(), setspec();
Xstatic    void export ARGS((struct tbl *, char *val));
Xstatic    int special ARGS ((char *name));
X
X/*
X * create a new block for function calls and simple commands
X * assume caller has allocated and set up e.loc
X */
Xvoid
Xnewblock()
X{
X    register struct block *l = e.loc;
X    static char *empty[] = {""};
X
X    ainit(&l->area);
X    l->argc = 0;
X    l->argv = empty;
X    l->exit = l->error = NULL;
X    tinit(&l->vars, &l->area);
X    tinit(&l->funs, &l->area);
X}
X
X/*
X * pop a block handling special variables
X */
Xvoid
Xpopblock()
X{
X    register struct block *l = e.loc;
X    register struct tbl *vp, **vpp = l->vars.tbls;
X    register int i;
X
X    e.loc = l->next;    /* pop block */
X    for (i = l->vars.size; --i >= 0; )
X        if ((vp = *vpp++) != NULL && (vp->flag&SPECIAL))
X            setspec(global(vp->name));
X    afreeall(&l->area);
X}
X
X/*
X * Search for variable, if not found create globally.
X */
Xstruct tbl *
Xglobal(n)
X    register char *n;
X{
X    register struct block *l = e.loc;
X    register struct tbl *vp;
X    register int c;
X    unsigned h = hash(n);
X
X    c = n[0];
X    if (digit(c)) {
X        vp = &vtemp;
X        lastarea = ATEMP;
X        vp->flag = (DEFINED|RDONLY);
X        vp->type = 0;
X        *vp->name = c;    /* should strncpy */
X        for (c = 0; digit(*n) && c < 1000; n++)
X            c = c*10 + *n-'0';
X        if (c <= l->argc)
X            setstr(vp, l->argv[c]);
X        return vp;
X    } else
X    if (!letter(c)) {
X        vp = &vtemp;
X        lastarea = ATEMP;
X        vp->flag = (DEFINED|RDONLY);
X        vp->type = 0;
X        *vp->name = c;
X        if (n[1] != '\0')
X            return vp;
X        vp->flag |= ISSET|INTEGER;
X        switch (c) {
X          case '$':
X            vp->val.i = getpid();
X            break;
X          case '!':
X            vp->val.i = async;
X            break;
X          case '?':
X            vp->val.i = exstat;
X            break;
X          case '#':
X            vp->val.i = l->argc;
X            break;
X          case '-':
X            vp->flag &= ~ INTEGER;
X            vp->val.s = getoptions();
X            break;
X          default:
X            vp->flag &= ~(ISSET|INTEGER);
X        }
X        return vp;
X    }
X    for (l = e.loc; l != NULL; l = l->next) {
X        vp = tsearch(&l->vars, n, h);
X        lastarea = &l->area;
X        if (vp != NULL)
X            return vp;
X        if (l->next == NULL)
X            break;
X    }
X    vp = tenter(&l->vars, n, h);
X    vp->flag |= DEFINED;
X    if (special(n))
X        vp->flag |= SPECIAL;
X    return vp;
X}
X
X/*
X * Search for local variable, if not found create locally.
X */
Xstruct tbl *
Xlocal(n)
X    register char *n;
X{
X    register struct block *l = e.loc;
X    register struct tbl *vp;
X    unsigned h = hash(n);
X
X    if (!letter(*n)) {
X        vp = &vtemp;
X        lastarea = ATEMP;
X        vp->flag = (DEFINED|RDONLY);
X        vp->type = 0;
X        return vp;
X    }
X    vp = tenter(&l->vars, n, h);
X    lastarea = &l->area;
X    vp->flag |= DEFINED;
X    if (special(n))
X        vp->flag |= SPECIAL;
X    return vp;
X}
X
X/* get variable string value */
Xchar *
Xstrval(vp)
X    register struct tbl *vp;
X{
X    register char *s;
X    static char strbuf[40];
X
X    if ((vp->flag&SPECIAL))
X        getspec(vp);
X    if (!(vp->flag&ISSET))
X        return null;    /* special to dollar() */
X    if (!(vp->flag&INTEGER))    /* string source */
X        s = vp->val.s + vp->type;
X    else {                /* integer source */
X        register unsigned long n;
X        register int base;
X
X        s = strbuf + sizeof(strbuf);
X        n = (vp->val.i < 0) ? -vp->val.i : vp->val.i;
X        base = (vp->type == 0) ? 10 : vp->type;
X
X        *--s = '\0';
X        do {
X            *--s = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[n%base];
X            n /= base;
X        } while (n != 0);
X        /* todo: should we output base# ? */
X        if (vp->val.i < 0)
X            *--s = '-';
X    }
X    return s;
X}
X
X/* get variable integer value */
Xlong
Xintval(vp)
X    register struct tbl *vp;
X{
X    register struct tbl *vq;
X
X    if ((vp->flag&SPECIAL))
X        getspec(vp);
X    if ((vp->flag&INTEGER))
X        return vp->val.i;
X    vq = &vtemp;
X    vq->flag = (INTEGER);
X    vq->type = 0;
X    strint(vq, vp);
X    return vq->val.i;
X}
X
X/* set variable to string value */
Xvoid
Xsetstr(vq, s)
X    register struct tbl *vq;
X    char *s;
X{
X    if (!(vq->flag&INTEGER)) { /* string dest */
X        if ((vq->flag&ALLOC))
X            afree((Void*)vq->val.s, lastarea);
X        vq->flag &= ~ (ISSET|ALLOC);
X        vq->type = 0;
X        if ((vq->flag&EXPORT))
X            export(vq, s);
X        else
X            vq->val.s = strsave(s, lastarea);
X        vq->flag |= ALLOC;
X    } else {        /* integer dest */
X        register struct tbl *vp = &vtemp;
X        vp->flag = (DEFINED|ISSET);
X        vp->type = 0;
X        vp->val.s = s;
X        strint(vq, vp);
X    }
X    vq->flag |= ISSET;
X    if ((vq->flag&SPECIAL))
X        setspec(vq);
X}
X
X/* convert variable to integer variable */
Xstruct tbl *
Xstrint(vq, vp)
X    register struct tbl *vq, *vp;
X{
X    register char *s = vp->val.s + vp->type;
X    register int c;
X    int base, neg = 0;
X
X    vq->flag |= INTEGER;
X    if ((vp->flag&INTEGER)) {
X        vq->val.i = vp->val.i;
X        return vq;
X    }
X    vq->val.i = 0;
X    base = 10;
X    for (c = *s++; c ; c = *s++)
X        if (c == '-') {
X            neg++;
X        } else if (c == '#') {
X            base = vq->type = vq->val.i;
X            vq->val.i = 0;
X        } else if (letnum(c)) {
X            if ('0' <= c && c <= '9')
X                c -= '0';
X            else if ('a' <= c && c <= 'z') /* fuck EBCDIC */
X                c -= 'a'-10;
X            else if ('A' <= c && c <= 'Z')
X                c -= 'A'-10;
X            vq->val.i = (vq->val.i*base) + c;
X        } else
X            break;
X    if (neg)
X        vq->val.i = -vq->val.i;
X    if (vq->type < 2 || vq->type > 36)
X        vq->type = 0;    /* default base (10) */
X    return vq;
X}
X
X/* set variable to integer */
Xvoid
Xsetint(vq, n)
X    register struct tbl *vq;
X    long n;
X{
X    if (!(vq->flag&INTEGER)) {
X        register struct tbl *vp = &vtemp;
X        vp->flag = (ISSET|INTEGER);
X        vp->type = 0;
X        vp->val.i = n;
X        setstr(vq, strval(vp));    /* ? */
X    } else
X        vq->val.i = n;
X    vq->flag |= ISSET;
X    if ((vq->flag&SPECIAL))
X        setspec(vq);
X}
X
X/* set variable from enviroment */
Ximport(thing)
X    char *thing;
X{
X    register struct tbl *vp;
X    register char *val;
X
X    val = strchr(thing, '=');
X    if (val == NULL)
X        return 0;
X    *val = '\0';
X    vp = local(thing);
X    *val++ = '=';
X    vp->flag |= DEFINED|ISSET|EXPORT;
X    vp->val.s = thing;
X    vp->type = val - thing;
X    if ((vp->flag&SPECIAL))
X        setspec(vp);
X    return 1;
X}
X
X/*
X * make vp->val.s be "name=value" for quick exporting.
X */
Xstatic void
Xexport(vp, val)
X    register struct tbl *vp;
X    char *val;
X{
X    register char *cp, *xp;
X    char *op = (vp->flag&ALLOC) ? vp->val.s : NULL;
X
X    xp = (char*)alloc(strlen(vp->name) + strlen(val) + 2, lastarea);
X    vp->flag |= ALLOC;
X    vp->val.s = xp;
X    for (cp = vp->name; (*xp = *cp++) != '\0'; xp++)
X        ;
X    *xp++ = '=';
X    vp->type = xp - vp->val.s; /* offset to value */
X    for (cp = val; (*xp++ = *cp++) != '\0'; )
X        ;
X    if (op != NULL)
X        afree((Void*)op, lastarea);
X}
X
X/*
X * lookup variable (according to (set&LOCAL)),
X * set its attributes (INTEGER, RDONLY, EXPORT, TRACE),
X * and optionally set its value if an assignment.
X */
Xstruct tbl *
Xtypeset(var, set, clr)
X    register char *var;
X    int clr, set;
X{
X    register struct tbl *vp;
X    register char *val;
X
X    /* check for valid variable name, search for value */
X    val = var;
X    if (!letter(*val))
X        return NULL;
X    for (val++; *val != '\0'; val++)
X        if (*val == '=')
X            break;
X        else if (letnum(*val))
X            ;
X        else
X            return NULL;
X    if (*val == '=')
X        *val = '\0';
X    else
X        val = NULL;
X    vp = (set&LOCAL) ? local(var) : global(var);
X    set &= ~ LOCAL;
X    if (val != NULL)
X        *val++ = '=';
X
X    if (!(vp->flag&ISSET))
X        vp->flag = vp->flag & ~clr | set;
X    else
X        if (!(vp->flag&INTEGER) && (set&INTEGER)) {
X        /* string to integer */
X        vtemp.flag = (ISSET);
X        vtemp.type = 0;
X        vtemp.val.s = vp->val.s + vp->type;
X        if ((vp->flag&ALLOC))
X            afree((Void*)vp->val.s, lastarea); /* dangerous, used later */
X        vp->flag &= ~ ALLOC;
X        vp->flag |= INTEGER;
X        vp->type = 0;
X        strint(vp, &vtemp);
X        } else
X        if ((clr&INTEGER) && (vp->flag&INTEGER)) {
X        /* integer to string */
X        vtemp.val.s = strval(vp);
X        vp->flag &= ~ INTEGER;
X        setstr(vp, vtemp.val.s);
X        }
X
X    vp->flag = vp->flag & ~clr | set;
X
X    if (val != NULL) {
X        if ((vp->flag&RDONLY))
X            errorf("cannot set readonly %s\n", var);
X        if ((vp->flag&INTEGER))
X            /* setstr should be able to handle this */
X            (void)evaluate(var);
X        else
X            setstr(vp, val);
X    }
X
X    if ((vp->flag&EXPORT) && !(vp->flag&INTEGER) && vp->type == 0)
X        export(vp, (vp->flag&ISSET) ? vp->val.s : null);
X
X    return vp;
X}
X
Xvoid
Xunset(vp)
X    register struct tbl *vp;
X{
X    if ((vp->flag&ALLOC))
X        afree((Void*)vp->val.s, lastarea);
X    vp->flag &= ~ (ALLOC|ISSET);
X}
X
Xint
Xisassign(s)
X    register char *s;
X{
X    if (!letter(*s))
X        return (0);
X    for (s++; *s != '='; s++)
X        if (*s == 0 || !letnum(*s))
X            return (0);
X    return (1);
X}
X
X/*
X * Make the exported environment from the exported names in the dictionary.
X */
Xchar **
Xmakenv()
X{
X    struct block *l = e.loc;
X    XPtrV env;
X    register struct tbl *vp, **vpp;
X    register int i;
X
X    XPinit(env, 64);
X    for (l = e.loc; l != NULL; l = l->next)
X        for (vpp = l->vars.tbls, i = l->vars.size; --i >= 0; )
X            if ((vp = *vpp++) != NULL
X                && (vp->flag&(ISSET|EXPORT)) == (ISSET|EXPORT)) {
X                register struct block *l2;
X                register struct tbl *vp2;
X                unsigned h = hash(vp->name);
X
X                lastarea = &l->area;
X
X                /* unexport any redefined instances */
X                for (l2 = l->next; l2 != NULL; l2 = l2->next) {
X                    vp2 = tsearch(&l2->vars, vp->name, h);
X                    if (vp2 != NULL)
X                        vp2->flag &= ~ EXPORT;
X                }
X                if ((vp->flag&INTEGER)) {
X                    /* integer to string */
X                    char *val;
X                    val = strval(vp);
X                    vp->flag &= ~ INTEGER;
X                    setstr(vp, val);
X                }
X                XPput(env, vp->val.s);
X            }
X    XPput(env, NULL);
X    return (char **) XPclose(env);
X}
X
X/*
X * handle special variables with side effects - PATH, SECONDS.
X */
X
Xstatic int
Xspecial(name)
X    register char * name;
X{
X    if (strcmp("PATH", name) == 0)
X        return V_PATH;
X    if (strcmp("IFS", name) == 0)
X        return V_IFS;
X    if (strcmp("SECONDS", name) == 0)
X        return V_SECONDS;
X    if (strcmp("OPTIND", name) == 0)
X        return V_OPTIND;
X    return V_NONE;
X}
X
Xextern    time_t time();
Xstatic    time_t    seconds;        /* time SECONDS last set */
X
Xstatic void
Xgetspec(vp)
X    register struct tbl *vp;
X{
X    switch (special(vp->name)) {
X    case V_SECONDS:
X        vp->flag &= ~ SPECIAL;
X        setint(vp, time((time_t *)0) - seconds);
X        vp->flag |= SPECIAL;
X        break;
X    }
X}
X
Xstatic void
Xsetspec(vp)
X    register struct tbl *vp;
X{
X    switch (special(vp->name)) {
X      case V_PATH:
X        path = strval(vp);
X        flushcom(1);    /* clear tracked aliases */
X        break;
X      case V_IFS:
X        setctypes(strval(vp), C_IFS);
X        break;
X      case V_SECONDS:
X        seconds = time((time_t *)0);
X        break;
X      case V_OPTIND:
X        if (intval(vp) == 1)
X            resetopts();
X        break;
X    }
X}
X
SHAR_EOF
true || echo 'restore of src/var.c failed'
fi
# ============= src/table.c ==============
if test -f 'src/table.c' -a X"$1" != X"-c"; then
    echo 'x - skipping src/table.c (File already exists)'
else
echo 'x - extracting src/table.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'src/table.c' &&
Xstatic char *RCSid = "$Header: /tmp/egisin/src/RCS/table.c,v 3.1 88/11/03 09:17:53 egisin Exp $";
X
X/*
X * dynamic hashed associative table for commands and variables
X */
X
X#include <stddef.h>
X#include <errno.h>
X#include <setjmp.h>
X#include "sh.h"
X#include "table.h"
X
X#define    INIT_TBLS    8    /* initial table size (power of 2) */
X
Xstatic struct tstate {
X    int left;
X    struct tbl **next;
X} tstate;
X
Xstatic void texpand();
X
Xunsigned int
Xhash(n)
X    register char * n;
X{
X    register unsigned int h = 0;
X
X    while (*n != '\0')
X        h = 2*h + *n++;
X    return h * 32821;    /* scatter bits */
X}
X
X#if 0
Xphash(s) char *s; {
X    printf("%2d: %s\n", hash(s)%32, s);
X}
X#endif
X
Xvoid
Xtinit(tp, ap)
X    register struct table *tp;
X    register Area *ap;
X{
X    tp->areap = ap;
X    tp->size = tp->free = 0;
X    tp->tbls = NULL;
X}
X
Xstatic void
Xtexpand(tp, nsize)
X    register struct table *tp;
X    int nsize;
X{
X    register int i;
X    register struct tbl *tblp, **p;
X    register struct tbl **ntblp, **otblp = tp->tbls;
X    int osize = tp->size;
X
X    ntblp = alloc(sizeofN(struct tbl *, nsize), tp->areap);
X    for (i = 0; i < nsize; i++)
X        ntblp[i] = NULL;
X    tp->size = nsize;
X    tp->free = 8*nsize/10;    /* table can get 80% full */
X    tp->tbls = ntblp;
X    if (otblp == NULL)
X        return;
X    for (i = 0; i < osize; i++)
X        if ((tblp = otblp[i]) != NULL)
X            if ((tblp->flag&DEFINED)) {
X                for (p = &ntblp[hash(tblp->name) & tp->size-1];
X                     *p != NULL; p--)
X                    if (p == ntblp) /* wrap */
X                        p += tp->size;
X                *p = tblp;
X                tp->free--;
X            } else {
X                afree((Void*)tblp, tp->areap);
X            }
X    afree((Void*)otblp, tp->areap);
X}
X
Xstruct tbl *
Xtsearch(tp, n, h)
X    register struct table *tp;    /* table */
X    register char *n;        /* name to enter */
X    unsigned int h;            /* hash(n) */
X{
X    register struct tbl **pp, *p;
X
X    if (tp->size == 0)
X        return NULL;
X
X    /* search for name in hashed table */
X    for (pp = &tp->tbls[h & tp->size-1]; (p = *pp) != NULL; pp--) {
X        if (*p->name == *n && strcmp(p->name, n) == 0
X            && (p->flag&DEFINED))
X            return p;
X        if (pp == tp->tbls) /* wrap */
X            pp += tp->size;
X    }
X
X    return NULL;
X}
X
Xstruct tbl *
Xtenter(tp, n, h)
X    register struct table *tp;    /* table */
X    register char *n;        /* name to enter */
X    unsigned int h;            /* hash(n) */
X{
X    register struct tbl **pp, *p;
X    register char *cp;
X
X    if (tp->size == 0)
X        texpand(tp, INIT_TBLS);
X  Search:
X    /* search for name in hashed table */
X    for (pp = &tp->tbls[h & tp->size-1]; (p = *pp) != NULL; pp--) {
X        if (*p->name == *n && strcmp(p->name, n) == 0)
X            return p;     /* found */
X        if (pp == tp->tbls) /* wrap */
X            pp += tp->size;
X    }
X
X    if (tp->free <= 0) {    /* too full */
X        texpand(tp, 2*tp->size);
X        goto Search;
X    }
X
X    /* create new tbl entry */
X    for (cp = n; *cp != '\0'; cp++)
X        ;
X    p = (struct tbl *) alloc(offsetof(struct tbl, name[(cp-n)+1]), tp->areap);
X    p->flag = 0;
X    p->type = 0;
X    for (cp = p->name; *n != '\0';)
X        *cp++ = *n++;
X    *cp = '\0';
X
X    /* enter in tp->tbls */
X    tp->free--;
X    *pp = p;
X    return p;
X}
X
Xvoid
Xtdelete(p)
X    register struct tbl *p;
X{
X    p->flag = 0;
X}
X
Xvoid
Xtwalk(tp)
X    register struct table *tp;
X{
X    tstate.left = tp->size;
X    tstate.next = tp->tbls;
X}
X
Xstruct tbl *
Xtnext()
X{
X    while (--tstate.left >= 0) {
X        struct tbl *p = *tstate.next++;
X        if (p != NULL && (p->flag&DEFINED))
X            return p;
X    }
X    return NULL;
X}
X
Xstatic int
Xtnamecmp(p1, p2)
X    Void *p1, *p2;
X{
X    return strcmp(((struct tbl *)p1)->name, ((struct tbl *)p2)->name);
X}
X
Xstruct tbl **
Xtsort(tp)
X    register struct table *tp;
X{
X    register int i;
X    register struct tbl **p, **sp, **dp;
X
X    p = (struct tbl **)alloc(sizeofN(struct tbl *, tp->size+1), ATEMP);
X    sp = tp->tbls;        /* source */
X    dp = p;            /* dest */
X    for (i = 0; i < tp->size; i++)
X        if ((*dp = *sp++) != NULL && ((*dp)->flag&DEFINED))
X            dp++;
X    i = dp - p;
X    qsortp((Void**)p, (size_t)i, tnamecmp);
X    p[i] = NULL;
X    return p;
X}
X
SHAR_EOF
true || echo 'restore of src/table.c failed'
fi
true || echo 'restore of src/eval.c failed'
echo End of part 5, continue with part 6
exit 0