+/*#include <ctype.h> sh.h*/
+/*#include <math.h> sh.h*/
+#include <memory.h>
+/*#include <strings.h> sh.h*/
+/*#include <sys/types.h> sh.h*/
+#ifdef __STDC__
+#include <stdarg.h>
+#define _va_start(argp, arg) va_start(argp, arg)
+#else
+#include <varargs.h>
+#define _va_start(argp, arg) va_start(argp)
+#endif
+#include "sh.h"
+
/*
* Copyright (c) 1988 Regents of the University of California.
* All rights reserved.
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*/
-#if defined(LIBC_SCCS) && !defined(lint)
+#if defined(DOSCCS) && !defined(lint)
static char sccsid[] = "@(#)doprnt.c 5.35 (Berkeley) 6/27/88";
-#endif /* LIBC_SCCS and not lint */
+#endif
-#include <sys/types.h>
-#include <varargs.h>
-#include <stdio.h>
-#include <ctype.h>
+/*#include <sys/types.h>*/
+/*#include <varargs.h>*/
+/*#include <stdio.h>*/
+/*#include <ctype.h>*/
/* 11-bit exponent (VAX G floating point) is 308 decimal digits */
#define MAXEXP 308
#define ZEROPAD 0x20 /* zero (as opposed to blank) pad */
#define HEXPREFIX 0x40 /* add 0x or 0X prefix */
-_doprnt(fmt0, argp/*, fp*/)
- u_char *fmt0;
- va_list argp;
- /*register FILE *fp;*/
-{
+static cvt __P((double number, register int prec, int flags, char *signp, int fmtch, char *startp, char *endp));
+static char *round __P((double fract, int *exp, register char *start, register char *end, int ch, char *signp));
+static char *exponent __P((register char *p, register int exp, int fmtch));
+
+int _doprnt(fmt0, argp) u_char *fmt0; va_list argp;
+ /*register FILE *fp;*/ {
register u_char *fmt; /* format string */
register int ch; /* character from fmt */
register int cnt; /* return value accumulator */
/* NOTREACHED */
}
-static
-cvt(number, prec, flags, signp, fmtch, startp, endp)
- double number;
- register int prec;
- int flags;
- u_char fmtch;
- char *signp, *startp, *endp;
-{
+static cvt(number, prec, flags, signp, fmtch, startp, endp) double number; register int prec; int flags; char *signp; int fmtch; char *startp; char *endp; {
register char *p, *t;
register double fract;
int dotrim, expcnt, gformat;
return(t - startp);
}
-static char *
-round(fract, exp, start, end, ch, signp)
- double fract;
- int *exp;
- register char *start, *end;
- char ch, *signp;
-{
+static char *round(fract, exp, start, end, ch, signp) double fract; int *exp; register char *start; register char *end; int ch; char *signp; {
double tmp;
if (fract)
return(start);
}
-static char *
-exponent(p, exp, fmtch)
- register char *p;
- register int exp;
- u_char fmtch;
-{
+static char *exponent(p, exp, fmtch) register char *p; register int exp; int fmtch; {
register char *t;
char expbuf[MAXEXP];
+/*#include <gen.h> sh.h*/
+/*#include <strings.h> sh.h*/
+#include <sys.h>
+/*#include <sys/proc.h> sh.h*/
+/*#include <sys/types.h> sh.h*/
+#include "sh.h"
+
/*
* Copyright (c) 1983 Regents of the University of California.
* All rights reserved. The Berkeley software License Agreement
#ifndef lint
/* From "@(#)malloc.c 5.5 (Berkeley) 2/25/86"; */
+#if defined(DOSCCS) && !defined(lint)
static char *sccsid = "@(#)malloc.c 5.3 (Berkeley) 3/29/86";
-#endif not lint
+#endif
+#endif
/*
* malloc.c (Caltech) 2/21/82
* This is designed for use in a virtual memory environment.
*/
-#include <sys/types.h>
+/*#include <sys/types.h>*/
#define NULL 0
*/
#define NBUCKETS 30
static union overhead *nextf[NBUCKETS];
-extern char *sbrk();
+/*extern char *sbrk();*/
static int pagesz; /* page size */
static int pagebucket; /* page size bucket */
#if defined(DEBUG) || defined(RCHECK)
#define ASSERT(p) if (!(p)) botch("p")
-static void
-botch(s)
- char *s;
-{
+static void botch __P((char *s));
+static findbucket __P((union overhead *freep, int srchlen));
+
+static void botch(s) char *s; {
printf("\r\nassertion botched: %s\r\n", s);
abort();
}
#define ASSERT(p)
#endif
-void *
-malloc(nbytes)
- unsigned nbytes;
-{
+void *malloc(nbytes) unsigned nbytes; {
register union overhead *op;
register int bucket;
register unsigned amt;
/*
* Allocate more memory to the indicated bucket.
*/
-void
-morecore(bucket)
- int bucket;
-{
+void morecore(bucket) int bucket; {
register union overhead *op;
register int sz; /* size of desired block */
int amt; /* amount to allocate */
}
}
-void
-free(cp)
- void *cp;
-{
+void free(cp) void *cp; {
register int size;
register union overhead *op;
*/
int realloc_srchlen = 4; /* 4 should be plenty, -1 =>'s whole list */
-void *
-realloc(cp, nbytes)
- void *cp;
- unsigned nbytes;
-{
+void *realloc(cp, nbytes) void *cp; unsigned nbytes; {
register u_int onb, i;
union overhead *op;
char *res;
* header starts at ``freep''. If srchlen is -1 search the whole list.
* Return bucket number, or -1 if not found.
*/
-static
-findbucket(freep, srchlen)
- union overhead *freep;
- int srchlen;
-{
+static findbucket(freep, srchlen) union overhead *freep; int srchlen; {
register union overhead *p;
register int i, j;
* for each size category, the second showing the number of mallocs -
* frees for each size category.
*/
-void
-showall(s)
-char **s;
-{
+void showall(s) char **s; {
register int i, j;
register union overhead *p;
int totfree = 0,
+#ifdef __STDC__
+#include <stdarg.h>
+#define _va_start(argp, arg) va_start(argp, arg)
+#else
+#include <varargs.h>
+#define _va_start(argp, arg) va_start(argp)
+#endif
+#include "sh.h"
+
/*
* Copyright (c) 1987 Regents of the University of California.
* All rights reserved.
* WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*/
-#if defined(LIBC_SCCS) && !defined(lint)
+#if defined(DOSCCS) && !defined(lint)
static char sccsid[] = "@(#)printf.c 5.4 (Berkeley) 6/27/88";
-#endif LIBC_SCCS and not lint
+#endif
/*#include <stdio.h>*/
-#include <varargs.h>
+/*#include <varargs.h>*/
-printf(fmt, va_alist)
- char *fmt;
- va_dcl
+#ifdef __STDC__
+int printf(char *fmt, ...)
+#else
+int printf(fmt, va_alist) char *fmt; va_dcl
+#endif
{
va_list argp;
int len;
- va_start(argp);
+ _va_start(argp, fmt);
len = _doprnt(fmt, argp/*, stdout*/);
va_end(argp);
return(/*ferror(stdout) ? EOF :*/ len);
+/*#include <gen.h> sh.h*/
+/*#include <pwd.h> sh.h*/
+/*#include <setjmp.h> sh.h*/
+/*#include <strings.h> sh.h*/
+/*#include <sys/errno.h> sh.h*/
+#include <sys/file.h>
+#include <sys/ioctl.h>
+/*#include <sys/proc.h> sh.h*/
+/*#include <sys/signal.h> sh.h*/
+/*#include <sys/stat.h> sh.h*/
+/*#include <sys/time.h> sh.h*/
+/*#include <sys/types.h> sh.h*/
+#include "sh.dir.h"
+/*#include "sh.h" sh.proc.h*/
+/*#include "sh.local.h" sh.h*/
+#include "sh.proc.h"
+
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
* specifies the terms and conditions for redistribution.
*/
-#ifndef lint
+#if defined(DOSCCS) && !defined(lint)
static char *sccsid = "@(#)sh.c 5.3 (Berkeley) 3/29/86";
#endif
-#include "sh.h"
-#include <sys/ioctl.h>
+/*#include "sh.h"*/
+/*#include <sys/ioctl.h>*/
/*
* C Shell
*
bool prompt = 1;
bool enterhist = 0;
-extern gid_t getegid(), getgid();
-extern uid_t geteuid(), getuid();
+/*extern gid_t getegid(), getgid();*/
+/*extern uid_t geteuid(), getuid();*/
-main(c, av)
- int c;
- char **av;
-{
+int main(c, av) int c; char **av; {
register char **v, *cp;
register int f;
struct sigvec osv;
if (oldisc != NTTYDISC) {
#ifdef DEBUG
printf("Switching to new tty driver...\n");
-#endif DEBUG
+#endif
ldisc = NTTYDISC;
(void) ioctl(f, TIOCSETD,
(char *)&ldisc);
exitstat();
}
-untty()
-{
+int untty() {
if (tpgrp > 0) {
(void) setpgrp(0, opgrp);
if (oldisc != -1 && oldisc != NTTYDISC) {
#ifdef DEBUG
printf("\nReverting to old tty driver...\n");
-#endif DEBUG
+#endif
(void) ioctl(FSHTTY, TIOCSETD, (char *)&oldisc);
}
}
}
-importpath(cp)
- char *cp;
-{
+int importpath(cp) char *cp; {
register int i = 0;
register char *dp;
register char **pv;
/*
* Source to the file which is the catenation of the argument names.
*/
-srccat(cp, dp)
- char *cp, *dp;
-{
+int srccat(cp, dp) char *cp; char *dp; {
register char *ep = strspl(cp, dp);
register int unit = dmove(open(ep, 0), -1);
* Source to a unit. If onlyown it must be our file or our group or
* we don't chance it. This occurs on ".cshrc"s and the like.
*/
-srcunit(unit, onlyown, hflg)
- register int unit;
- bool onlyown;
- bool hflg;
-{
+int srcunit(unit, onlyown, hflg) register int unit; int onlyown; int hflg; {
/* We have to push down a lot of state here */
/* All this could go into a structure */
int oSHIN = -1, oldintty = intty;
error(NOSTR);
}
-rechist()
-{
+int rechist() {
char buf[BUFSIZ];
int fp, ftmp, oldidfds;
}
}
-goodbye()
-{
+int goodbye() {
if (loginsh) {
(void) signal(SIGQUIT, SIG_IGN);
(void) signal(SIGINT, SIG_IGN);
exitstat();
}
-exitstat()
-{
+int exitstat() {
#ifdef PROF
monitor(0);
/*
* in the event of a HUP we want to save the history
*/
-phup()
-{
+int phup() {
rechist();
exit(1);
}
* and finally go through the normal error mechanism, which
* gets a chance to make the shell go away.
*/
-pintr()
-{
+int pintr() {
pintr1(1);
}
-pintr1(wantnl)
- bool wantnl;
-{
+int pintr1(wantnl) int wantnl; {
register char **v;
int omask;
* Note that if catch is not set then we will unwind on any error.
* If an end-of-file occurs, we return.
*/
-process(catch)
- bool catch;
-{
+int process(catch) int catch; {
jmp_buf osetexit;
register struct command *t;
resexit(osetexit);
}
-dosource(t)
- register char **t;
-{
+int dosource(t) register char **t; {
register char *f;
register int u;
bool hflg = 0;
* knows, since the login program insists on saying
* "You have mail."
*/
-mailchk()
-{
+int mailchk() {
register struct varent *v;
register char **vp;
time_t t;
chktim = t;
}
-#include <pwd.h>
+/*#include <pwd.h>*/
/*
* Extract a home directory from the password file
* The argument points to a buffer where the name of the
* user whose home directory is sought is currently.
* We write the home directory of the user back there.
*/
-gethdir(home)
- char *home;
-{
+int gethdir(home) char *home; {
register struct passwd *pp = getpwnam(home);
if (pp == 0)
* Move the initial descriptors to their eventual
* resting places, closin all other units.
*/
-initdesc()
-{
+int initdesc() {
didfds = 0; /* 0, 1, 2 aren't set up */
(void) ioctl(SHIN = dcopy(0, FSHIN), FIOCLEX, (char *)0);
/*#ifdef PROF*/
/*done(i)*/
/*#else*/
-exit(i)
-/*#endif*/
- int i;
-{
+int exit(i)
+/*#endif*/ int i; {
untty();
_exit(i);
}
-printprompt()
-{
+int printprompt() {
register char *cp;
if (!whyles) {
+#include "sh.char.h"
+
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
* specifies the terms and conditions for redistribution.
*/
-#ifndef lint
+#if defined(DOSCCS) && !defined(lint)
static char *sccsid = "@(#)sh.char.c 5.3 (Berkeley) 3/29/86";
#endif
-#include "sh.char.h"
+/*#include "sh.char.h"*/
unsigned short _cmap[256] = {
/* nul soh stx etx */
+#ifndef _SH_CHAR_H_
+#define _SH_CHAR_H_
+
+#include <ctype.h>
+
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
#define digit(c) cmap(c, _DIG)
#define letter(c) cmap(c, _LET)
#define alnum(c) (digit(c) || letter(c))
+
+#endif
+/*#include <setjmp.h> sh.h*/
+/*#include <sys/resource.h> sh.h*/
+/*#include <sys/time.h> sh.h*/
+/*#include <sys/types.h> sh.h*/
#include "sh.h"
+/*#include "sh.local.h" sh.h*/
+
+/*#include "sh.h"*/
/* moved all this here from sh.h which now only declares them extern */
+/*#include <gen.h> sh.h*/
+/*#include <strings.h> sh.h*/
+/*#include <sys/dir.h> sh.h*/
+#include <sys/file.h>
+/*#include <sys/param.h> sh.h*/
+/*#include <sys/proc.h> sh.h*/
+#include "sh.char.h"
+#include "sh.dir.h"
+#include "sh.h"
+
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
* specifies the terms and conditions for redistribution.
*/
-#ifndef lint
+#if defined(DOSCCS) && !defined(lint)
static char *sccsid = "@(#)sh.dir.c 5.3 (Berkeley) 6/11/85";
#endif
-#include "sh.h"
-#include "sh.dir.h"
+/*#include "sh.h"*/
+/*#include "sh.dir.h"*/
/*
* C Shell - directory management
*/
-struct directory *dfind();
-char *dfollow();
-char *dcanon();
+/*struct directory *dfind();*/
+/*char *dfollow();*/
+/*char *dcanon();*/
struct directory dhead; /* "head" of loop */
int printd; /* force name to be printed */
static char *fakev[] = { "dirs", NOSTR };
/*
* dinit - initialize current working directory
*/
-dinit(hp)
- char *hp;
-{
+int dinit(hp) char *hp; {
register char *cp;
register struct directory *dp;
char path[MAXPATHLEN];
/*
* dodirs - list all directories in directory loop
*/
-dodirs(v)
- char **v;
-{
+int dodirs(v) char **v; {
register struct directory *dp;
bool lflag;
char *hp = value("home");
printf("\n");
}
-dtildepr(home, dir)
- register char *home, *dir;
-{
+int dtildepr(home, dir) register char *home; register char *dir; {
if (!eq(home, "/") && prefix(home, dir))
printf("~%s", dir + strlen(home));
/*
* dochngd - implement chdir command.
*/
-dochngd(v)
- char **v;
-{
+int dochngd(v) char **v; {
register char *cp;
register struct directory *dp;
/*
* dfollow - change to arg directory; fall back on cdpath if not valid
*/
-char *
-dfollow(cp)
- register char *cp;
-{
+char *dfollow(cp) register char *cp; {
register char *dp;
struct varent *c;
* with no arguments exchange top and second.
* with numeric argument (+n) bring it to top.
*/
-dopushd(v)
- char **v;
-{
+int dopushd(v) char **v; {
register struct directory *dp;
printd = 1;
/*
* dfind - find a directory if specified by numeric (+n) argument
*/
-struct directory *
-dfind(cp)
- register char *cp;
-{
+struct directory *dfind(cp) register char *cp; {
register struct directory *dp;
register int i;
register char *ep;
* dopopd - pop a directory out of the directory stack
* with a numeric argument just discard it.
*/
-dopopd(v)
- char **v;
-{
+int dopopd(v) char **v; {
register struct directory *dp, *p;
printd = 1;
/*
* dfree - free the directory (or keep it if it still has ref count)
*/
-dfree(dp)
- register struct directory *dp;
-{
+int dfree(dp) register struct directory *dp; {
if (dp->di_count != 0)
dp->di_next = dp->di_prev = 0;
* we are of course assuming that the file system is standardly
* constructed (always have ..'s, directories have links)
*/
-char *
-dcanon(cp, p)
- register char *cp, *p;
-{
+char *dcanon(cp, p) register char *cp; register char *p; {
register char *sp;
register char *p1, *p2; /* general purpose */
bool slash;
/*
* dnewcwd - make a new directory in the loop the current one
*/
-dnewcwd(dp)
- register struct directory *dp;
-{
+int dnewcwd(dp) register struct directory *dp; {
dcwd = dp;
set("cwd", savestr(dcwd->di_name));
+#ifndef _SH_DIR_H_
+#define _SH_DIR_H_
+
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
char *di_name; /* actual name */
};
struct directory *dcwd; /* the one we are in now */
+
+#ifndef __P
+#ifdef __STDC__
+#define __P(args) args
+#else
+#define __P(args) ()
+#endif
+#endif
+
+/* sh.dir.c */
+int dinit __P((char *hp));
+int dodirs __P((char **v));
+int dtildepr __P((register char *home, register char *dir));
+int dochngd __P((char **v));
+char *dfollow __P((register char *cp));
+int dopushd __P((char **v));
+struct directory *dfind __P((register char *cp));
+int dopopd __P((char **v));
+int dfree __P((register struct directory *dp));
+char *dcanon __P((register char *cp, register char *p));
+int dnewcwd __P((register struct directory *dp));
+
+#endif
+/*#include <gen.h> sh.h*/
+/*#include <strings.h> sh.h*/
+#include <sys/file.h>
+#include <sys/trace.h>
+/*#include <sys/types.h> sh.h*/
+#include "sh.char.h"
+#include "sh.h"
+/*#include "sh.local.h" sh.h*/
+
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
* specifies the terms and conditions for redistribution.
*/
-#ifndef lint
+#if defined(DOSCCS) && !defined(lint)
static char *sccsid = "@(#)sh.dol.c 5.3 (Berkeley) 3/29/86";
#endif
-#include "sh.h"
+/*#include "sh.h"*/
/*
* C shell
* Fix up the $ expansions and quotations in the
* argument list to command t.
*/
-Dfix(t)
- register struct command *t;
-{
+int Dfix(t) register struct command *t; {
register char **pp;
register char *p;
/*
* $ substitute one word, for i/o redirection
*/
-char *
-Dfix1(cp)
- register char *cp;
-{
+char *Dfix1(cp) register char *cp; {
char *Dv[2];
if (noexec)
/*
* Subroutine to do actual fixing after state initialization.
*/
-Dfix2(v)
- char **v;
-{
+int Dfix2(v) char **v; {
char *agargv[GAVSIZ];
ginit(agargv); /* Initialize glob's area pointers */
* here is that we don't get a newline to terminate our expansion.
* Rather, DgetC will return a DEOF when we hit the end-of-input.
*/
-Dword()
-{
+int Dword() {
register int c, c1;
char wbuf[BUFSIZ];
register char *wp = wbuf;
* Any QUOTES character which is returned from a $ expansion is
* QUOTEd so that it will not be recognized above.
*/
-DgetC(flag)
- register int flag;
-{
+int DgetC(flag) register int flag; {
register int c;
top:
* Handle the multitudinous $ expansion forms.
* Ugh.
*/
-Dgetdol()
-{
+int Dgetdol() {
register char *np;
register struct varent *vp;
char name[20];
}
}
-setDolp(cp)
- register char *cp;
-{
+int setDolp(cp) register char *cp; {
register char *dp;
if (dolmod == 0 || dolmcnt == 0) {
dolp = "";
}
-unDredc(c)
- int c;
-{
+int unDredc(c) int c; {
Dpeekrd = c;
}
-Dredc()
-{
+int Dredc() {
register int c;
if (c = Dpeekrd) {
return (' ');
}
-Dtestq(c)
- register int c;
-{
+int Dtestq(c) register int c; {
if (cmap(c, QUOTES))
gflag = 1;
* of the shell input up to a line the same as "term".
* Unit 0 should have been closed before this call.
*/
-heredoc(term)
- char *term;
-{
+int heredoc(term) char *term; {
register int c;
char *Dv[2];
char obuf[BUFSIZ], lbuf[BUFSIZ], mbuf[BUFSIZ];
+/*#include <sys/errno.h> sh.h*/
+#include <sys/ioctl.h>
+#ifdef __STDC__
+#include <stdarg.h>
+#define _va_start(argp, arg) va_start(argp, arg)
+#else
+#include <varargs.h>
+#define _va_start(argp, arg) va_start(argp)
+#endif
+#include "sh.h"
+/*#include "sh.local.h" sh.h*/
+
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
* specifies the terms and conditions for redistribution.
*/
-#ifndef lint
+#if defined(DOSCCS) && !defined(lint)
static char *sccsid = "@(#)sh.err.c 5.3 (Berkeley) 5/13/86";
#endif
-#include "sh.h"
-#include <sys/ioctl.h>
+/*#include "sh.h"*/
+/*#include <sys/ioctl.h>*/
/*
* C Shell
* be closed in the routine process in sh.c which is the only
* place error unwinds are ever caught.
*/
-error(s, va_alist)
- char *s;
- va_dcl
+#ifdef __STDC__
+int error(char *s, ...)
+#else
+int error(s, va_alist) char *s; va_dcl
+#endif
{
register char **v;
register char *ep;
* an error diagnostic here.
*/
if (s) {
- va_start(argp);
+ _va_start(argp, fmt);
vprintf(s, argp), printf(".\n");
va_end(argp);
}
* Perror is the shells version of perror which should otherwise
* never be called.
*/
-Perror(s)
- char *s;
-{
+int Perror(s) char *s; {
/*
* Perror uses unit 2, thus if we didn't set up the fd's
error(NOSTR); /* To exit or unwind */
}
-bferr(cp)
- char *cp;
-{
+int bferr(cp) char *cp; {
flush();
haderr = 1;
* which sets the variable err as a side effect; later to be tested,
* e.g. in process.
*/
-seterr(s)
- char *s;
-{
+int seterr(s) char *s; {
if (err == 0)
err = s, errspl = 0;
}
/* Set err to a splice of cp and dp, to be freed later in error() */
-seterr2(cp, dp)
- char *cp, *dp;
-{
+int seterr2(cp, dp) char *cp; char *dp; {
if (err)
return;
}
/* Set err to a splice of cp with a string form of character d */
-seterrc(cp, d)
- char *cp, d;
-{
+int seterrc(cp, d) char *cp; int d; {
char chbuf[2];
chbuf[0] = d;
+/*#include <sys/dir.h> sh.h*/
+/*#include <sys/errno.h> sh.h*/
+/*#include <sys/exec.h> sh.h*/
+#include <sys/file.h>
+/*#include <sys/signal.h> sh.h*/
+/*#include <sys/stat.h> sh.h*/
+#include "sh.h"
+/*#include "sh.local.h" sh.h*/
+
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
* specifies the terms and conditions for redistribution.
*/
-#ifndef lint
+#if defined(DOSCCS) && !defined(lint)
static char *sccsid = "@(#)sh.exec.c 5.2 (Berkeley) 6/6/85";
#endif
-#include "sh.h"
-#include <sys/dir.h>
+/*#include "sh.h"*/
+/*#include <sys/dir.h>*/
/*
* C shell
/* Dummy search path for just absolute search when no path */
char *justabs[] = { "", 0 };
-doexec(t)
- register struct command *t;
-{
+int doexec(t) register struct command *t; {
char *sav;
register char *dp, **pv, **av;
register struct varent *v;
pexerr();
}
-pexerr()
-{
+int pexerr() {
/* Couldn't find the damn thing */
setname(expath);
* Record error message if not found.
* Also do shell scripts here.
*/
-texec(f, t)
- char *f;
- register char **t;
-{
+int texec(f, t) char *f; register char **t; {
register struct varent *v;
register char **vp;
extern char *sys_errlist[];
}
/*ARGSUSED*/
-execash(t, kp)
- char **t;
- register struct command *kp;
-{
+int execash(t, kp) char **t; register struct command *kp; {
rechist();
(void) signal(SIGINT, parintr);
/*NOTREACHED*/
}
-xechoit(t)
- char **t;
-{
+int xechoit(t) char **t; {
if (adrof("echo")) {
flush();
}
}
-dohash()
-{
+int dohash() {
struct stat stb;
DIR *dirp;
register struct direct *dp;
}
}
-dounhash()
-{
+int dounhash() {
havhash = 0;
}
#ifdef VFORK
-hashstat()
-{
+int hashstat() {
if (hits+misses)
printf("%d hits, %d misses, %d%%\n",
/*
* Hash a command name.
*/
-hashname(cp)
- register char *cp;
-{
+int hashname(cp) register char *cp; {
register long h = 0;
while (*cp)
+/*#include <gen.h> sh.h*/
+#include <sys/file.h>
+/*#include <sys/stat.h> sh.h*/
+#include "sh.char.h"
+/*#include "sh.h" sh.proc.h*/
+#include "sh.proc.h"
+
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
* specifies the terms and conditions for redistribution.
*/
-#ifndef lint
+#if defined(DOSCCS) && !defined(lint)
static char *sccsid = "@(#)sh.exp.c 5.3 (Berkeley) 6/23/85";
#endif
-#include "sh.h"
+/*#include "sh.h"*/
/*
* C shell
#define EQMATCH 7
#define NOTEQMATCH 8
-exp(vp)
- register char ***vp;
-{
+int exp(vp) register char ***vp; {
return (exp0(vp, 0));
}
-exp0(vp, ignore)
- register char ***vp;
- bool ignore;
-{
+int exp0(vp, ignore) register char ***vp; int ignore; {
register int p1 = exp1(vp, ignore);
#ifdef EDEBUG
return (p1);
}
-exp1(vp, ignore)
- register char ***vp;
-{
+int exp1(vp, ignore) register char ***vp; int ignore; {
register int p1 = exp2(vp, ignore);
#ifdef EDEBUG
return (p1);
}
-exp2(vp, ignore)
- register char ***vp;
- bool ignore;
-{
+int exp2(vp, ignore) register char ***vp; int ignore; {
register int p1 = exp2a(vp, ignore);
#ifdef EDEBUG
return (p1);
}
-exp2a(vp, ignore)
- register char ***vp;
- bool ignore;
-{
+int exp2a(vp, ignore) register char ***vp; int ignore; {
register int p1 = exp2b(vp, ignore);
#ifdef EDEBUG
return (p1);
}
-exp2b(vp, ignore)
- register char ***vp;
- bool ignore;
-{
+int exp2b(vp, ignore) register char ***vp; int ignore; {
register int p1 = exp2c(vp, ignore);
#ifdef EDEBUG
return (p1);
}
-exp2c(vp, ignore)
- register char ***vp;
- bool ignore;
-{
+int exp2c(vp, ignore) register char ***vp; int ignore; {
register char *p1 = exp3(vp, ignore);
register char *p2;
register int i;
return (i);
}
-char *
-exp3(vp, ignore)
- register char ***vp;
- bool ignore;
-{
+char *exp3(vp, ignore) register char ***vp; int ignore; {
register char *p1, *p2;
register int i;
return (p1);
}
-char *
-exp3a(vp, ignore)
- register char ***vp;
- bool ignore;
-{
+char *exp3a(vp, ignore) register char ***vp; int ignore; {
register char *p1, *p2, *op;
register int i;
return (p1);
}
-char *
-exp4(vp, ignore)
- register char ***vp;
- bool ignore;
-{
+char *exp4(vp, ignore) register char ***vp; int ignore; {
register char *p1, *p2;
register int i = 0;
return (p1);
}
-char *
-exp5(vp, ignore)
- register char ***vp;
- bool ignore;
-{
+char *exp5(vp, ignore) register char ***vp; int ignore; {
register char *p1, *p2;
register int i = 0;
return (p1);
}
-char *
-exp6(vp, ignore)
- register char ***vp;
-{
+char *exp6(vp, ignore) register char ***vp; int ignore; {
int ccode, i;
register char *cp, *dp, *ep;
return (ignore&NOGLOB ? savestr(cp) : globone(cp));
}
-evalav(v)
- register char **v;
-{
+int evalav(v) register char **v; {
struct wordent paraml;
register struct wordent *hp = ¶ml;
struct command *t;
freelex(¶ml), freesyn(t);
}
-isa(cp, what)
- register char *cp;
- register int what;
-{
+int isa(cp, what) register char *cp; register int what; {
if (cp == 0)
return ((what & RESTOP) != 0);
return (0);
}
-egetn(cp)
- register char *cp;
-{
+int egetn(cp) register char *cp; {
if (*cp && *cp != '-' && !digit(*cp))
bferr("Expression syntax");
/* Phew! */
#ifdef EDEBUG
-etraci(str, i, vp)
- char *str;
- int i;
- char ***vp;
-{
+int etraci(str, i, vp) char *str; int i; char ***vp; {
printf("%s=%d\t", str, i);
blkpr(*vp);
printf("\n");
}
-etracc(str, cp, vp)
- char *str, *cp;
- char ***vp;
-{
+int etracc(str, cp, vp) char *str; char *cp; char ***vp; {
printf("%s=%s\t", str, cp);
blkpr(*vp);
+/*#include <gen.h> sh.h*/
+/*#include <pwd.h> sh.h*/
+/*#include <strings.h> sh.h*/
+/*#include <sys/dir.h> sh.h*/
+#include <sys/file.h>
+/*#include <sys/ioctl.h> sgtty.h*/
+/*#include <sys/param.h> sh.h*/
+/*#include <sys/signal.h> sh.h*/
+/*#include <sys/stat.h> sh.h*/
+#include "sh.h"
+
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
* specifies the terms and conditions for redistribution.
*/
-#ifndef lint
+#if defined(DOSCCS) && !defined(lint)
static char *sccsid = "@(#)sh.file.c 5.6 (Berkeley) 5/18/86";
#endif
* Finally got around to adding to the Cshell., Ken Greer, Dec. 1981.
*/
-#include "sh.h"
+/*#include "sh.h"*/
#include <sgtty.h>
-#include <sys/dir.h>
-#include <pwd.h>
+/*#include <sys/dir.h>*/
+/*#include <pwd.h>*/
#define TRUE 1
#define FALSE 0
typedef enum {LIST, RECOGNIZE} COMMAND;
-int sortscmp(); /* defined in sh.glob.c */
+/*int sortscmp();*/ /* defined in sh.glob.c */
/*
* Put this here so the binary can be patched with adb to enable file
*/
bool filec = 0;
-static
-setup_tty(on)
- int on;
-{
+static setup_tty __P((int on));
+static back_to_col_1 __P((void));
+static pushback __P((char *string));
+static catn __P((register char *des, register char *src, register count));
+static copyn __P((register char *des, register char *src, register count));
+static char filetype __P((char *dir, char *file));
+static print_by_column __P((char *dir, char *items[], int count));
+static char *tilde __P((char *new, char *old));
+static retype __P((void));
+static beep __P((void));
+static print_recognized_stuff __P((char *recognized_part));
+static extract_dir_and_name __P((char *path, char *dir, char *name));
+static char *getentry __P((DIR *dir_fd, int looking_for_lognames));
+static free_items __P((register char **items));
+static _search __P((char *word, COMMAND command, int max_word_length));
+static recognize __P((char *extended_name, char *entry, int name_length, int numitems));
+static is_prefix __P((register char *check, register char *template));
+static is_suffix __P((char *check, char *template));
+static ignored __P((register char *entry));
+
+static setup_tty(on) int on; {
struct sgttyb sgtty;
static struct tchars tchars; /* INT, QUIT, XON, XOFF, EOF, BRK */
/*
* Move back to beginning of current line
*/
-static
-back_to_col_1()
-{
+static back_to_col_1() {
struct sgttyb tty, tty_normal;
int omask;
/*
* Push string contents back into tty queue
*/
-static
-pushback(string)
- char *string;
-{
+static pushback(string) char *string; {
register char *p;
struct sgttyb tty, tty_normal;
int omask;
* Des is a string whose maximum length is count.
* Always null terminate.
*/
-static
-catn(des, src, count)
- register char *des, *src;
- register count;
-{
+static catn(des, src, count) register char *des; register char *src; register count; {
while (--count >= 0 && *des)
des++;
* Like strncpy but always leave room for trailing \0
* and always null terminate.
*/
-static
-copyn(des, src, count)
- register char *des, *src;
- register count;
-{
+static copyn(des, src, count) register char *des; register char *src; register count; {
while (--count >= 0)
if ((*des++ = *src++) == 0)
*des = '\0';
}
-static char
-filetype(dir, file)
- char *dir, *file;
-{
+static char filetype(dir, file) char *dir; char *file; {
char path[MAXPATHLEN];
struct stat statb;
/*
* Print sorted down columns
*/
-static
-print_by_column(dir, items, count)
- char *dir, *items[];
-{
+static print_by_column(dir, items, count) char *dir; char *items[]; int count; {
register int i, rows, r, c, maxwidth = 0, columns;
if (ioctl(SHOUT, TIOCGWINSZ, (char *)&win) < 0 || win.ws_col == 0)
* expands to
* home_directory_of_person/mumble
*/
-static char *
-tilde(new, old)
- char *new, *old;
-{
+static char *tilde(new, old) char *new; char *old; {
register char *o, *p;
register struct passwd *pw;
static char person[40];
/*
* Cause pending line to be printed
*/
-static
-retype()
-{
+static retype() {
int pending_input = LPENDIN;
(void) ioctl(SHOUT, TIOCLBIS, (char *)&pending_input);
}
-static
-beep()
-{
+static beep() {
if (adrof("nobeep") == 0)
(void) write(SHOUT, "\007", 1);
* Erase that silly ^[ and
* print the recognized part of the string
*/
-static
-print_recognized_stuff(recognized_part)
- char *recognized_part;
-{
+static print_recognized_stuff(recognized_part) char *recognized_part; {
/* An optimized erasing of that silly ^[ */
switch (strlen(recognized_part)) {
* Parse full path in file into 2 parts: directory and file names
* Should leave final slash (/) at end of dir.
*/
-static
-extract_dir_and_name(path, dir, name)
- char *path, *dir, *name;
-{
+static extract_dir_and_name(path, dir, name) char *path; char *dir; char *name; {
register char *p;
p = rindex(path, '/');
}
}
-static char *
-getentry(dir_fd, looking_for_lognames)
- DIR *dir_fd;
-{
+static char *getentry(dir_fd, looking_for_lognames) DIR *dir_fd; int looking_for_lognames; {
register struct passwd *pw;
register struct direct *dirp;
return (NULL);
}
-static
-free_items(items)
- register char **items;
-{
+static free_items(items) register char **items; {
register int i;
for (i = 0; items[i]; i++)
/*
* Perform a RECOGNIZE or LIST command on string "word".
*/
-static
-_search(word, command, max_word_length)
- char *word;
- COMMAND command;
-{
+static _search(word, command, max_word_length) char *word; COMMAND command; int max_word_length; {
static char **items = NULL;
register DIR *dir_fd;
register numitems = 0, ignoring = TRUE, nignored = 0;
* character mismatch between extended_name and entry.
* If we shorten it back to the prefix length, stop _searching.
*/
-static
-recognize(extended_name, entry, name_length, numitems)
- char *extended_name, *entry;
-{
+static recognize(extended_name, entry, name_length, numitems) char *extended_name; char *entry; int name_length; int numitems; {
if (numitems == 1) /* 1st match */
copyn(extended_name, entry, MAXNAMLEN);
* This differs from PWB imatch in that if check is null
* it matches anything.
*/
-static
-is_prefix(check, template)
- register char *check, *template;
-{
+static is_prefix(check, template) register char *check; register char *template; {
do
if (*check == 0)
* Return true if the chars in template appear at the
* end of check, I.e., are it's suffix.
*/
-static
-is_suffix(check, template)
- char *check, *template;
-{
+static is_suffix(check, template) char *check; char *template; {
register char *c, *t;
for (c = check; *c++;)
}
}
-tenex(inputline, inputline_size)
- char *inputline;
- int inputline_size;
-{
+int tenex(inputline, inputline_size) char *inputline; int inputline_size; {
register int numitems, num_read;
setup_tty(ON);
return (num_read);
}
-static
-ignored(entry)
- register char *entry;
-{
+static ignored(entry) register char *entry; {
struct varent *vp;
register char **cp;
return (TRUE);
return (FALSE);
}
-#endif FILEC
+#endif
+/*#include <gen.h> sh.h*/
+/*#include <math.h> sh.h*/
+/*#include <setjmp.h> sh.h*/
+/*#include <strings.h> sh.h*/
+/*#include <sys/exec.h> sh.h*/
+#include <sys/file.h>
+#include <sys/ioctl.h>
+/*#include <sys/proc.h> sh.h*/
+/*#include <sys/resource.h> sh.h*/
+/*#include <sys/signal.h> sh.h*/
+/*#include <sys/stat.h> sh.h*/
+/*#include <sys/types.h> sh.h*/
+#include "sh.char.h"
+/*#include "sh.h" sh.proc.h*/
+/*#include "sh.local.h" sh.h*/
+#include "sh.proc.h"
+
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
* specifies the terms and conditions for redistribution.
*/
-#ifndef lint
+#if defined(DOSCCS) && !defined(lint)
static char *sccsid = "@(#)sh.func.c 5.3 (Berkeley) 5/13/86";
#endif
-#include "sh.h"
-#include <sys/ioctl.h>
+/*#include "sh.h"*/
+/*#include <sys/ioctl.h>*/
/*
* C shell
*/
-struct biltins *
-isbfunc(t)
- struct command *t;
-{
+struct biltins *isbfunc(t) struct command *t; {
register char *cp = t->t_dcom[0];
register struct biltins *bp, *bp1, *bp2;
int dolabel(), dofg1(), dobg1();
return (0);
}
-func(t, bp)
- register struct command *t;
- register struct biltins *bp;
-{
+int func(t, bp) register struct command *t; register struct biltins *bp; {
int i;
xechoit(t->t_dcom);
(*bp->bfunct)(t->t_dcom, t);
}
-dolabel()
-{
+int dolabel() {
}
-doonintr(v)
- char **v;
-{
+int doonintr(v) char **v; {
register char *cp;
register char *vv = v[1];
}
}
-donohup()
-{
+int donohup() {
if (intty)
bferr("Can't from terminal");
}
}
-dozip()
-{
+int dozip() {
;
}
-prvars()
-{
+int prvars() {
plist(&shvhed);
}
-doalias(v)
- register char **v;
-{
+int doalias(v) register char **v; {
register struct varent *vp;
register char *p;
}
}
-unalias(v)
- char **v;
-{
+int unalias(v) char **v; {
unset1(v, &aliases);
}
-dologout()
-{
+int dologout() {
islogin();
goodbye();
}
-dologin(v)
- char **v;
-{
+int dologin(v) char **v; {
islogin();
rechist();
}
#ifdef NEWGRP
-donewgrp(v)
- char **v;
-{
+int donewgrp(v) char **v; {
if (chkstop == 0 && setintr)
panystop(0);
}
#endif
-islogin()
-{
+int islogin() {
if (chkstop == 0 && setintr)
panystop(0);
error("Not login shell");
}
-doif(v, kp)
- char **v;
- struct command *kp;
-{
+int doif(v, kp) char **v; struct command *kp; {
register int i;
register char **vv;
#endif
}
-doelse()
-{
+int doelse() {
#if defined(__STDC__) || defined(lint)
search(ZELSE, 0, 0);
#else
#endif
}
-dogoto(v)
- char **v;
-{
+int dogoto(v) char **v; {
register struct whyle *wp;
char *lp;
wfree();
}
-doswitch(v)
- register char **v;
-{
+int doswitch(v) register char **v; {
register char *cp, *lp;
v++;
xfree(lp);
}
-dobreak()
-{
+int dobreak() {
if (whyles)
toend();
bferr("Not in while/foreach");
}
-doexit(v)
- char **v;
-{
+int doexit(v) char **v; {
if (chkstop == 0)
panystop(0);
(void) close(SHIN);
}
-doforeach(v)
- register char **v;
-{
+int doforeach(v) register char **v; {
register char *cp;
register struct whyle *nwp;
doagain();
}
-dowhile(v)
- char **v;
-{
+int dowhile(v) char **v; {
register int status;
register bool again = whyles != 0 && whyles->w_start == lineloc &&
whyles->w_fename == 0;
toend();
}
-preread()
-{
+int preread() {
whyles->w_end = -1;
if (setintr)
whyles->w_end = btell();
}
-doend()
-{
+int doend() {
if (!whyles)
bferr("Not in while/foreach");
doagain();
}
-docontin()
-{
+int docontin() {
if (!whyles)
bferr("Not in while/foreach");
doagain();
}
-doagain()
-{
+int doagain() {
/* Repeating a while is simple */
if (whyles->w_fename == 0) {
bseek(whyles->w_start);
}
-dorepeat(v, kp)
- char **v;
- struct command *kp;
-{
+int dorepeat(v, kp) char **v; struct command *kp; {
register int i, omask;
i = getn(v[1]);
(void) sigsetmask(omask);
}
-doswbrk()
-{
+int doswbrk() {
#if defined(__STDC__) || defined(lint)
search(ZBRKSW, 0, 0);
#else
#endif
}
-srchx(cp)
- register char *cp;
-{
+int srchx(cp) register char *cp; {
register struct srch *sp, *sp1, *sp2;
register i;
char *Sgoal;
/*VARARGS2*/
-search(type, level, goal)
- int type;
- register int level;
- char *goal;
-{
+int search(type, level, goal) int type; register int level; char *goal; {
char wordbuf[BUFSIZ];
register char *aword = wordbuf;
register char *cp;
} while (level >= 0);
}
-getword(wp)
- register char *wp;
-{
+int getword(wp) register char *wp; {
register int found = 0;
register int c, d;
/*NOTREACHED*/
}
-toend()
-{
+int toend() {
if (whyles->w_end == 0) {
#if defined(__STDC__) || defined(lint)
wfree();
}
-wfree()
-{
+int wfree() {
long o = btell();
while (whyles) {
}
}
-doecho(v)
- char **v;
-{
+int doecho(v) char **v; {
echo(' ', v);
}
-doglob(v)
- char **v;
-{
+int doglob(v) char **v; {
echo(0, v);
flush();
}
-echo(sep, v)
- char sep;
- register char **v;
-{
+int echo(sep, v) int sep; register char **v; {
register char *cp;
int nonl = 0;
char **environ;
-dosetenv(v)
- register char **v;
-{
+int dosetenv(v) register char **v; {
char *vp, *lp;
v++;
xfree(lp);
}
-dounsetenv(v)
- register char **v;
-{
+int dounsetenv(v) register char **v; {
v++;
do
while (*v);
}
-setenv(name, val)
- char *name, *val;
-{
+int setenv(name, val) char *name; char *val; {
register char **ep = environ;
register char *cp, *dp;
char *blk[2], **oep = ep;
setenv(name, val);
}
-unsetenv(name)
- char *name;
-{
+int unsetenv(name) char *name; {
register char **ep = environ;
register char *cp, *dp;
char **oep = ep;
}
}
-doumask(v)
- register char **v;
-{
+int doumask(v) register char **v; {
register char *cp = v[1];
register int i;
(void) umask(i);
}
-
struct limits {
int limconst;
char *limname;
-1, 0,
};
-struct limits *
-findlim(cp)
- char *cp;
-{
+struct limits *findlim(cp) char *cp; {
register struct limits *lp, *res;
res = 0;
/*NOTREACHED*/
}
-dolimit(v)
- register char **v;
-{
+int dolimit(v) register char **v; {
register struct limits *lp;
register int limit;
char hard = 0;
error(NOSTR);
}
-getval(lp, v)
- register struct limits *lp;
- char **v;
-{
+int getval(lp, v) register struct limits *lp; char **v; {
register float f;
double atof();
char *cp = *v++;
return ((int)(f+0.5));
}
-limtail(cp, str0)
- char *cp, *str0;
-{
+int limtail(cp, str0) char *cp; char *str0; {
register char *str = str0;
while (*cp && *cp == *str)
error("Bad scaling; did you mean ``%s''?", str0);
}
-plim(lp, hard)
- register struct limits *lp;
- char hard;
-{
+int plim(lp, hard) register struct limits *lp; int hard; {
struct rlimit rlim;
int limit;
printf("\n");
}
-dounlimit(v)
- register char **v;
-{
+int dounlimit(v) register char **v; {
register struct limits *lp;
int err = 0;
char hard = 0;
}
}
-setlim(lp, hard, limit)
- register struct limits *lp;
- char hard;
-{
+int setlim(lp, hard, limit) register struct limits *lp; int hard; int limit; {
struct rlimit rlim;
(void) getrlimit(lp->limconst, &rlim);
return (0);
}
-dosuspend()
-{
+int dosuspend() {
int ldisc, ctpgrp;
int (*old)();
}
}
-doeval(v)
- char **v;
-{
+int doeval(v) char **v; {
char **oevalvec = evalvec;
char *oevalp = evalp;
jmp_buf osetexit;
+/*#include <gen.h> sh.h*/
+/*#include <strings.h> sh.h*/
+/*#include <sys/dir.h> sh.h*/
+/*#include <sys/errno.h> sh.h*/
+#include <sys/file.h>
+/*#include <sys/param.h> sh.h*/
+/*#include <sys/signal.h> sh.h*/
+/*#include <sys/stat.h> sh.h*/
+#include "sh.char.h"
+/*#include "sh.h" sh.proc.h*/
+/*#include "sh.local.h" sh.h*/
+#include "sh.proc.h"
+
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
* specifies the terms and conditions for redistribution.
*/
-#ifndef lint
+#if defined(DOSCCS) && !defined(lint)
static char *sccsid = "@(#)sh.glob.c 5.4 (Berkeley) 5/13/86";
#endif
-#include "sh.h"
-#include <sys/dir.h>
+/*#include "sh.h"*/
+/*#include <sys/dir.h>*/
/*
* C Shell
bool nonomatch;
char *entp;
char **sortbas;
-int sortscmp();
+/*int sortscmp();*/
#define sort() qsort((char *)sortbas, &gargv[gargc] - sortbas, \
sizeof(*sortbas), sortscmp), sortbas = &gargv[gargc]
-
-char **
-glob(v)
- register char **v;
-{
+char **glob(v) register char **v; {
char agpath[BUFSIZ];
char *agargv[GAVSIZ];
return (gargv = copyblk(gargv));
}
-ginit(agargv)
- char **agargv;
-{
+int ginit(agargv) char **agargv; {
agargv[0] = 0; gargv = agargv; sortbas = agargv; gargc = 0;
gnleft = NCARGS - 4;
}
-collect(as)
- register char *as;
-{
+int collect(as) register char *as; {
register int i;
if (any('`', as)) {
acollect(as);
}
-acollect(as)
- register char *as;
-{
+int acollect(as) register char *as; {
register int ogargc = gargc;
gpathp = gpath; *gpathp = 0; globbed = 0;
/*
* String compare for qsort. Also used by filec code in sh.file.c.
*/
-sortscmp(a1, a2)
- char **a1, **a2;
-{
+int sortscmp(a1, a2) char **a1; char **a2; {
return (strcmp(*a1, *a2));
}
-expand(as)
- char *as;
-{
+int expand(as) char *as; {
register char *cs;
register char *sgpathp, *oldcs;
struct stat stb;
*gpathp = 0;
}
-matchdir(pattern)
- char *pattern;
-{
+int matchdir(pattern) char *pattern; {
struct stat stb;
register struct direct *dp;
register DIR *dirp;
Perror(gpath);
}
-execbrc(p, s)
- char *p, *s;
-{
+int execbrc(p, s) char *p; char *s; {
char restbuf[BUFSIZ + 2];
register char *pe, *pm, *pl;
int brclev = 0;
return (0);
}
-match(s, p)
- char *s, *p;
-{
+int match(s, p) char *s; char *p; {
register int c;
register char *sentp;
char sglobbed = globbed;
return (c);
}
-amatch(s, p)
- register char *s, *p;
-{
+int amatch(s, p) register char *s; register char *p; {
register int scc;
int ok, lc;
char *sgpathp;
}
}
-Gmatch(s, p)
- register char *s, *p;
-{
+int Gmatch(s, p) register char *s; register char *p; {
register int scc;
int ok, lc;
int c, cc;
}
}
-Gcat(s1, s2)
- char *s1, *s2;
-{
+int Gcat(s1, s2) char *s1; char *s2; {
register char *p, *q;
int n;
;
}
-addpath(c)
- char c;
-{
+int addpath(c) int c; {
if (gpathp >= lastgpathp)
error("Pathname too long");
*gpathp = 0;
}
-rscan(t, f)
- register char **t;
- int (*f)();
-{
+int rscan(t, f) register char **t; int (*f)(); {
register char *p;
while (p = *t++)
(*f)(*p++);
}
-trim(t)
- register char **t;
-{
+int trim(t) register char **t; {
register char *p;
while (p = *t++)
*p++ &= TRIM;
}
-tglob(t)
- register char **t;
-{
+int tglob(t) register char **t; {
register char *p, c;
while (p = *t++) {
}
}
-char *
-globone(str)
- register char *str;
-{
+char *globone(str) register char *str; {
char *gv[2];
register char **gvp;
register char *cp;
* a substitution from a << redirection, and so we should
* not crunch blanks and tabs, separating words only at newlines.
*/
-char **
-dobackp(cp, literal)
- char *cp;
- bool literal;
-{
+char **dobackp(cp, literal) char *cp; int literal; {
register char *lp, *rp;
char *ep;
char word[BUFSIZ];
}
}
-backeval(cp, literal)
- char *cp;
- bool literal;
-{
+int backeval(cp, literal) char *cp; int literal; {
int pvec[2];
int quoted = (literal || (cp[0] & QUOTE)) ? QUOTE : 0;
char ibuf[BUFSIZ];
prestjob();
}
-psave(c)
- char c;
-{
+int psave(c) int c; {
if (--pnleft <= 0)
error("Word too long");
*pargcp++ = c;
}
-pword()
-{
+int pword() {
psave(0);
if (pargc == GAVSIZ)
+#ifndef _SH_H_
+#define _SH_H_
+
+#include <gen.h>
+/*#include <setjmp.h> gen.h*/
+/*#include <strings.h> gen.h*/
+/*#include <sys/param.h> gen.h*/
+#include <sys/resource.h>
+#include <sys/stat.h>
+/*#include <sys/time.h> gen.h*/
+/*#include <sys/types.h> gen.h*/
+#ifdef __STDC__
+#include <stdarg.h>
+#endif
+#include "sh.local.h"
+
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
* @(#)sh.h 5.3 (Berkeley) 3/29/86
*/
-#include <sys/time.h>
-#include <sys/resource.h>
-#include <sys/param.h>
-#include <sys/stat.h>
-#include <sys/signal.h>
-#include <errno.h>
-#include <setjmp.h>
-#include "sh.local.h"
-#include "sh.char.h"
+/*#include <sys/time.h>*/
+/*#include <sys/resource.h>*/
+/*#include <sys/param.h>*/
+/*#include <sys/stat.h>*/
+/*#include <sys/signal.h>*/
+/*#include <errno.h>*/
+/*#include <setjmp.h>*/
+/*#include "sh.local.h"*/
+/*#include "sh.char.h"*/
/*
* C shell
extern char *alloctmp;
#define xalloc(i) ((alloctmp = malloc(i)) ? alloctmp : (char *)nomem(i))
-char *Dfix1();
-char **blkcat();
-char **blkcpy();
-char **blkend();
-char **blkspl();
-char *calloc();
-char *malloc();
-char *cname();
-char **copyblk();
-char **dobackp();
-char *domod();
-struct wordent *dosub();
-char *exp3();
-char *exp3a();
-char *exp4();
-char *exp5();
-char *exp6();
-struct Hist *enthist();
-struct Hist *findev();
-struct wordent *freenod();
-char *getenv();
-char *getinx();
-struct varent *getvx();
-struct passwd *getpwnam();
-struct wordent *gethent();
-struct wordent *getsub();
-char *getwd();
-char **glob();
-char *globone();
-char *index();
-struct biltins *isbfunc();
-off_t lseek();
-char *operate();
-int phup();
-int pintr();
-int pchild();
-char *putn();
-char *rindex();
-char **saveblk();
-char *savestr();
-char *strcat();
-char *strcpy();
-char *strend();
-char *strings();
-char *strip();
-char *strspl();
-char *subword();
-struct command *syntax();
-struct command *syn0();
-struct command *syn1();
-struct command *syn1a();
-struct command *syn1b();
-struct command *syn2();
-struct command *syn3();
-char *value1();
-char *xhome();
-char *xname();
-char *xset();
+/*char *Dfix1();*/
+/*char **blkcat();*/
+/*char **blkcpy();*/
+/*char **blkend();*/
+/*char **blkspl();*/
+/*char *calloc();*/
+/*char *malloc();*/
+/*char *cname();*/
+/*char **copyblk();*/
+/*char **dobackp();*/
+/*char *domod();*/
+/*struct wordent *dosub();*/
+/*char *exp3();*/
+/*char *exp3a();*/
+/*char *exp4();*/
+/*char *exp5();*/
+/*char *exp6();*/
+/*struct Hist *enthist();*/
+/*struct Hist *findev();*/
+/*struct wordent *freenod();*/
+/*char *getenv();*/
+/*char *getinx();*/
+/*struct varent *getvx();*/
+/*struct passwd *getpwnam();*/
+/*struct wordent *gethent();*/
+/*struct wordent *getsub();*/
+/*char *getwd();*/
+/*char **glob();*/
+/*char *globone();*/
+/*char *index();*/
+/*struct biltins *isbfunc();*/
+/*off_t lseek();*/
+/*char *operate();*/
+/*int phup();*/
+/*int pintr();*/
+/*int pchild();*/
+/*char *putn();*/
+/*char *rindex();*/
+/*char **saveblk();*/
+/*char *savestr();*/
+/*char *strcat();*/
+/*char *strcpy();*/
+/*char *strend();*/
+/*char *strings();*/
+/*char *strip();*/
+/*char *strspl();*/
+/*char *subword();*/
+/*struct command *syntax();*/
+/*struct command *syn0();*/
+/*struct command *syn1();*/
+/*struct command *syn1a();*/
+/*struct command *syn1b();*/
+/*struct command *syn2();*/
+/*struct command *syn3();*/
+/*char *value1();*/
+/*char *xhome();*/
+/*char *xname();*/
+/*char *xset();*/
#define NOSTR ((char *) 0)
char *iname; /* name from /usr/include */
char *pname; /* print name */
} mesg[];
+
+#ifndef __P
+#ifdef __STDC__
+#define __P(args) args
+#else
+#define __P(args) ()
+#endif
+#endif
+
+/* doprnt.c */
+int _doprnt __P((u_char *fmt0, va_list argp));
+
+/* malloc.c */
+void *malloc __P((unsigned nbytes));
+void morecore __P((int bucket));
+void free __P((void *cp));
+void *realloc __P((void *cp, unsigned nbytes));
+void showall __P((char **s));
+
+/* printf.c */
+int printf __P((char *fmt, ...));
+
+/* sh.c */
+int main __P((int c, char **av));
+int untty __P((void));
+int importpath __P((char *cp));
+int srccat __P((char *cp, char *dp));
+int srcunit __P((register int unit, int onlyown, int hflg));
+int rechist __P((void));
+int goodbye __P((void));
+int exitstat __P((void));
+int phup __P((void));
+int pintr __P((void));
+int pintr1 __P((int wantnl));
+int process __P((int catch));
+int dosource __P((register char **t));
+int mailchk __P((void));
+int gethdir __P((char *home));
+int initdesc __P((void));
+int exit __P((int i));
+int printprompt __P((void));
+
+/* sh.dol.c */
+int Dfix __P((register struct command *t));
+char *Dfix1 __P((register char *cp));
+int Dfix2 __P((char **v));
+int Dword __P((void));
+int DgetC __P((register int flag));
+int Dgetdol __P((void));
+int setDolp __P((register char *cp));
+int unDredc __P((int c));
+int Dredc __P((void));
+int Dtestq __P((register int c));
+int heredoc __P((char *term));
+
+/* sh.err.c */
+int error __P((char *s, ...));
+int Perror __P((char *s));
+int bferr __P((char *cp));
+int seterr __P((char *s));
+int seterr2 __P((char *cp, char *dp));
+int seterrc __P((char *cp, int d));
+
+/* sh.exec.c */
+int doexec __P((register struct command *t));
+int pexerr __P((void));
+int texec __P((char *f, register char **t));
+int execash __P((char **t, register struct command *kp));
+int xechoit __P((char **t));
+int dohash __P((void));
+int dounhash __P((void));
+int hashstat __P((void));
+int hashname __P((register char *cp));
+
+/* sh.exp.c */
+int exp __P((register char ***vp));
+int exp0 __P((register char ***vp, int ignore));
+int exp1 __P((register char ***vp, int ignore));
+int exp2 __P((register char ***vp, int ignore));
+int exp2a __P((register char ***vp, int ignore));
+int exp2b __P((register char ***vp, int ignore));
+int exp2c __P((register char ***vp, int ignore));
+char *exp3 __P((register char ***vp, int ignore));
+char *exp3a __P((register char ***vp, int ignore));
+char *exp4 __P((register char ***vp, int ignore));
+char *exp5 __P((register char ***vp, int ignore));
+char *exp6 __P((register char ***vp, int ignore));
+int evalav __P((register char **v));
+int isa __P((register char *cp, register int what));
+int egetn __P((register char *cp));
+int etraci __P((char *str, int i, char ***vp));
+int etracc __P((char *str, char *cp, char ***vp));
+
+/* sh.file.c */
+int tenex __P((char *inputline, int inputline_size));
+
+/* sh.func.c */
+struct biltins *isbfunc __P((struct command *t));
+int func __P((register struct command *t, register struct biltins *bp));
+int dolabel __P((void));
+int doonintr __P((char **v));
+int donohup __P((void));
+int dozip __P((void));
+int prvars __P((void));
+int doalias __P((register char **v));
+int unalias __P((char **v));
+int dologout __P((void));
+int dologin __P((char **v));
+int donewgrp __P((char **v));
+int islogin __P((void));
+int doif __P((char **v, struct command *kp));
+int reexecute __P((register struct command *kp));
+int doelse __P((void));
+int dogoto __P((char **v));
+int doswitch __P((register char **v));
+int dobreak __P((void));
+int doexit __P((char **v));
+int doforeach __P((register char **v));
+int dowhile __P((char **v));
+int preread __P((void));
+int doend __P((void));
+int docontin __P((void));
+int doagain __P((void));
+int dorepeat __P((char **v, struct command *kp));
+int doswbrk __P((void));
+int srchx __P((register char *cp));
+int search __P((int type, register int level, char *goal));
+int getword __P((register char *wp));
+int toend __P((void));
+int wfree __P((void));
+int doecho __P((char **v));
+int doglob __P((char **v));
+int echo __P((int sep, register char **v));
+int dosetenv __P((register char **v));
+int dounsetenv __P((register char **v));
+int setenv __P((char *name, char *val));
+int unsetenv __P((char *name));
+int doumask __P((register char **v));
+struct limits *findlim __P((char *cp));
+int dolimit __P((register char **v));
+int getval __P((register struct limits *lp, char **v));
+int limtail __P((char *cp, char *str0));
+int plim __P((register struct limits *lp, int hard));
+int dounlimit __P((register char **v));
+int setlim __P((register struct limits *lp, int hard, int limit));
+int dosuspend __P((void));
+int doeval __P((char **v));
+
+/* sh.glob.c */
+char **glob __P((register char **v));
+int ginit __P((char **agargv));
+int collect __P((register char *as));
+int acollect __P((register char *as));
+int sortscmp __P((char **a1, char **a2));
+int expand __P((char *as));
+int matchdir __P((char *pattern));
+int execbrc __P((char *p, char *s));
+int match __P((char *s, char *p));
+int amatch __P((register char *s, register char *p));
+int Gmatch __P((register char *s, register char *p));
+int Gcat __P((char *s1, char *s2));
+int addpath __P((int c));
+int rscan __P((register char **t, int (*f)(void)));
+int trim __P((register char **t));
+int tglob __P((register char **t));
+char *globone __P((register char *str));
+char **dobackp __P((char *cp, int literal));
+int backeval __P((char *cp, int literal));
+int psave __P((int c));
+int pword __P((void));
+
+/* sh.hist.c */
+int savehist __P((struct wordent *sp));
+struct Hist *enthist __P((int event, register struct wordent *lp, int docopy));
+int hfree __P((register struct Hist *hp));
+int dohist __P((char **vp));
+int dohist1 __P((struct Hist *hp, int *np, int rflg, int hflg));
+int phist __P((register struct Hist *hp, int hflg));
+
+/* sh.lex.c */
+int lex __P((register struct wordent *hp));
+int prlex __P((struct wordent *sp0));
+int copylex __P((register struct wordent *hp, register struct wordent *fp));
+int freelex __P((register struct wordent *vp));
+char *word __P((void));
+int getC1 __P((register int flag));
+int getdol __P((void));
+int addla __P((char *cp));
+int getexcl __P((int sc));
+struct wordent *getsub __P((struct wordent *en));
+struct wordent *dosub __P((int sc, struct wordent *en, int global));
+char *subword __P((char *cp, int type, bool *adid));
+char *domod __P((char *cp, int type));
+int matchs __P((register char *str, register char *pat));
+int getsel __P((register int *al, register int *ar, int dol));
+struct wordent *gethent __P((int sc));
+struct Hist *findev __P((char *cp, int anyarg));
+int noev __P((char *cp));
+int setexclp __P((register char *cp));
+int unreadc __P((int c));
+int readc __P((int wanteof));
+int bgetc __P((void));
+int bfree __P((void));
+int bseek __P((off_t l));
+int btoeof __P((void));
+int settell __P((void));
+
+/* sh.misc.c */
+int any __P((register int c, register char *s));
+int onlyread __P((char *cp));
+int xfree __P((char *cp));
+char *savestr __P((register char *s));
+void *calloc __P((register unsigned i, unsigned j));
+int nomem __P((unsigned i));
+char **blkend __P((register char **up));
+int blkpr __P((register char **av));
+int blklen __P((register char **av));
+char **blkcpy __P((char **oav, register char **bv));
+char **blkcat __P((char **up, char **vp));
+int blkfree __P((char **av0));
+char **saveblk __P((register char **v));
+char *strspl __P((char *cp, char *dp));
+char **blkspl __P((register char **up, register char **vp));
+int lastchr __P((register char *cp));
+int closem __P((void));
+int donefds __P((void));
+int dmove __P((register int i, register int j));
+int dcopy __P((register int i, register int j));
+int renum __P((register int i, register int j));
+int lshift __P((register char **v, register int c));
+int number __P((char *cp));
+char **copyblk __P((register char **v));
+char *strend __P((register char *cp));
+char *strip __P((char *cp));
+int udvar __P((char *name));
+int prefix __P((register char *sub, register char *str));
+
+/* sh.parse.c */
+int alias __P((register struct wordent *lex));
+int asyntax __P((register struct wordent *p1, register struct wordent *p2));
+int asyn0 __P((struct wordent *p1, register struct wordent *p2));
+int asyn3 __P((struct wordent *p1, register struct wordent *p2));
+struct wordent *freenod __P((register struct wordent *p1, register struct wordent *p2));
+struct command *syntax __P((register struct wordent *p1, register struct wordent *p2, int flags));
+struct command *syn0 __P((struct wordent *p1, struct wordent *p2, int flags));
+struct command *syn1 __P((struct wordent *p1, struct wordent *p2, int flags));
+struct command *syn1a __P((struct wordent *p1, struct wordent *p2, int flags));
+struct command *syn1b __P((struct wordent *p1, struct wordent *p2, int flags));
+struct command *syn2 __P((struct wordent *p1, struct wordent *p2, int flags));
+struct command *syn3 __P((struct wordent *p1, struct wordent *p2, int flags));
+int freesyn __P((register struct command *t));
+
+/* sh.print.c */
+int psecs __P((long l));
+int p2dig __P((register int i));
+int putchar __P((register int c));
+int draino __P((void));
+int flush __P((void));
+
+/* sh.set.c */
+int doset __P((register char **v));
+char *getinx __P((register char *cp, register int *ip));
+int asx __P((char *vp, int subscr, char *p));
+struct varent *getvx __P((char *vp, int subscr));
+int dolet __P((char **v));
+char *xset __P((char *cp, char ***vp));
+char *operate __P((int op, char *vp, char *p));
+char *putn __P((register int n));
+int putn1 __P((register int n));
+int getn __P((register char *cp));
+char *value1 __P((char *var, struct varent *head));
+struct varent *madrof __P((char *pat, register struct varent *vp));
+struct varent *adrof1 __P((register char *name, register struct varent *v));
+int set __P((char *var, char *val));
+int set1 __P((char *var, char **vec, struct varent *head));
+int setq __P((char *name, char **vec, register struct varent *p));
+int unset __P((char *v[]));
+int unset1 __P((register char *v[], struct varent *head));
+int unsetv __P((char *var));
+int unsetv1 __P((register struct varent *p));
+int setNS __P((char *cp));
+int shift __P((register char **v));
+int exportpath __P((char **val));
+int balance __P((register struct varent *p, register f, int d));
+int plist __P((register struct varent *p));
+
+/* sh.time.c */
+int settimes __P((void));
+int dotime __P((void));
+int donice __P((register char **v));
+int ruadd __P((register struct rusage *ru, register struct rusage *ru2));
+int prusage __P((register struct rusage *r0, register struct rusage *r1, struct timeval *e, struct timeval *b));
+int pdeltat __P((struct timeval *t1, struct timeval *t0));
+int tvadd __P((struct timeval *tsum, struct timeval *t0));
+int tvsub __P((struct timeval *tdiff, struct timeval *t1, struct timeval *t0));
+
+#endif
+/*#include <sys/signal.h> sh.h*/
+#include "sh.char.h"
+#include "sh.h"
+
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
* specifies the terms and conditions for redistribution.
*/
-#ifndef lint
+#if defined(DOSCCS) && !defined(lint)
static char *sccsid = "@(#)sh.hist.c 5.2 (Berkeley) 6/6/85";
#endif
-#include "sh.h"
+/*#include "sh.h"*/
/*
* C shell
*/
-savehist(sp)
- struct wordent *sp;
-{
+int savehist(sp) struct wordent *sp; {
register struct Hist *hp, *np;
register int histlen = 0;
char *cp;
(void) enthist(++eventno, sp, 1);
}
-struct Hist *
-enthist(event, lp, docopy)
- int event;
- register struct wordent *lp;
- bool docopy;
-{
+struct Hist *enthist(event, lp, docopy) int event; register struct wordent *lp; int docopy; {
register struct Hist *np;
np = (struct Hist *) xalloc(sizeof *np);
return (np);
}
-hfree(hp)
- register struct Hist *hp;
-{
+int hfree(hp) register struct Hist *hp; {
freelex(&hp->Hlex);
xfree((char *)hp);
}
-dohist(vp)
- char **vp;
-{
+int dohist(vp) char **vp; {
int n, rflg = 0, hflg = 0;
if (getn(value("history")) == 0)
return;
dohist1(Histlist.Hnext, &n, rflg, hflg);
}
-dohist1(hp, np, rflg, hflg)
- struct Hist *hp;
- int *np, rflg, hflg;
-{
+int dohist1(hp, np, rflg, hflg) struct Hist *hp; int *np; int rflg; int hflg; {
bool print = (*np) > 0;
top:
if (hp == 0)
goto top;
}
-phist(hp, hflg)
- register struct Hist *hp;
- int hflg;
-{
+int phist(hp, hflg) register struct Hist *hp; int hflg; {
if (hflg == 0)
printf("%6d\t", hp->Hnum);
+#include "sh.h"
+
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
* specifies the terms and conditions for redistribution.
*/
-#ifndef lint
+#if defined(DOSCCS) && !defined(lint)
static char *sccsid = "@(#)sh.init.c 5.2 (Berkeley) 6/6/85";
#endif
-#include "sh.local.h"
+/*#include "sh.local.h"*/
/*
* C shell
*/
-extern int doalias();
-extern int dobg();
-extern int dobreak();
-extern int dochngd();
-extern int docontin();
-extern int dodirs();
-extern int doecho();
-extern int doelse();
-extern int doend();
-extern int doendif();
-extern int doendsw();
-extern int doeval();
-extern int doexit();
-extern int dofg();
-extern int doforeach();
-extern int doglob();
-extern int dogoto();
-extern int dohash();
-extern int dohist();
-extern int doif();
-extern int dojobs();
-extern int dokill();
-extern int dolet();
-extern int dolimit();
-extern int dologin();
-extern int dologout();
+/*extern int doalias();*/
+/*extern int dobg();*/
+/*extern int dobreak();*/
+/*extern int dochngd();*/
+/*extern int docontin();*/
+/*extern int dodirs();*/
+/*extern int doecho();*/
+/*extern int doelse();*/
+/*extern int doend();*/
+/*extern int doendif();*/
+/*extern int doendsw();*/
+/*extern int doeval();*/
+/*extern int doexit();*/
+/*extern int dofg();*/
+/*extern int doforeach();*/
+/*extern int doglob();*/
+/*extern int dogoto();*/
+/*extern int dohash();*/
+/*extern int dohist();*/
+/*extern int doif();*/
+/*extern int dojobs();*/
+/*extern int dokill();*/
+/*extern int dolet();*/
+/*extern int dolimit();*/
+/*extern int dologin();*/
+/*extern int dologout();*/
#ifdef NEWGRP
-extern int donewgrp();
+/*extern int donewgrp();*/
#endif
-extern int donice();
-extern int donotify();
-extern int donohup();
-extern int doonintr();
-extern int dopopd();
-extern int dopushd();
-extern int dorepeat();
-extern int doset();
-extern int dosetenv();
-extern int dosource();
-extern int dostop();
-extern int dosuspend();
-extern int doswbrk();
-extern int doswitch();
-extern int dotime();
-extern int dounlimit();
-extern int doumask();
-extern int dowait();
-extern int dowhile();
-extern int dozip();
-extern int execash();
-extern int goodbye();
+/*extern int donice();*/
+/*extern int donotify();*/
+/*extern int donohup();*/
+/*extern int doonintr();*/
+/*extern int dopopd();*/
+/*extern int dopushd();*/
+/*extern int dorepeat();*/
+/*extern int doset();*/
+/*extern int dosetenv();*/
+/*extern int dosource();*/
+/*extern int dostop();*/
+/*extern int dosuspend();*/
+/*extern int doswbrk();*/
+/*extern int doswitch();*/
+/*extern int dotime();*/
+/*extern int dounlimit();*/
+/*extern int doumask();*/
+/*extern int dowait();*/
+/*extern int dowhile();*/
+/*extern int dozip();*/
+/*extern int execash();*/
+/*extern int goodbye();*/
#ifdef VFORK
-extern int hashstat();
+/*extern int hashstat();*/
#endif
-extern int shift();
-extern int showall();
-extern int unalias();
-extern int dounhash();
-extern int unset();
-extern int dounsetenv();
+/*extern int shift();*/
+/*extern int showall();*/
+/*extern int unalias();*/
+/*extern int dounhash();*/
+/*extern int unset();*/
+/*extern int dounsetenv();*/
#define INF 1000
+/*#include <gen.h> sh.h*/
+/*#include <strings.h> sh.h*/
+/*#include <sys/errno.h> sh.h*/
+#include <sys/file.h>
+#include <sys/ioctl.h>
+/*#include <sys/signal.h> sh.h*/
+/*#include <sys/types.h> sh.h*/
+#include "sh.char.h"
+/*#include "sh.h" sh.proc.h*/
+/*#include "sh.local.h" sh.h*/
+#include "sh.proc.h"
+
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
* specifies the terms and conditions for redistribution.
*/
-#ifndef lint
+#if defined(DOSCCS) && !defined(lint)
static char *sccsid = "@(#)sh.lex.c 5.4 (Berkeley) 3/29/86";
#endif
-#include "sh.h"
-#include <sgtty.h>
+/*#include "sh.h"*/
+/*#include <sgtty.h>*/
/*
* C shell
* of input buffering, and especially because of history substitution.
*/
-char *word();
+/*char *word();*/
/*
* Peekc is a peek characer for getC, peekread for readc.
#define ungetC(c) peekc = c
#define ungetD(c) peekd = c
-lex(hp)
- register struct wordent *hp;
-{
+int lex(hp) register struct wordent *hp; {
register struct wordent *wdp;
int c;
return (hadhist);
}
-prlex(sp0)
- struct wordent *sp0;
-{
+int prlex(sp0) struct wordent *sp0; {
register struct wordent *sp = sp0->next;
for (;;) {
}
}
-copylex(hp, fp)
- register struct wordent *hp;
- register struct wordent *fp;
-{
+int copylex(hp, fp) register struct wordent *hp; register struct wordent *fp; {
register struct wordent *wdp;
wdp = hp;
hp->prev = wdp;
}
-freelex(vp)
- register struct wordent *vp;
-{
+int freelex(vp) register struct wordent *vp; {
register struct wordent *fp;
while (vp->next != vp) {
vp->prev = vp;
}
-char *
-word()
-{
+char *word() {
register char c, c1;
register char *wp;
char wbuf[BUFSIZ];
return (savestr(wbuf));
}
-getC1(flag)
- register int flag;
-{
+int getC1(flag) register int flag; {
register char c;
top:
return (c);
}
-getdol()
-{
+int getdol() {
register char *np;
char name[40];
register int c;
goto ret;
}
-addla(cp)
- char *cp;
-{
+int addla(cp) char *cp; {
char buf[BUFSIZ];
if (lap != 0 && strlen(cp) + strlen(lap) >= sizeof (labuf) - 4) {
char rhsb[64];
int quesarg;
-getexcl(sc)
- char sc;
-{
+int getexcl(sc) int sc; {
register struct wordent *hp, *ip;
int left, right, dol;
register int c;
exclnxt = hp;
}
-struct wordent *
-getsub(en)
- struct wordent *en;
-{
+struct wordent *getsub(en) struct wordent *en; {
register char *cp;
int delim;
register int c;
return (en);
}
-struct wordent *
-dosub(sc, en, global)
- int sc;
- struct wordent *en;
- bool global;
-{
+struct wordent *dosub(sc, en, global) int sc; struct wordent *en; int global; {
struct wordent lex;
bool didsub = 0;
struct wordent *hp = &lex;
return (&enthist(-1000, &lex, 0)->Hlex);
}
-char *
-subword(cp, type, adid)
- char *cp;
- int type;
- bool *adid;
-{
+char *subword(cp, type, adid) char *cp; int type; bool *adid; {
char wbuf[BUFSIZ];
register char *wp, *mp, *np;
register int i;
}
}
-char *
-domod(cp, type)
- char *cp;
- int type;
-{
+char *domod(cp, type) char *cp; int type; {
register char *wp, *xp;
register int c;
return (0);
}
-matchs(str, pat)
- register char *str, *pat;
-{
+int matchs(str, pat) register char *str; register char *pat; {
while (*str && *pat && *str == *pat)
str++, pat++;
return (*pat == 0);
}
-getsel(al, ar, dol)
- register int *al, *ar;
- int dol;
-{
+int getsel(al, ar, dol) register int *al; register int *ar; int dol; {
register int c = getC(0);
register int i;
bool first = *al < 0;
}
-struct wordent *
-gethent(sc)
- int sc;
-{
+struct wordent *gethent(sc) int sc; {
register struct Hist *hp;
register char *np;
register int c;
return (0);
}
-struct Hist *
-findev(cp, anyarg)
- char *cp;
- bool anyarg;
-{
+struct Hist *findev(cp, anyarg) char *cp; int anyarg; {
register struct Hist *hp;
for (hp = Histlist.Hnext; hp; hp = hp->Hnext) {
return (0);
}
-noev(cp)
- char *cp;
-{
+int noev(cp) char *cp; {
seterr2(cp, ": Event not found");
}
-setexclp(cp)
- register char *cp;
-{
+int setexclp(cp) register char *cp; {
if (cp && cp[0] == '\n')
return;
exclp = cp;
}
-unreadc(c)
- char c;
-{
+int unreadc(c) int c; {
peekread = c;
}
-readc(wanteof)
- bool wanteof;
-{
+int readc(wanteof) int wanteof; {
register int c;
static sincereal;
return (c);
}
-bgetc()
-{
+int bgetc() {
register int buf, off, c;
#ifdef FILEC
char ttyline[BUFSIZ];
return (c);
}
-bfree()
-{
+int bfree() {
register int sb, i;
#ifdef TELL
}
}
-bseek(l)
- off_t l;
-{
+int bseek(l) off_t l; {
register struct whyle *wp;
fseekp = l;
#endif
}
-btoeof()
-{
+int btoeof() {
(void) lseek(SHIN, (off_t)0, 2);
fseekp = feobp;
}
#ifdef TELL
-settell()
-{
+int settell() {
cantell = 0;
if (arginp || onelflg || intty)
+#ifndef _SH_LOCAL_H_
+#define _SH_LOCAL_H_
+
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
/*#ifdef PROF*/
/*#define exit(n) done(n)*/
/*#endif*/
+
+#endif
+/*#include <gen.h> sh.h*/
+/*#include <strings.h> sh.h*/
+#include <sys/file.h>
+/*#include <sys/param.h> sh.h*/
+/*#include <sys/proc.h> sh.h*/
+#include "sh.char.h"
+#include "sh.h"
+/*#include "sh.local.h" sh.h*/
+
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
* specifies the terms and conditions for redistribution.
*/
-#ifndef lint
+#if defined(DOSCCS) && !defined(lint)
static char *sccsid = "@(#)sh.misc.c 5.3 (Berkeley) 3/29/86";
#endif
-#include "sh.h"
+/*#include "sh.h"*/
/*
* C Shell
*/
-any(c, s)
- register int c;
- register char *s;
-{
+int any(c, s) register int c; register char *s; {
while (*s)
if (*s++ == c)
return(0);
}
-onlyread(cp)
- char *cp;
-{
+int onlyread(cp) char *cp; {
extern char end[];
return (cp < end);
}
-xfree(cp)
- char *cp;
-{
+int xfree(cp) char *cp; {
extern char end[];
if (cp >= end && cp < (char *) &cp)
free(cp);
}
-char *
-savestr(s)
- register char *s;
-{
+char *savestr(s) register char *s; {
char *n;
register char *p;
return (n);
}
-void *
-calloc(i, j)
- register unsigned i;
- unsigned j;
-{
+void *calloc(i, j) register unsigned i; unsigned j; {
char *cp;
i *= j;
return (cp);
}
-nomem(i)
- unsigned i;
-{
+int nomem(i) unsigned i; {
#ifdef debug
static char *av[2] = {0, 0};
#endif
return 0; /* fool lint */
}
-char **
-blkend(up)
- register char **up;
-{
+char **blkend(up) register char **up; {
while (*up)
up++;
return (up);
}
-blkpr(av)
- register char **av;
-{
+int blkpr(av) register char **av; {
for (; *av; av++) {
printf("%s", *av);
}
}
-blklen(av)
- register char **av;
-{
+int blklen(av) register char **av; {
register int i = 0;
while (*av++)
return (i);
}
-char **
-blkcpy(oav, bv)
- char **oav;
- register char **bv;
-{
+char **blkcpy(oav, bv) char **oav; register char **bv; {
register char **av = oav;
while (*av++ = *bv++)
return (oav);
}
-char **
-blkcat(up, vp)
- char **up, **vp;
-{
+char **blkcat(up, vp) char **up; char **vp; {
(void) blkcpy(blkend(up), vp);
return (up);
}
-blkfree(av0)
- char **av0;
-{
+int blkfree(av0) char **av0; {
register char **av = av0;
for (; *av; av++)
XFREE((char *)av0)
}
-char **
-saveblk(v)
- register char **v;
-{
+char **saveblk(v) register char **v; {
register char **newv =
(char **) calloc((unsigned) (blklen(v) + 1), sizeof (char **));
char **onewv = newv;
return (onewv);
}
-char *
-strspl(cp, dp)
- char *cp, *dp;
-{
+char *strspl(cp, dp) char *cp; char *dp; {
char *ep;
register char *p, *q;
return (ep);
}
-char **
-blkspl(up, vp)
- register char **up, **vp;
-{
+char **blkspl(up, vp) register char **up; register char **vp; {
register char **wp =
(char **) calloc((unsigned) (blklen(up) + blklen(vp) + 1),
sizeof (char **));
return (blkcat(wp, vp));
}
-lastchr(cp)
- register char *cp;
-{
+int lastchr(cp) register char *cp; {
if (!*cp)
return (0);
* This routine is called after an error to close up
* any units which may have been left open accidentally.
*/
-closem()
-{
+int closem() {
register int f;
for (f = 0; f < NOFILE; f++)
(void) close(f);
}
-donefds()
-{
+int donefds() {
(void) close(0);
(void) close(1);
* If j is -1 then we just want to get i to a safe place,
* i.e. to a unit > 2. This also happens in dcopy.
*/
-dmove(i, j)
- register int i, j;
-{
+int dmove(i, j) register int i; register int j; {
if (i == j || i < 0)
return (i);
return (j);
}
-dcopy(i, j)
- register int i, j;
-{
+int dcopy(i, j) register int i; register int j; {
if (i == j || i < 0 || j < 0 && i > 2)
return (i);
return (renum(i, j));
}
-renum(i, j)
- register int i, j;
-{
+int renum(i, j) register int i; register int j; {
register int k = dup(i);
if (k < 0)
* the first c arguments. Used in "shift" commands
* as well as by commands like "repeat".
*/
-lshift(v, c)
- register char **v;
- register int c;
-{
+int lshift(v, c) register char **v; register int c; {
register char **u = v;
while (*u && --c >= 0)
(void) blkcpy(v, u);
}
-number(cp)
- char *cp;
-{
+int number(cp) char *cp; {
if (*cp == '-') {
cp++;
return (*cp == 0);
}
-char **
-copyblk(v)
- register char **v;
-{
+char **copyblk(v) register char **v; {
register char **nv =
(char **) calloc((unsigned) (blklen(v) + 1), sizeof (char **));
return (blkcpy(nv, v));
}
-char *
-strend(cp)
- register char *cp;
-{
+char *strend(cp) register char *cp; {
while (*cp)
cp++;
return (cp);
}
-char *
-strip(cp)
- char *cp;
-{
+char *strip(cp) char *cp; {
register char *dp = cp;
while (*dp++ &= TRIM)
return (cp);
}
-udvar(name)
- char *name;
-{
+int udvar(name) char *name; {
setname(name);
bferr("Undefined variable");
}
-prefix(sub, str)
- register char *sub, *str;
-{
+int prefix(sub, str) register char *sub; register char *str; {
for (;;) {
if (*sub == 0)
+/*#include <gen.h> sh.h*/
+/*#include <setjmp.h> sh.h*/
+/*#include "sh.h" sh.proc.h*/
+#include "sh.proc.h"
+
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
* specifies the terms and conditions for redistribution.
*/
-#ifndef lint
+#if defined(DOSCCS) && !defined(lint)
static char *sccsid = "@(#)sh.parse.c 5.3 (Berkeley) 5/13/86";
#endif
-#include "sh.h"
+/*#include "sh.h"*/
/*
* C shell
* If word 0 of a command has an alias, do it.
* Repeat a maximum of 20 times.
*/
-alias(lex)
- register struct wordent *lex;
-{
+int alias(lex) register struct wordent *lex; {
int aleft = 21;
jmp_buf osetexit;
resexit(osetexit);
}
-asyntax(p1, p2)
- register struct wordent *p1, *p2;
-{
+int asyntax(p1, p2) register struct wordent *p1; register struct wordent *p2; {
while (p1 != p2)
if (any(p1->word[0], ";&\n"))
}
}
-asyn0(p1, p2)
- struct wordent *p1;
- register struct wordent *p2;
-{
+int asyn0(p1, p2) struct wordent *p1; register struct wordent *p2; {
register struct wordent *p;
register int l = 0;
asyn3(p1, p2);
}
-asyn3(p1, p2)
- struct wordent *p1;
- register struct wordent *p2;
-{
+int asyn3(p1, p2) struct wordent *p1; register struct wordent *p2; {
register struct varent *ap;
struct wordent alout;
register bool redid;
reset(); /* throw! */
}
-struct wordent *
-freenod(p1, p2)
- register struct wordent *p1, *p2;
-{
+struct wordent *freenod(p1, p2) register struct wordent *p1; register struct wordent *p2; {
register struct wordent *retp = p1->prev;
while (p1 != p2) {
* empty
* syn0
*/
-struct command *
-syntax(p1, p2, flags)
- register struct wordent *p1, *p2;
- int flags;
-{
+struct command *syntax(p1, p2, flags) register struct wordent *p1; register struct wordent *p2; int flags; {
while (p1 != p2)
if (any(p1->word[0], ";&\n"))
* syn1
* syn1 & syntax
*/
-struct command *
-syn0(p1, p2, flags)
- struct wordent *p1, *p2;
- int flags;
-{
+struct command *syn0(p1, p2, flags) struct wordent *p1; struct wordent *p2; int flags; {
register struct wordent *p;
register struct command *t, *t1;
int l;
* syn1a
* syn1a ; syntax
*/
-struct command *
-syn1(p1, p2, flags)
- struct wordent *p1, *p2;
- int flags;
-{
+struct command *syn1(p1, p2, flags) struct wordent *p1; struct wordent *p2; int flags; {
register struct wordent *p;
register struct command *t;
int l;
* syn1b
* syn1b || syn1a
*/
-struct command *
-syn1a(p1, p2, flags)
- struct wordent *p1, *p2;
- int flags;
-{
+struct command *syn1a(p1, p2, flags) struct wordent *p1; struct wordent *p2; int flags; {
register struct wordent *p;
register struct command *t;
register int l = 0;
* syn2
* syn2 && syn1b
*/
-struct command *
-syn1b(p1, p2, flags)
- struct wordent *p1, *p2;
- int flags;
-{
+struct command *syn1b(p1, p2, flags) struct wordent *p1; struct wordent *p2; int flags; {
register struct wordent *p;
register struct command *t;
register int l = 0;
* syn3 | syn2
* syn3 |& syn2
*/
-struct command *
-syn2(p1, p2, flags)
- struct wordent *p1, *p2;
- int flags;
-{
+struct command *syn2(p1, p2, flags) struct wordent *p1; struct wordent *p2; int flags; {
register struct wordent *p, *pn;
register struct command *t;
register int l = 0;
*
* KEYWORD = (@ exit foreach if set switch test while)
*/
-struct command *
-syn3(p1, p2, flags)
- struct wordent *p1, *p2;
- int flags;
-{
+struct command *syn3(p1, p2, flags) struct wordent *p1; struct wordent *p2; int flags; {
register struct wordent *p;
struct wordent *lp, *rp;
register struct command *t;
return (t);
}
-freesyn(t)
- register struct command *t;
-{
+int freesyn(t) register struct command *t; {
register char **v;
if (t == 0)
+#include <sys/file.h>
+#include <sys/ioctl.h>
+#include "sh.h"
+
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
* specifies the terms and conditions for redistribution.
*/
-#ifndef lint
+#if defined(DOSCCS) && !defined(lint)
static char *sccsid = "@(#)sh.print.c 5.2 (Berkeley) 6/6/85";
#endif
-#include "sh.h"
-#include <sys/ioctl.h>
+/*#include "sh.h"*/
+/*#include <sys/ioctl.h>*/
/*
* C Shell
*/
-psecs(l)
- long l;
-{
+int psecs(l) long l; {
register int i;
i = l / 3600;
p2dig(i);
}
-p2dig(i)
- register int i;
-{
+int p2dig(i) register int i; {
printf("%d%d", i / 10, i % 10);
}
char linbuf[128];
char *linp = linbuf;
-putchar(c)
- register int c;
-{
+int putchar(c) register int c; {
if ((c & QUOTE) == 0 && (c == 0177 || c < ' ' && c != '\t' && c != '\n')) {
putchar('^');
flush();
}
-draino()
-{
+int draino() {
linp = linbuf;
}
-flush()
-{
+int flush() {
register int unit;
int lmode;
+/*#include <gen.h> sh.h*/
+/*#include <strings.h> sh.h*/
+/*#include <sys/errno.h> sh.h*/
+#include <sys/ioctl.h>
+/*#include <sys/proc.h> sh.h*/
+/*#include <sys/resource.h> sh.h*/
+/*#include <sys/signal.h> sh.h*/
+/*#include <sys/time.h> sh.h*/
+#include <sys/wait.h>
+#include "sh.char.h"
+#include "sh.dir.h"
+/*#include "sh.h" sh.proc.h*/
+/*#include "sh.local.h" sh.h*/
+#include "sh.proc.h"
+
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
* specifies the terms and conditions for redistribution.
*/
-#ifndef lint
+#if defined(DOSCCS) && !defined(lint)
static char *sccsid = "@(#)sh.proc.c 5.5 (Berkeley) 5/13/86";
#endif
-#include "sh.h"
-#include "sh.dir.h"
-#include "sh.proc.h"
-#include <sys/wait.h>
-#include <sys/ioctl.h>
+/*#include "sh.h"*/
+/*#include "sh.dir.h"*/
+/*#include "sh.proc.h"*/
+/*#include <sys/wait.h>*/
+/*#include <sys/ioctl.h>*/
/*
* C Shell - functions that manage processes, handling hanging, termination
* childs status. Top level routines (like pwait) must be sure
* to mask interrupts when playing with the proclist data structures!
*/
-pchild()
-{
+int pchild() {
register struct process *pp;
register struct process *fp;
register int pid;
goto loop;
}
-pnote()
-{
+int pnote() {
register struct process *pp;
int flags, omask;
* pwait - wait for current job to terminate, maintaining integrity
* of current and previous job indicators.
*/
-pwait()
-{
+int pwait() {
register struct process *fp, *pp;
int omask;
* pjwait - wait for a job to finish or become stopped
* It is assumed to be in the foreground state (PFOREGND)
*/
-pjwait(pp)
- register struct process *pp;
-{
+int pjwait(pp) register struct process *pp; {
register struct process *fp;
int jobflags, reason, omask;
/*
* dowait - wait for all processes to finish
*/
-dowait()
-{
+int dowait() {
register struct process *pp;
int omask;
/*
* pflushall - flush all jobs from list (e.g. at fork())
*/
-pflushall()
-{
+int pflushall() {
register struct process *pp;
for (pp = proclist.p_next; pp != PNULL; pp = pp->p_next)
* the argument process for deletion. The actual free of the
* space is not done here since pflush is called at interrupt level.
*/
-pflush(pp)
- register struct process *pp;
-{
+int pflush(pp) register struct process *pp; {
register struct process *np;
register int index;
* pclrcurr - make sure the given job is not the current or previous job;
* pp MUST be the job leader
*/
-pclrcurr(pp)
- register struct process *pp;
-{
+int pclrcurr(pp) register struct process *pp; {
if (pp == pcurrent)
if (pprevious != PNULL) {
* palloc - allocate a process structure and fill it up.
* an important assumption is made that the process is running.
*/
-palloc(pid, t)
- int pid;
- register struct command *t;
-{
+int palloc(pid, t) int pid; register struct command *t; {
register struct process *pp;
int i;
(void) gettimeofday(&pp->p_btime, (struct timezone *)0);
}
-padd(t)
- register struct command *t;
-{
+int padd(t) register struct command *t; {
char **argp;
if (t == 0)
}
}
-pads(cp)
- char *cp;
-{
+int pads(cp) char *cp; {
register int i = strlen(cp);
if (cmdlen >= PMAXLEN)
* so another job can be created. Used for { } in exp6
* and `` in globbing.
*/
-psavejob()
-{
+int psavejob() {
pholdjob = pcurrjob;
pcurrjob = PNULL;
* prestjob - opposite of psavejob. This may be missed if we are interrupted
* somewhere, but pendjob cleans up anyway.
*/
-prestjob()
-{
+int prestjob() {
pcurrjob = pholdjob;
pholdjob = PNULL;
* pendjob - indicate that a job (set of commands) has been completed
* or is about to begin.
*/
-pendjob()
-{
+int pendjob() {
register struct process *pp, *tp;
if (pcurrjob && (pcurrjob->p_flags&(PFOREGND|PSTOPPED)) == 0) {
/*
* pprint - print a job
*/
-pprint(pp, flag)
- register struct process *pp;
-{
+int pprint(pp, flag) register struct process *pp; int flag; {
register status, reason;
struct process *tp;
extern char *linp, linbuf[];
return (jobflags);
}
-ptprint(tp)
- register struct process *tp;
-{
+int ptprint(tp) register struct process *tp; {
struct timeval tetime, diff;
static struct timeval ztime;
struct rusage ru;
/*
* dojobs - print all jobs
*/
-dojobs(v)
- char **v;
-{
+int dojobs(v) char **v; {
register struct process *pp;
register int flag = NUMBER|NAME|REASON;
int i;
/*
* dofg - builtin - put the job into the foreground
*/
-dofg(v)
- char **v;
-{
+int dofg(v) char **v; {
register struct process *pp;
okpcntl();
/*
* %... - builtin - put the job into the foreground
*/
-dofg1(v)
- char **v;
-{
+int dofg1(v) char **v; {
register struct process *pp;
okpcntl();
/*
* dobg - builtin - put the job into the background
*/
-dobg(v)
- char **v;
-{
+int dobg(v) char **v; {
register struct process *pp;
okpcntl();
/*
* %... & - builtin - put the job into the background
*/
-dobg1(v)
- char **v;
-{
+int dobg1(v) char **v; {
register struct process *pp;
pp = pfind(v[0]);
/*
* dostop - builtin - stop the job
*/
-dostop(v)
- char **v;
-{
+int dostop(v) char **v; {
pkill(++v, SIGSTOP);
}
/*
* dokill - builtin - superset of kill (1)
*/
-dokill(v)
- char **v;
-{
+int dokill(v) char **v; {
register int signum;
register char *name;
pkill(v, signum);
}
-pkill(v, signum)
- char **v;
- int signum;
-{
+int pkill(v, signum) char **v; int signum; {
register struct process *pp, *np;
register int jobflags = 0;
int omask, pid, err = 0;
/*
* pstart - start the job in foreground/background
*/
-pstart(pp, foregnd)
- register struct process *pp;
- int foregnd;
-{
+int pstart(pp, foregnd) register struct process *pp; int foregnd; {
register struct process *np;
int omask, jobflags = 0;
(void) sigsetmask(omask);
}
-panystop(neednl)
-{
+int panystop(neednl) int neednl; {
register struct process *pp;
chkstop = 2;
error("\nThere are stopped jobs" + 1 - neednl);
}
-struct process *
-pfind(cp)
- char *cp;
-{
+struct process *pfind(cp) char *cp; {
register struct process *pp, *np;
if (cp == 0 || cp[1] == 0 || eq(cp, "%%") || eq(cp, "%+")) {
/*
* pgetcurr - find most recent job that is not pp, preferably stopped
*/
-struct process *
-pgetcurr(pp)
- register struct process *pp;
-{
+struct process *pgetcurr(pp) register struct process *pp; {
register struct process *np;
register struct process *xp = PNULL;
/*
* donotify - flag the job so as to report termination asynchronously
*/
-donotify(v)
- char **v;
-{
+int donotify(v) char **v; {
register struct process *pp;
pp = pfind(*++v);
* 1: want to claim tty; manipulate process and tty pgrps
* It is usually just the value of tpgrp.
*/
-pfork(t, wanttty)
- struct command *t; /* command we are forking for */
- int wanttty;
-{
+int pfork(t, wanttty) struct command *t; /* command we are forking for */ int wanttty; {
register int pid;
bool ignint = 0;
int pgrp, omask;
return (pid);
}
-okpcntl()
-{
+int okpcntl() {
if (tpgrp == -1)
error("No job control in this shell");
+#ifndef _SH_PROC_H_
+#define _SH_PROC_H_
+
+/*#include <sys/resource.h> sh.h*/
+/*#include <sys/time.h> sh.h*/
+#include "sh.h"
+
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
short pmaxindex; /* current maximum job index */
-int psigint();
-struct process *pgetcurr();
-struct process *plookup();
-struct process *pfind();
+/*int psigint();*/
+/*struct process *pgetcurr();*/
+/*struct process *plookup();*/
+/*struct process *pfind();*/
+
+#ifndef __P
+#ifdef __STDC__
+#define __P(args) args
+#else
+#define __P(args) ()
+#endif
+#endif
+
+/* sh.proc.c */
+int pchild __P((void));
+int pnote __P((void));
+int pwait __P((void));
+int pjwait __P((register struct process *pp));
+int dowait __P((void));
+int pflushall __P((void));
+int pflush __P((register struct process *pp));
+int pclrcurr __P((register struct process *pp));
+int palloc __P((int pid, register struct command *t));
+int padd __P((register struct command *t));
+int pads __P((char *cp));
+int psavejob __P((void));
+int prestjob __P((void));
+int pendjob __P((void));
+int pprint __P((register struct process *pp, int flag));
+int ptprint __P((register struct process *tp));
+int dojobs __P((char **v));
+int dofg __P((char **v));
+int dofg1 __P((char **v));
+int dobg __P((char **v));
+int dobg1 __P((char **v));
+int dostop __P((char **v));
+int dokill __P((char **v));
+int pkill __P((char **v, int signum));
+int pstart __P((register struct process *pp, int foregnd));
+int panystop __P((int neednl));
+struct process *pfind __P((char *cp));
+struct process *pgetcurr __P((register struct process *pp));
+int donotify __P((char **v));
+int pfork __P((struct command *t, int wanttty));
+int okpcntl __P((void));
+
+/* sh.sem.c */
+int execute __P((register struct command *t, int wanttty, int *pipein, int *pipeout));
+int vffree __P((void));
+int doio __P((register struct command *t, int *pipein, int *pipeout));
+int mypipe __P((register int *pv));
+int chkclob __P((register char *cp));
+
+#endif
+/*#include <strings.h> sh.h*/
+#include <sys/file.h>
+#include <sys/ioctl.h>
+/*#include <sys/proc.h> sh.h*/
+/*#include <sys/resource.h> sh.h*/
+/*#include <sys/signal.h> sh.h*/
+/*#include <sys/stat.h> sh.h*/
+/*#include <sys/types.h> sh.h*/
+/*#include "sh.h" sh.proc.h*/
+/*#include "sh.local.h" sh.h*/
+#include "sh.proc.h"
+
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
* specifies the terms and conditions for redistribution.
*/
-#ifndef lint
+#if defined(DOSCCS) && !defined(lint)
static char *sccsid = "@(#)sh.sem.c 5.4 (Berkeley) 5/13/86";
#endif
-#include "sh.h"
-#include "sh.proc.h"
-#include <sys/ioctl.h>
+/*#include "sh.h"*/
+/*#include "sh.proc.h"*/
+/*#include <sys/ioctl.h>*/
/*
* C shell
*/
-execute(t, wanttty, pipein, pipeout)
- register struct command *t;
- int wanttty, *pipein, *pipeout;
-{
+int execute(t, wanttty, pipein, pipeout) register struct command *t; int wanttty; int *pipein; int *pipeout; {
bool forked = 0;
struct biltins *bifunc;
int pid = 0;
}
#ifdef VFORK
-vffree()
-{
+int vffree() {
register char **v;
if (v = gargv)
* Perform io redirection.
* We may or maynot be forked here.
*/
-doio(t, pipein, pipeout)
- register struct command *t;
- int *pipein, *pipeout;
-{
+int doio(t, pipein, pipeout) register struct command *t; int *pipein; int *pipeout; {
register char *cp;
register int flags = t->t_dflg;
didfds = 1;
}
-mypipe(pv)
- register int *pv;
-{
+int mypipe(pv) register int *pv; {
if (pipe(pv) < 0)
goto oops;
error("Can't make pipe");
}
-chkclob(cp)
- register char *cp;
-{
+int chkclob(cp) register char *cp; {
struct stat stb;
if (stat(cp, &stb) < 0)
+/*#include <strings.h> sh.h*/
+/*#include <sys/signal.h> sh.h*/
+#include "sh.char.h"
+#include "sh.h"
+/*#include "sh.local.h" sh.h*/
+
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
* specifies the terms and conditions for redistribution.
*/
-#ifndef lint
+#if defined(DOSCCS) && !defined(lint)
static char *sccsid = "@(#)sh.set.c 5.2 (Berkeley) 6/6/85";
#endif
-#include "sh.h"
+/*#include "sh.h"*/
/*
* C Shell
*/
-doset(v)
- register char **v;
-{
+int doset(v) register char **v; {
register char *p;
char *vp, op;
char **vecp;
} while (p = *v++);
}
-char *
-getinx(cp, ip)
- register char *cp;
- register int *ip;
-{
+char *getinx(cp, ip) register char *cp; register int *ip; {
*ip = 0;
*cp++ = 0;
return (cp);
}
-asx(vp, subscr, p)
- char *vp;
- int subscr;
- char *p;
-{
+int asx(vp, subscr, p) char *vp; int subscr; char *p; {
register struct varent *v = getvx(vp, subscr);
xfree(v->vec[subscr - 1]);
v->vec[subscr - 1] = globone(p);
}
-struct varent *
-getvx(vp, subscr)
- char *vp;
-{
+struct varent *getvx(vp, subscr) char *vp; int subscr; {
register struct varent *v = adrof(vp);
if (v == 0)
char plusplus[2] = { '1', 0 };
-dolet(v)
- char **v;
-{
+int dolet(v) char **v; {
register char *p;
char *vp, c, op;
bool hadsub;
else
if (hadsub)
#ifndef V6
- /* avoid bug in vax CC */
- {
+ /* avoid bug in vax CC */ {
struct varent *gv = getvx(vp, subscr);
asx(vp, subscr, operate(op, gv->vec[subscr - 1], p));
} while (p = *v++);
}
-char *
-xset(cp, vp)
- char *cp, ***vp;
-{
+char *xset(cp, vp) char *cp; char ***vp; {
register char *dp;
if (*cp) {
return (putn(exp(vp)));
}
-char *
-operate(op, vp, p)
- char op, *vp, *p;
-{
+char *operate(op, vp, p) int op; char *vp; char *p; {
char opr[2];
char *vec[5];
register char **v = vec;
static char *putp;
-char *
-putn(n)
- register int n;
-{
+char *putn(n) register int n; {
static char number[15];
putp = number;
return (savestr(number));
}
-putn1(n)
- register int n;
-{
+int putn1(n) register int n; {
if (n > 9)
putn1(n / 10);
*putp++ = n % 10 + '0';
}
-getn(cp)
- register char *cp;
-{
+int getn(cp) register char *cp; {
register int n;
int sign;
return (0);
}
-char *
-value1(var, head)
- char *var;
- struct varent *head;
-{
+char *value1(var, head) char *var; struct varent *head; {
register struct varent *vp;
vp = adrof1(var, head);
return (vp == 0 || vp->vec[0] == 0 ? "" : vp->vec[0]);
}
-struct varent *
-madrof(pat, vp)
- char *pat;
- register struct varent *vp;
-{
+struct varent *madrof(pat, vp) char *pat; register struct varent *vp; {
register struct varent *vp1;
for (; vp; vp = vp->v_right) {
return vp;
}
-struct varent *
-adrof1(name, v)
- register char *name;
- register struct varent *v;
-{
+struct varent *adrof1(name, v) register char *name; register struct varent *v; {
register cmp;
v = v->v_left;
/*
* The caller is responsible for putting value in a safe place
*/
-set(var, val)
- char *var, *val;
-{
+int set(var, val) char *var; char *val; {
register char **vec = (char **) xalloc(2 * sizeof (char **));
vec[0] = onlyread(val) ? savestr(val) : val;
set1(var, vec, &shvhed);
}
-set1(var, vec, head)
- char *var, **vec;
- struct varent *head;
-{
+int set1(var, vec, head) char *var; char **vec; struct varent *head; {
register char **oldv = vec;
gflag = 0; tglob(oldv);
setq(var, vec, head);
}
-setq(name, vec, p)
- char *name, **vec;
- register struct varent *p;
-{
+int setq(name, vec, p) char *name; char **vec; register struct varent *p; {
register struct varent *c;
register f;
trim(c->vec = vec);
}
-unset(v)
- char *v[];
-{
+int unset(v) char *v[]; {
unset1(v, &shvhed);
if (adrof("histchars") == 0) {
#endif
}
-unset1(v, head)
- register char *v[];
- struct varent *head;
-{
+int unset1(v, head) register char *v[]; struct varent *head; {
register struct varent *vp;
register int cnt;
}
}
-unsetv(var)
- char *var;
-{
+int unsetv(var) char *var; {
register struct varent *vp;
if ((vp = adrof1(var, &shvhed)) == 0)
unsetv1(vp);
}
-unsetv1(p)
- register struct varent *p;
-{
+int unsetv1(p) register struct varent *p; {
register struct varent *c, *pp;
register f;
balance(pp, f, 1);
}
-setNS(cp)
- char *cp;
-{
+int setNS(cp) char *cp; {
set(cp, "");
}
-shift(v)
- register char **v;
-{
+int shift(v) register char **v; {
register struct varent *argv;
register char *name;
lshift(argv->vec, 1);
}
-exportpath(val)
-char **val;
-{
+int exportpath(val) char **val; {
char exppath[BUFSIZ];
exppath[0] = 0;
* F == 0 means we've come from p's left child.
* D == 1 means we've just done a delete, otherwise an insert.
*/
-balance(p, f, d)
- register struct varent *p;
- register f;
-{
+int balance(p, f, d) register struct varent *p; register f; int d; {
register struct varent *pp;
register struct varent *t; /* used by the rotate macros */
register ff;
}
}
-plist(p)
- register struct varent *p;
-{
+int plist(p) register struct varent *p; {
register struct varent *c;
register len;
+/*#include <sys/resource.h> sh.h*/
+/*#include <sys/time.h> sh.h*/
+/*#include <sys/types.h> sh.h*/
+#include "sh.h"
+
/*
* Copyright (c) 1980 Regents of the University of California.
* All rights reserved. The Berkeley Software License Agreement
* specifies the terms and conditions for redistribution.
*/
-#ifndef lint
+#if defined(DOSCCS) && !defined(lint)
static char *sccsid = "@(#)sh.time.c 5.4 (Berkeley) 5/13/86";
#endif
-#include "sh.h"
+/*#include "sh.h"*/
/*
* C Shell - routines handling process timing and niceing
*/
-settimes()
-{
+int settimes() {
struct rusage ruch;
(void) gettimeofday(&time0, (struct timezone *)0);
* dotime is only called if it is truly a builtin function and not a
* prefix to another command
*/
-dotime()
-{
+int dotime() {
struct timeval timedol;
struct rusage ru1, ruch;
/*
* donice is only called when it on the line by itself or with a +- value
*/
-donice(v)
- register char **v;
-{
+int donice(v) register char **v; {
register char *cp;
int nval;
(void) setpriority(PRIO_PROCESS, 0, nval);
}
-ruadd(ru, ru2)
- register struct rusage *ru, *ru2;
-{
+int ruadd(ru, ru2) register struct rusage *ru; register struct rusage *ru2; {
register long *lp, *lp2;
register int cnt;
while (--cnt > 0);
}
-prusage(r0, r1, e, b)
- register struct rusage *r0, *r1;
- struct timeval *e, *b;
-{
+int prusage(r0, r1, e, b) register struct rusage *r0; register struct rusage *r1; struct timeval *e; struct timeval *b; {
register time_t t =
(r1->ru_utime.tv_sec-r0->ru_utime.tv_sec)*100+
(r1->ru_utime.tv_usec-r0->ru_utime.tv_usec)/10000+
putchar('\n');
}
-pdeltat(t1, t0)
- struct timeval *t1, *t0;
-{
+int pdeltat(t1, t0) struct timeval *t1; struct timeval *t0; {
struct timeval td;
tvsub(&td, t1, t0);
printf("%d.%01d", td.tv_sec, td.tv_usec/100000);
}
-tvadd(tsum, t0)
- struct timeval *tsum, *t0;
-{
+int tvadd(tsum, t0) struct timeval *tsum; struct timeval *t0; {
tsum->tv_sec += t0->tv_sec;
tsum->tv_usec += t0->tv_usec;
tsum->tv_sec++, tsum->tv_usec -= 1000000;
}
-tvsub(tdiff, t1, t0)
- struct timeval *tdiff, *t1, *t0;
-{
+int tvsub(tdiff, t1, t0) struct timeval *tdiff; struct timeval *t1; struct timeval *t0; {
tdiff->tv_sec = t1->tv_sec - t0->tv_sec;
tdiff->tv_usec = t1->tv_usec - t0->tv_usec;
public / 43bsd.git / commitdiff