${CC} ${CFLAGS} -o expr expr.o
ps:
- ${CC} ${CFLAGS} -o ps ps.c -lm
+# ${CC} ${CFLAGS} -o ps ps.c -lm
+ ${CC} ${CFLAGS} -o ps ps.c -lnox_m
# DO NOT DELETE THIS LINE -- make depend uses it
char *man = { "mrxtdpq" };
char *opt = { "uvnbailo" };
+#ifndef __P
+#ifdef __STDC__
+#define __P(args) args
+#else
+#define __P(args) ()
+#endif
+#endif
+
int signum[] = {SIGHUP, SIGINT, SIGQUIT, 0};
/*int sigdone();*/
/*long lseek();*/
/*int pcmd();*/
/*int mcmd();*/
/*int qcmd();*/
-int (*comfun)();
+void (*comfun) __P((void));
char flg[26];
char **namv;
int namc;
/*char *mktemp();*/
/*char *ctime();*/
-#ifndef __P
-#ifdef __STDC__
-#define __P(args) args
-#else
-#define __P(args) ()
-#endif
-#endif
-
-int main __P((int argc, char *argv[]));
-int setcom __P((int (*fun)(void)));
-int rcmd __P((void));
-int dcmd __P((void));
-int xcmd __P((void));
-int pcmd __P((void));
-int mcmd __P((void));
-int tcmd __P((void));
-int qcmd __P((void));
-int init __P((void));
+void main __P((int argc, char *argv[]));
+void setcom __P((void (*fun)(void)));
+void rcmd __P((void));
+void dcmd __P((void));
+void xcmd __P((void));
+void pcmd __P((void));
+void mcmd __P((void));
+void tcmd __P((void));
+void qcmd __P((void));
+void init __P((void));
int getaf __P((void));
-int getqf __P((void));
-int usage __P((void));
-int noar __P((void));
-int sigdone __P((void));
-int done __P((int c));
+void getqf __P((void));
+void usage __P((void));
+void noar __P((void));
+void sigdone __P((void));
+void done __P((int c));
int notfound __P((void));
int morefil __P((void));
-int cleanup __P((void));
-int install __P((void));
-int movefil __P((int f));
+void cleanup __P((void));
+void install __P((void));
+void movefil __P((int f));
int stats __P((void));
-int copyfil __P((int fi, int fo, int flag));
+void copyfil __P((int fi, int fo, int flag));
int getdir __P((void));
int match __P((void));
-int bamatch __P((void));
-int phserr __P((void));
-int mesg __P((int c));
+void bamatch __P((void));
+void phserr __P((void));
+void mesg __P((int c));
char *trim __P((char *s));
-int longt __P((void));
-int pmode __P((void));
-int select __P((int *pairp));
-int wrerr __P((void));
+void longt __P((void));
+void pmode __P((void));
+void select __P((int *pairp));
+void wrerr __P((void));
-int main(argc, argv) int argc; char *argv[]; {
+void main(argc, argv) int argc; char *argv[]; {
register i;
register char *cp;
for(i=0; signum[i]; i++)
if(signal(signum[i], SIG_IGN) != SIG_IGN)
- signal(signum[i], sigdone);
+ signal(signum[i], (void (*) __P((int sig)))sigdone);
if(argc < 3)
usage();
cp = argv[1];
done(notfound());
}
-int setcom(fun) int (*fun)(); {
+void setcom(fun) void (*fun) __P((void)); {
if(comfun != 0) {
fprintf(stderr, "ar: only one of [%s] allowed\n", man);
comfun = fun;
}
-int rcmd() {
+void rcmd() {
register f;
init();
cleanup();
}
-int dcmd() {
+void dcmd() {
init();
if(getaf())
install();
}
-int xcmd() {
+void xcmd() {
register f;
struct timeval tv[2];
}
}
-int pcmd() {
+void pcmd() {
if(getaf())
noar();
}
}
-int mcmd() {
+void mcmd() {
init();
if(getaf())
install();
}
-int tcmd() {
+void tcmd() {
if(getaf())
noar();
}
}
-int qcmd() {
+void qcmd() {
register i, f;
if (flg['a'-'a'] || flg['b'-'a']) {
}
}
-int init() {
+void init() {
tfnam = mktemp(tmpnam);
close(creat(tfnam, 0600));
return(0);
}
-int getqf() {
+void getqf() {
char mbuf[SARMAG];
if ((qf = open(arnam, 2)) < 0) {
}
}
-int usage() {
+void usage() {
printf("usage: ar [%s][%s] archive files ...\n", man, opt);
done(1);
}
-int noar() {
+void noar() {
fprintf(stderr, "ar: %s does not exist\n", arnam);
done(1);
}
-int sigdone() {
+void sigdone() {
done(100);
}
-int done(c) int c; {
+void done(c) int c; {
if(tfnam)
unlink(tfnam);
return(n);
}
-int cleanup() {
+void cleanup() {
register i, f;
_truncate++;
install();
}
-int install() {
+void install() {
register i;
for(i=0; signum[i]; i++)
* insert the file 'file'
* into the temporary file
*/
-int movefil(f) int f; {
+void movefil(f) int f; {
char buf[sizeof(arbuf)+1];
sprintf(buf, "%-16s%-12ld%-6u%-6u%-8o%-10ld%-2s",
* copy next file
* size given in arbuf
*/
-int copyfil(fi, fo, flag) int fi; int fo; int flag; {
+void copyfil(fi, fo, flag) int fi; int fo; int flag; {
register i, o;
int pe;
return(0);
}
-int bamatch() {
+void bamatch() {
register f;
switch(bastate) {
}
}
-int phserr() {
+void phserr() {
fprintf(stderr, "ar: phase error on %s\n", file);
}
-int mesg(c) int c; {
+void mesg(c) int c; {
if(flg['v'-'a'])
if(c != 'c' || flg['v'-'a'] > 1)
#define XOTH 01
#define STXT 01000
-int longt() {
+void longt() {
register char *cp;
pmode();
int *m[] = { m1, m2, m3, m4, m5, m6, m7, m8, m9};
-int pmode() {
+void pmode() {
register int **mp;
for (mp = &m[0]; mp < &m[9];)
select(*mp++);
}
-int select(pairp) int *pairp; {
+void select(pairp) int *pairp; {
register int n, *ap;
ap = pairp;
putchar(*ap);
}
-int wrerr() {
+void wrerr() {
perror("ar write error");
done(1);
}
/*#include <sys/types.h>*/
/*#include <sys/stat.h>*/
-/* #define OPTSIZE BUFSIZ /* define this only if not 4.2 BSD or beyond */
+/*#define OPTSIZE BUFSIZ*/ /* define this only if not 4.2 BSD or beyond */
int bflg, eflg, nflg, sflg, tflg, uflg, vflg;
int spaced, col, lno, inline, ibsize, obsize;
#endif
#endif
-int main __P((int argc, char **argv));
-int copyopt __P((register FILE *f));
+void main __P((int argc, char **argv));
+void copyopt __P((register FILE *f));
int fastcat __P((register int fd));
-int main(argc, argv) int argc; char **argv; {
+void main(argc, argv) int argc; char **argv; {
int fflg = 0;
register FILE *fi;
register c;
exit(retval);
}
-int copyopt(f) register FILE *f; {
+void copyopt(f) register FILE *f; {
register int c;
top:
int fastcat(fd) register int fd; {
register int buffsize, n, nwritten, offset;
register char *buff;
- struct stat statbuff;
void *malloc();
#ifndef OPTSIZE
#endif
#endif
-int main __P((int argc, char **argv));
-int idexit __P((void));
-int dexit __P((void));
-int error __P((char *s, char *x));
+void main __P((int argc, char **argv));
+void idexit __P((void));
+void dexit __P((void));
+void error __P((char *s, char *x));
int getsuf __P((char as[]));
char *setsuf __P((char *as, int ch));
int callsys __P((char *f, char **v));
char *savestr __P((register char *cp));
char *strspl __P((char *left, char *right));
-int main(argc, argv) int argc; char **argv; {
+void main(argc, argv) int argc; char **argv; {
char *t;
char *assource;
int i, j, c;
if (nc==0)
goto nocom;
if (signal(SIGINT, SIG_IGN) != SIG_IGN)
- signal(SIGINT, idexit);
+ signal(SIGINT, (void (*) __P((int sig)))idexit);
if (signal(SIGTERM, SIG_IGN) != SIG_IGN)
- signal(SIGTERM, idexit);
+ signal(SIGTERM, (void (*) __P((int sig)))idexit);
if (signal(SIGHUP, SIG_IGN) != SIG_IGN)
- signal(SIGHUP, idexit);
+ signal(SIGHUP, (void (*) __P((int sig)))idexit);
if (pflag==0)
sprintf(tmp0, "/tmp/ctm%05.5d", getpid());
tmp1 = strspl(tmp0, "1");
dexit();
}
-int idexit() {
+void idexit() {
eflag = 100;
dexit();
}
-int dexit() {
+void dexit() {
if (!pflag) {
cunlink(tmp1);
exit(eflag);
}
-int error(s, x) char *s; char *x; {
+void error(s, x) char *s; char *x; {
FILE *diag = exflag ? stderr : stdout;
fprintf(diag, "cc: ");
#endif
#endif
-int main __P((int argc, char *argv[]));
+void main __P((int argc, char *argv[]));
int isnumber __P((char *s));
int chownr __P((char *dir, int uid, int gid));
int verror __P((char *fmt, va_list argp));
int error __P((char *fmt, ...));
-int fatal __P((int status, char *fmt, ...));
+void fatal __P((int status, char *fmt, ...));
int Perror __P((char *s));
-int main(argc, argv) int argc; char *argv[]; {
+void main(argc, argv) int argc; char *argv[]; {
register c, i;
register char *cp;
}
#ifdef __STDC__
-int fatal(int status, char *fmt, ...)
+void fatal(int status, char *fmt, ...)
#else
-int fatal(status, fmt, va_alist) int status; char *fmt; va_dcl
+void fatal(status, fmt, va_alist) int status; char *fmt; va_dcl
#endif
{
va_list argp;
#endif
#endif
-int main __P((int argc, char *argv[]));
+void main __P((int argc, char *argv[]));
int chmodr __P((char *dir, int mode));
int verror __P((char *fmt, va_list argp));
int error __P((char *fmt, ...));
-int fatal __P((int status, char *fmt, ...));
+void fatal __P((int status, char *fmt, ...));
int Perror __P((char *s));
int newmode __P((unsigned nm));
int _abs __P((void));
int what __P((void));
int where __P((register om));
-int main(argc, argv) int argc; char *argv[]; {
- register char *p, *flags;
+void main(argc, argv) int argc; char *argv[]; {
+ register char *p;
register int i;
struct stat st;
}
#ifdef __STDC__
-int fatal(int status, char *fmt, ...)
+void fatal(int status, char *fmt, ...)
#else
-int fatal(status, fmt, va_alist) int status; char *fmt; va_dcl
+void fatal(status, fmt, va_alist) int status; char *fmt; va_dcl
#endif
{
va_list argp;
int newmode(nm) unsigned nm; {
register o, m, b;
- int savem;
ms = modestring;
- savem = nm;
m = _abs();
if (*ms == '\0')
return (m);
#endif
#endif
-int main __P((int argc, char **argv));
+void main __P((int argc, char **argv));
long otoi __P((char *s));
-int main(argc, argv) int argc; char **argv; {
+void main(argc, argv) int argc; char **argv; {
register c1, c2;
char *arg;
#endif
#endif
-int main __P((int argc, char **argv));
+void main __P((int argc, char **argv));
int copy __P((char *from, char *to));
int rcopy __P((char *from, char *to));
int setimes __P((char *path, struct stat *statp));
-int Perror __P((char *s));
+void Perror __P((char *s));
-int main(argc, argv) int argc; char **argv; {
+void main(argc, argv) int argc; char **argv; {
struct stat stb;
int rc, i;
return (0);
}
-int Perror(s) char *s; {
+void Perror(s) char *s; {
fprintf(stderr, "cp: ");
perror(s);
/*#include <netdb.h> net.h*/
#include <netinet/in.h>
#include <netns/ns.h>
-#include <protocols/timed.h>
+/*#include <protocols/timed.h> see TSPTYPES below*/
/*#include <stdio.h> net.h*/
/*#include <strings.h> gen.h*/
#include <sys.h>
#endif
#endif
-int main __P((int argc, char *argv[]));
+void main __P((int argc, char *argv[]));
int gtime __P((void));
int gp __P((int dfault));
int settime __P((struct timeval tv));
-int main(argc, argv) int argc; char *argv[]; {
+void main(argc, argv) int argc; char *argv[]; {
register char *tzn;
openlog("date", LOG_ODELAY, LOG_AUTH);
/*#include <netinet/in.h>*/
/*#include <netdb.h>*/
#define TSPTYPES
-/*#include <protocols/timed.h>*/
+#include <protocols/timed.h>
#define WAITACK 2 /* seconds */
#define WAITDATEACK 5 /* seconds */
msg.tsp_time.tv_sec = htonl((u_long)tv.tv_sec);
msg.tsp_time.tv_usec = htonl((u_long)tv.tv_usec);
length = sizeof (struct sockaddr_in);
- if (connect(s, &dest, length) < 0) {
+ if (connect(s, (struct sockaddr *)&dest, length) < 0) {
perror("date: connect");
goto bad;
}
}
if (found > 0 && FD_ISSET(s, &ready)) {
length = sizeof (struct sockaddr_in);
- if (recvfrom(s, (char *)&msg, sizeof (struct tsp), 0, &from,
+ if (recvfrom(s, (char *)&msg, sizeof (struct tsp), 0, (struct sockaddr *)&from,
&length) < 0) {
if (errno != ECONNREFUSED)
perror("date: recvfrom");
#endif
#endif
-int main __P((int argc, char **argv));
-int flsh __P((void));
+void main __P((int argc, char **argv));
+void flsh __P((void));
int match __P((char *s));
int number __P((int big));
-int cnull __P((int cc));
-int null __P((int c));
-int ascii __P((int cc));
-int unblock __P((int cc));
-int ebcdic __P((int cc));
-int ibm __P((int cc));
-int block __P((int cc));
-int term __P((void));
-int stats __P((void));
-
-int main(argc, argv) int argc; char **argv; {
- int (*conv)();
+void cnull __P((int cc));
+void null __P((int c));
+void ascii __P((int cc));
+void unblock __P((int cc));
+void ebcdic __P((int cc));
+void ibm __P((int cc));
+void block __P((int cc));
+void term __P((void));
+void stats __P((void));
+
+void main(argc, argv) int argc; char **argv; {
+ void (*conv)();
register char *ip;
register c;
- int ebcdic(), ibm(), ascii(), null(), cnull(), term(), block(), unblock();
+ void ebcdic(), ibm(), ascii(), null(), cnull(), term(), block(), unblock();
int a;
conv = null;
op = obuf;
if (signal(SIGINT, SIG_IGN) != SIG_IGN)
- signal(SIGINT, term);
+ signal(SIGINT, (void (*) __P((int sig)))term);
while(skip) {
read(ibf, ibuf, ibs);
skip--;
goto loop;
}
-int flsh() {
+void flsh() {
register c;
if(obc) {
/* never gets here */
}
-int cnull(cc) int cc; {
+void cnull(cc) int cc; {
register c;
c = cc;
null(c);
}
-int null(c) int c; {
+void null(c) int c; {
*op = c;
op++;
}
}
-int ascii(cc) int cc; {
+void ascii(cc) int cc; {
register c;
c = etoa[cc] & 0377;
}
}
-int unblock(cc) int cc; {
+void unblock(cc) int cc; {
register c;
c = cc & 0377;
}
}
-int ebcdic(cc) int cc; {
+void ebcdic(cc) int cc; {
register c;
c = cc;
null(c);
}
-int ibm(cc) int cc; {
+void ibm(cc) int cc; {
register c;
c = cc;
null(c);
}
-int block(cc) int cc; {
+void block(cc) int cc; {
register c;
c = cc;
null(c);
}
-int term() {
+void term() {
stats();
exit(0);
}
-int stats() {
+void stats() {
fprintf(stderr,"%u+%u records in\n", nifr, nipr);
fprintf(stderr,"%u+%u records out\n", nofr, nopr);
#endif
#endif
-int main __P((int argc, char **argv));
-int dfree __P((char *file, int infsent));
+void main __P((int argc, char **argv));
+void dfree __P((char *file, int infsent));
int bread __P((daddr_t bno, char *buf, int cnt));
char *mpath __P((char *file));
int eq __P((char *f1, char *f2));
-int main(argc, argv) int argc; char **argv; {
+void main(argc, argv) int argc; char **argv; {
int i;
while (argc > 1 && argv[1][0]=='-') {
dfree(argv[i], 0);
}
-int dfree(file, infsent) char *file; int infsent; {
+void dfree(file, infsent) char *file; int infsent; {
long totalblks, availblks, avail, free, used;
struct stat stbuf;
struct fstab *fsp;
#endif
#endif
-int main __P((int argc, char **argv));
+void main __P((int argc, char **argv));
long descend __P((char *base, char *name));
-int main(argc, argv) int argc; char **argv; {
+void main(argc, argv) int argc; char **argv; {
long blocks = 0;
register char *np;
int pid;
#endif
/*#include <stdio.h>*/
-int main(argc, argv) int argc; char *argv[]; {
+void main(argc, argv) int argc; char *argv[]; {
register int i, nflg;
nflg = 0;
#define ESIZE 128
#define GBSIZE 256
#define NBRA 5
+#ifndef EOF
#define EOF -1
+#endif
#define KSIZE 9
#define CBRA 1
#define READ 0
#define WRITE 1
+#ifndef __P
+#ifdef __STDC__
+#define __P(args) args
+#else
+#define __P(args) ()
+#endif
+#endif
+
int peekc;
int lastc;
char savedfile[FNSIZE];
int io;
int pflag;
/*long lseek();*/
-int (*oldhup)();
-int (*oldquit)();
+void (*oldhup) __P((int sig));
+void (*oldquit) __P((int sig));
int vflag = 1;
int xflag;
int xtflag;
/*char *realloc();*/
jmp_buf savej;
-#ifndef __P
-#ifdef __STDC__
-#define __P(args) args
-#else
-#define __P(args) ()
-#endif
-#endif
-
-int main __P((int argc, char **argv));
-int commands __P((void));
+void main __P((int argc, char **argv));
+void commands __P((void));
int *address __P((void));
-int setdot __P((void));
-int setall __P((void));
-int setnoaddr __P((void));
-int nonzero __P((void));
-int newline __P((void));
-int filename __P((int comm));
-int exfile __P((void));
-int onintr __P((void));
-int onhup __P((void));
-int error __P((char *s));
+void setdot __P((void));
+void setall __P((void));
+void setnoaddr __P((void));
+void nonzero __P((void));
+void newline __P((void));
+void filename __P((int comm));
+void exfile __P((void));
+void onintr __P((void));
+void onhup __P((void));
+void error __P((char *s));
int getchr __P((void));
int gettty __P((void));
int getfile __P((void));
-int putfile __P((void));
+void putfile __P((void));
int append __P((int (*f)(void), int *a));
-int callunix __P((void));
-int quit __P((void));
-int delete __P((void));
-int rdelete __P((int *ad1, int *ad2));
-int gdelete __P((void));
+void callunix __P((void));
+void quit __P((void));
+void delete __P((void));
+void rdelete __P((int *ad1, int *ad2));
+void gdelete __P((void));
char *getline __P((int tl));
int putline __P((void));
char *getblock __P((int atl, int iof));
-int blkio __P((int b, char *buf, int (*iofcn)(void)));
-int init __P((void));
-int global __P((int k));
-int join __P((void));
-int substitute __P((int inglob));
+void blkio __P((int b, char *buf, int (*iofcn)(int fd, void *buf, int size)));
+void init __P((void));
+void global __P((int k));
+void join __P((void));
+void substitute __P((int inglob));
int compsub __P((void));
int getsub __P((void));
-int dosub __P((void));
+void dosub __P((void));
char *place __P((register char *sp, register char *l1, register char *l2));
-int move __P((int cflag));
-int reverse __P((register int *a1, register int *a2));
+void move __P((int cflag));
+void reverse __P((register int *a1, register int *a2));
int getcopy __P((void));
-int compile __P((int aeof));
+void compile __P((int aeof));
int execute __P((int gf, int *addr));
int advance __P((register char *lp, register char *ep));
int backref __P((register i, register char *lp));
int cclass __P((register char *set, int c, int af));
-int putd __P((void));
-int puts __P((register char *sp));
-int putchr __P((int ac));
-int crblock __P((char *permp, char *buf, int nchar, long startn));
+void putd __P((void));
+void _puts __P((register char *sp));
+void putchr __P((int ac));
+void crblock __P((char *permp, char *buf, int nchar, long startn));
int getkey __P((void));
int crinit __P((char *keyp, char *permp));
-int makekey __P((char *a, char *b));
+void makekey __P((char *a, char *b));
-int main(argc, argv) int argc; char **argv; {
+void main(argc, argv) int argc; char **argv; {
register char *p1, *p2;
- extern int onintr(), quit(), onhup();
- int (*oldintr)();
+ extern void onintr(), quit(), onhup();
+ void (*oldintr) __P((int sig));
oldquit = signal(SIGQUIT, SIG_IGN);
oldhup = signal(SIGHUP, SIG_IGN);
oldintr = signal(SIGINT, SIG_IGN);
- if ((int)signal(SIGTERM, SIG_IGN) == 0)
- signal(SIGTERM, quit);
+ if (signal(SIGTERM, SIG_IGN) == SIG_DFL)
+ signal(SIGTERM, (void (*) __P((int sig)))quit);
argv++;
while (argc > 1 && **argv=='-') {
switch((*argv)[1]) {
zero = (int *)malloc(nlall*sizeof(int));
tfname = mktemp("/tmp/eXXXXX");
init();
- if (((int)oldintr&01) == 0)
- signal(SIGINT, onintr);
- if (((int)oldhup&01) == 0)
- signal(SIGHUP, onhup);
+ if (oldintr != SIG_IGN) /* ((int)oldintr&01) == 0) ??? */
+ signal(SIGINT, (void (*) __P((int sig)))onintr);
+ if (oldhup != SIG_IGN) /* (((int)oldhup&01) == 0) ??? */
+ signal(SIGHUP, (void (*) __P((int sig)))onhup);
setjmp(savej);
commands();
quit();
}
-int commands() {
+void commands() {
int getfile(), gettty();
register *a1, c;
case 'f':
setnoaddr();
filename(c);
- puts(savedfile);
+ _puts(savedfile);
continue;
case 'g':
nonzero();
a1 = addr1;
do {
- puts(getline(*a1++));
+ _puts(getline(*a1++));
} while (a1 <= addr2);
dot = addr2;
listf = 0;
setnoaddr();
newline();
xflag = 1;
- puts("Entering encrypting mode!");
+ _puts("Entering encrypting mode!");
getkey();
kflag = crinit(key, perm);
continue;
}
}
-int setdot() {
+void setdot() {
if (addr2 == 0)
addr1 = addr2 = dot;
if (addr1 > addr2)
error(Q);
}
-int setall() {
+void setall() {
if (addr2==0) {
addr1 = zero+1;
addr2 = dol;
setdot();
}
-int setnoaddr() {
+void setnoaddr() {
if (addr2)
error(Q);
}
-int nonzero() {
+void nonzero() {
if (addr1<=zero || addr2>dol)
error(Q);
}
-int newline() {
+void newline() {
register c;
if ((c = getchr()) == '\n')
error(Q);
}
-int filename(comm) int comm; {
+void filename(comm) int comm; {
register char *p1, *p2;
register c;
}
}
-int exfile() {
+void exfile() {
close(io);
io = -1;
if (vflag) {
}
}
-int onintr() {
- signal(SIGINT, onintr);
+void onintr() {
+ signal(SIGINT, (void (*) __P((int sig)))onintr);
putchr('\n');
lastc = '\n';
error(Q);
}
-int onhup() {
+void onhup() {
signal(SIGINT, SIG_IGN);
signal(SIGHUP, SIG_IGN);
if (dol > zero) {
quit();
}
-int error(s) char *s; {
+void error(s) char *s; {
register c;
wrapp = 0;
listf = 0;
putchr('?');
- puts(s);
+ _puts(s);
count = 0;
lseek(0, (long)0, 2);
pflag = 0;
return(0);
}
-int putfile() {
+void putfile() {
int *a1, n;
register char *fp, *lp;
register nib;
if(kflag)
crblock(perm, genbuf, n, count-n);
if(write(io, genbuf, n) != n) {
- puts(WRERR);
+ _puts(WRERR);
error(Q);
}
nib = 511;
if(kflag)
crblock(perm, genbuf, n, count-n);
if(write(io, genbuf, n) != n) {
- puts(WRERR);
+ _puts(WRERR);
error(Q);
}
}
return(nline);
}
-int callunix() {
- register (*savint)(), pid, rpid;
+void callunix() {
+ void (*savint) __P((int sig));
+ register pid, rpid;
int retcode;
setnoaddr();
while ((rpid = wait(&retcode)) != pid && rpid != -1)
;
signal(SIGINT, savint);
- puts("!");
+ _puts("!");
}
-int quit() {
+void quit() {
if (vflag && fchange && dol!=zero) {
fchange = 0;
error(Q);
exit(0);
}
-int delete() {
+void delete() {
setdot();
newline();
nonzero();
rdelete(addr1, addr2);
}
-int rdelete(ad1, ad2) int *ad1; int *ad2; {
+void rdelete(ad1, ad2) int *ad1; int *ad2; {
register *a1, *a2, *a3;
a1 = ad1;
fchange = 1;
}
-int gdelete() {
+void gdelete() {
register *a1, *a2, *a3;
a3 = dol;
return(obuff+off);
}
-int blkio(b, buf, iofcn) int b; char *buf; int (*iofcn)(); {
+void blkio(b, buf, iofcn) int b; char *buf; int (*iofcn) __P((int fd, void *buf, int size)); {
lseek(tfile, (long)b<<9, 0);
if ((*iofcn)(tfile, buf, 512) != 512) {
error(T);
}
}
-int init() {
+void init() {
register *markp;
close(tfile);
dot = dol = zero;
}
-int global(k) int k; {
+void global(k) int k; {
register char *gp;
register c;
register int *a1;
}
}
-int join() {
+void join() {
register char *gp, *lp;
register *a1;
dot = addr1;
}
-int substitute(inglob) int inglob; {
+void substitute(inglob) int inglob; {
register *markp, *a1, nl;
int gsubf;
int getsub();
return(0);
}
-int dosub() {
+void dosub() {
register char *lp, *sp, *rp;
int c;
return(sp);
}
-int move(cflag) int cflag; {
+void move(cflag) int cflag; {
register int *adt, *ad1, *ad2;
int getcopy();
fchange = 1;
}
-int reverse(a1, a2) register int *a1; register int *a2; {
+void reverse(a1, a2) register int *a1; register int *a2; {
register int t;
for (;;) {
return(0);
}
-int compile(aeof) int aeof; {
+void compile(aeof) int aeof; {
register eof, c;
register char *ep;
char *lastep;
return(!af);
}
-int putd() {
+void putd() {
register r;
r = count%10;
putchr(r + '0');
}
-int puts(sp) register char *sp; {
+void _puts(sp) register char *sp; {
col = 0;
while (*sp)
putchr(*sp++);
char line[70];
char *linp = line;
-int putchr(ac) int ac; {
+void putchr(ac) int ac; {
register char *lp;
register c;
}
linp = lp;
}
-int crblock(permp, buf, nchar, startn) char *permp; char *buf; int nchar; long startn; {
+void crblock(permp, buf, nchar, startn) char *permp; char *buf; int nchar; long startn; {
register char *p1;
int n1;
int n2;
int getkey() {
struct sgttyb b;
int save;
- int (*sig)();
+ void (*sig) __P((int sig));
register char *p;
register c;
save = b.sg_flags;
b.sg_flags &= ~ECHO;
stty(0, &b);
- puts("Key:");
+ _puts("Key:");
p = key;
while(((c=getchr()) != EOF) && (c!='\n')) {
if(p < &key[KSIZE])
return(1);
}
-int makekey(a, b) char *a; char *b; {
+void makekey(a, b) char *a; char *b; {
register int i;
long t;
char temp[KSIZE + 1];
#include <ctype.h>
#include <stdio.h>
#include <sys/errno.h>
-#include <sys/ttychars.h>
#if defined(DOSCCS) && !defined(lint)
static char sccsid[] = "@(#)grep.c 4.6 (Berkeley) 5/14/84";
#endif
#endif
-int main __P((int argc, char **argv));
-int compile __P((char *astr));
-int execute __P((char *file));
+void main __P((int argc, char **argv));
+void compile __P((char *astr));
+void execute __P((char *file));
int advance __P((register char *lp, register char *ep));
-int succeed __P((char *f));
+void succeed __P((char *f));
int ecmp __P((char *a, char *b, int count));
-int errexit __P((char *s, char *f));
+void errexit __P((char *s, char *f));
-int main(argc, argv) int argc; char **argv; {
+void main(argc, argv) int argc; char **argv; {
while (--argc > 0 && (++argv)[0][0]=='-')
switch (argv[0][1]) {
exit(retcode != 0 ? retcode : nsucc == 0);
}
-int compile(astr) char *astr; {
+void compile(astr) char *astr; {
register c;
register char *ep, *sp;
char *cstart;
errexit("grep: RE error\n", (char *)NULL);
}
-int execute(file) char *file; {
+void execute(file) char *file; {
register char *p1, *p2;
register c;
}
}
-int succeed(f) char *f; {
+void succeed(f) char *f; {
nsucc = 1;
if (sflag)
return;
return(1);
}
-int errexit(s, f) char *s; char *f; {
+void errexit(s, f) char *s; char *f; {
fprintf(stderr, s, f);
exit(2);
}
/*extern unsigned long inet_addr();*/
/*extern long gethostid();*/
-int main(argc, argv) int argc; char **argv; {
+void main(argc, argv) int argc; char **argv; {
register char *id;
u_long addr;
long hostid;
char hostname[32];
extern int errno;
-int main(argc, argv) int argc; char *argv[]; {
+void main(argc, argv) int argc; char *argv[]; {
int myerrno;
argc--;
int li_used;
int li_used2;
} libseg[NSEG] = {
- li_init, 0, 0,
+ {li_init, 0, 0}
}, *clibseg = libseg;
/*
struct local *lo_first;
int lo_used;
} locseg[NSEG] = {
- lhinit, 0
+ {lhinit, 0}
}, *clocseg;
/*
#endif
#endif
-int main __P((int argc, char **argv));
+void main __P((int argc, char **argv));
int htoi __P((register char *p));
-int delexit __P((void));
-int endload __P((int argc, char **argv));
-int load1arg __P((register char *cp));
+void delexit __P((void));
+void endload __P((int argc, char **argv));
+void load1arg __P((register char *cp));
int step __P((off_t nloc));
-int nextlibp __P((off_t val));
+void nextlibp __P((off_t val));
int ldrand __P((void));
int load1 __P((int libflg, off_t loc));
-int middle __P((void));
-int fixspec __P((struct nlist *sym, long offset));
-int ldrsym __P((register struct nlist *sp, long val, int type));
-int setupout __P((void));
-int outb __P((register struct biobuf **bp, int inc, int bufsize));
-int load2arg __P((char *acp));
-int load2 __P((long loc));
-int tracesym __P((void));
-int load2td __P((long creloc, int position, struct biobuf *b1, struct biobuf *b2));
-int finishout __P((void));
-int mkfsym __P((char *s));
-int getarhdr __P((void));
-int mget __P((register char *loc, int n, register STREAM *sp));
-int symwrite __P((struct nlist *sp, struct biobuf *bp));
-int dseek __P((register STREAM *sp, long loc, long s));
+void middle __P((void));
+void fixspec __P((struct nlist *sym, long offset));
+void ldrsym __P((register struct nlist *sp, long val, int type));
+void setupout __P((void));
+void outb __P((register struct biobuf **bp, int inc, int bufsize));
+void load2arg __P((char *acp));
+void load2 __P((long loc));
+void tracesym __P((void));
+void load2td __P((long creloc, int position, struct biobuf *b1, struct biobuf *b2));
+void finishout __P((void));
+void mkfsym __P((char *s));
+void getarhdr __P((void));
+void mget __P((void *_loc, int n, register STREAM *sp));
+void symwrite __P((struct nlist *sp, struct biobuf *bp));
+void dseek __P((register STREAM *sp, long loc, long s));
char get __P((STREAM *asp));
int getfile __P((char *acp));
int libopen __P((char *name, int oflags));
struct nlist **lookup __P((void));
-int symfree __P((struct nlist *saved));
+void symfree __P((struct nlist *saved));
struct nlist **slookup __P((char *s));
int enter __P((register struct nlist **hp));
int symx __P((struct nlist *sp));
-int symreloc __P((void));
-int error __P((int n, char *s));
-int readhdr __P((off_t loc));
-int round __P((int v, u_long r));
+void symreloc __P((void));
+void error __P((int n, char *s));
+void readhdr __P((off_t loc));
+int _round __P((int v, u_long r));
char *savestr __P((register char *cp));
-int bopen __P((register struct biobuf *bp, int off, int bufsize));
-int bwrite __P((register char *p, register int cnt, register struct biobuf *bp));
-int bflush __P((void));
-int bflush1 __P((register struct biobuf *bp));
-int bflushc __P((register struct biobuf *bp, int c));
-int bseek __P((register struct biobuf *bp, register off_t off));
-
-int main(argc, argv) int argc; char **argv; {
- register int c, i;
+void bopen __P((register struct biobuf *bp, int off, int bufsize));
+void bwrite __P((void *_p, register int cnt, register struct biobuf *bp));
+void bflush __P((void));
+void bflush1 __P((register struct biobuf *bp));
+void bflushc __P((register struct biobuf *bp, int c));
+void bseek __P((register struct biobuf *bp, register off_t off));
+
+void main(argc, argv) int argc; char **argv; {
+ register int c, i;
int num;
register char *ap, **p;
char save;
if (signal(SIGINT, SIG_IGN) != SIG_IGN) {
- signal(SIGINT, delexit);
- signal(SIGTERM, delexit);
+ signal(SIGINT, (void (*) __P((int sig)))delexit);
+ signal(SIGTERM, (void (*) __P((int sig)))delexit);
}
if (argc == 1)
exit(4);
case 'l':
save = ap[--i];
ap[i]='-';
- load1arg(&ap[i]);
+ load1arg(&ap[i]);
ap[i]=save;
goto next;
case 'M':
return (n);
}
-int delexit() {
+void delexit() {
struct stat stbuf;
long size;
char c = 0;
* appropriately filled with zeros.
*/
fstat(biofd, &stbuf);
- size = round(stbuf.st_size, pagesize);
+ size = _round(stbuf.st_size, pagesize);
if (!rflag && size > stbuf.st_size) {
lseek(biofd, size - 1, 0);
if (write(biofd, &c, 1) != 1)
exit (delarg);
}
-int endload(argc, argv) int argc; char **argv; {
+void endload(argc, argv) int argc; char **argv; {
register int c, i;
long dnum;
register char *ap, **p;
case 'L':
goto next;
case 'l':
- ap[--i]='-';
+ ap[--i]='-';
load2arg(&ap[i]);
goto next;
}
/*
* Scan file to find defined symbols.
*/
-int load1arg(cp) register char *cp; {
+void load1arg(cp) register char *cp; {
register struct ranlib *tp;
off_t nloc;
int kind;
nloc = SARMAG;
while (step(nloc))
nloc += sizeof(archdr) +
- round(atol(archdr.ar_size), sizeof (short));
+ _round(atol(archdr.ar_size), sizeof (short));
break;
/*
case 2:
nloc = SARMAG + sizeof (archdr);
dseek(&text, nloc, sizeof (tnum));
- mget((char *)&tnum, sizeof (tnum), &text);
+ mget(&tnum, sizeof (tnum), &text);
nloc += sizeof (tnum);
tab = (struct ranlib *)malloc(tnum);
if (tab == 0)
error(1, "ran out of memory (toc)");
dseek(&text, nloc, tnum);
- mget((char *)tab, tnum, &text);
+ mget(tab, tnum, &text);
nloc += tnum;
tnum /= sizeof (struct ranlib);
dseek(&text, nloc, sizeof (ssiz));
- mget((char *)&ssiz, sizeof (ssiz), &text);
+ mget(&ssiz, sizeof (ssiz), &text);
nloc += sizeof (ssiz);
tabstr = (char *)malloc(ssiz);
if (tabstr == 0)
error(1, "ran out of memory (tocstr)");
dseek(&text, nloc, ssiz);
- mget((char *)tabstr, ssiz, &text);
+ mget(tabstr, ssiz, &text);
for (tp = &tab[tnum]; --tp >= tab;) {
if (tp->ran_un.ran_strx < 0 ||
tp->ran_un.ran_strx >= ssiz)
nloc = SARMAG;
do
nloc += sizeof(archdr) +
- round(atol(archdr.ar_size), sizeof(short));
+ _round(atol(archdr.ar_size), sizeof(short));
while (step(nloc));
break;
}
* Recording -1 marks the end of files from an archive.
* The liblist data structure is dynamically extended here.
*/
-int nextlibp(val) off_t val; {
+void nextlibp(val) off_t val; {
if (clibseg->li_used == NROUT) {
if (++clibseg == &libseg[NSEG])
error(1, "no space for string table");
mget(curstr+sizeof(off_t), size-sizeof(off_t), &reloc);
while (text.size > 0) {
- mget((char *)&cursym, sizeof(struct nlist), &text);
+ mget(&cursym, sizeof(struct nlist), &text);
if (cursym.n_un.n_strx) {
if (cursym.n_un.n_strx<sizeof(size) ||
cursym.n_un.n_strx>=size)
}
if (libflg==0 || ndef) {
tsize += filhdr.a_text;
- dsize += round(filhdr.a_data, sizeof (long));
- bsize += round(filhdr.a_bss, sizeof (long));
+ dsize += _round(filhdr.a_data, sizeof (long));
+ bsize += _round(filhdr.a_bss, sizeof (long));
ssize += nlocal;
trsize += filhdr.a_trsize;
drsize += filhdr.a_drsize;
return(0);
}
-int middle() {
+void middle() {
register struct nlist *sp;
long csize, t, corigin, ocsize;
int nund, rnd;
csize = 0;
if (!Aflag)
addsym = symseg[0].sy_first;
- database = round(tsize+textbase,
+ database = _round(tsize+textbase,
(nflag||zflag? pagesize : sizeof (long)));
database += hsize;
if (dflag || rflag==0) {
rnd = sizeof (long);
else
rnd = sizeof (short);
- csize = round(csize, rnd);
+ csize = _round(csize, rnd);
sp->n_value = csize;
sp->n_type = N_EXT+N_COMM;
ocsize = csize;
/*
* Now set symbols to their final value
*/
- csize = round(csize, sizeof (long));
+ csize = _round(csize, sizeof (long));
torigin = textbase;
dorigin = database;
corigin = dorigin + dsize;
}
}
-int fixspec(sym, offset) struct nlist *sym; long offset; {
+void fixspec(sym, offset) struct nlist *sym; long offset; {
if(symx(sym) < symx(addsym) && sym!=0)
sym->n_value += offset;
}
-int ldrsym(sp, val, type) register struct nlist *sp; long val; int type; {
+void ldrsym(sp, val, type) register struct nlist *sp; long val; int type; {
if (sp == 0)
return;
off_t wroff;
struct biobuf toutb;
-int setupout() {
+void setupout() {
int bss;
struct stat stbuf;
extern char *sys_errlist[];
}
filhdr.a_magic = nflag ? NMAGIC : (zflag ? ZMAGIC : OMAGIC);
filhdr.a_text = nflag ? tsize :
- round(tsize, zflag ? pagesize : sizeof (long));
- filhdr.a_data = zflag ? round(dsize, pagesize) : dsize;
+ _round(tsize, zflag ? pagesize : sizeof (long));
+ filhdr.a_data = zflag ? _round(dsize, pagesize) : dsize;
bss = bsize - (filhdr.a_data - dsize);
if (bss < 0)
bss = 0;
filhdr.a_drsize = (rflag ? drsize:0);
tout = &toutb;
bopen(tout, 0, stbuf.st_blksize);
- bwrite((char *)&filhdr, sizeof (filhdr), tout);
+ bwrite(&filhdr, sizeof (filhdr), tout);
if (zflag)
bseek(tout, pagesize);
wroff = N_TXTOFF(filhdr) + filhdr.a_text;
}
}
-int outb(bp, inc, bufsize) register struct biobuf **bp; int inc; int bufsize; {
+void outb(bp, inc, bufsize) register struct biobuf **bp; int inc; int bufsize; {
*bp = (struct biobuf *)malloc(sizeof (struct biobuf));
if (*bp == 0)
wroff += inc;
}
-int load2arg(acp) char *acp; {
+void load2arg(acp) char *acp; {
register char *cp;
off_t loc;
close(infil);
}
-int load2(loc) long loc; {
+void load2(loc) long loc; {
int size;
register struct nlist *sp;
register struct local *lp;
filhdr.a_trsize+filhdr.a_drsize, filhdr.a_syms);
while (text.size > 0) {
symno++;
- mget((char *)&cursym, sizeof(struct nlist), &text);
+ mget(&cursym, sizeof(struct nlist), &text);
if (cursym.n_un.n_strx) {
if (cursym.n_un.n_strx<sizeof(size) ||
cursym.n_un.n_strx>=size)
filhdr.a_data++;
}
torigin += filhdr.a_text;
- dorigin += round(filhdr.a_data, sizeof (long));
- borigin += round(filhdr.a_bss, sizeof (long));
+ dorigin += _round(filhdr.a_data, sizeof (long));
+ borigin += _round(filhdr.a_bss, sizeof (long));
free(curstr);
}
int ty_value;
char *ty_name;
} tynames[] = {
- N_UNDF, "undefined",
- N_ABS, "absolute",
- N_TEXT, "text",
- N_DATA, "data",
- N_BSS, "bss",
- N_COMM, "common",
- 0, 0,
+ {N_UNDF, "undefined"},
+ {N_ABS, "absolute"},
+ {N_TEXT, "text"},
+ {N_DATA, "data"},
+ {N_BSS, "bss"},
+ {N_COMM, "common"},
+ {0, 0}
};
-int tracesym() {
+void tracesym() {
register struct tynames *tp;
if (cursym.n_type & N_STAB)
* If we are saving the relocation information, then we increase
* each relocation datum address by our base position in the new segment.
*/
-int load2td(creloc, position, b1, b2) long creloc; int position; struct biobuf *b1; struct biobuf *b2; {
+void load2td(creloc, position, b1, b2) long creloc; int position; struct biobuf *b1; struct biobuf *b2; {
register struct nlist *sp;
register struct local *lp;
long tw;
codep = (char *)malloc(codesz);
if (relp == 0 || codep == 0)
error(1, "out of memory (load2td)");
- mget((char *)relp, relsz, &reloc);
+ mget(relp, relsz, &reloc);
rpend = &relp[relsz / sizeof (struct relocation_info)];
mget(codep, codesz, &text);
for (rp = relp; rp < rpend; rp++) {
free(codep);
}
-int finishout() {
+void finishout() {
register int i;
int nsymt;
delexit();
}
-int mkfsym(s) char *s; {
+void mkfsym(s) char *s; {
if (sflag || xflag)
return;
symwrite(&cursym, sout);
}
-int getarhdr() {
+void getarhdr() {
register char *cp;
- mget((char *)&archdr, sizeof archdr, &text);
+ mget(&archdr, sizeof archdr, &text);
for (cp=archdr.ar_name; cp<&archdr.ar_name[sizeof(archdr.ar_name)];)
if (*cp++ == ' ') {
cp[-1] = 0;
}
}
-int mget(loc, n, sp) register char *loc; int n; register STREAM *sp; {
+void mget(_loc, n, sp) void *_loc; int n; register STREAM *sp; {
+#define loc (*(char **)&_loc)
register char *p;
register int take;
*loc++ = get(sp);
--n;
goto top;
+#undef loc
}
-int symwrite(sp, bp) struct nlist *sp; struct biobuf *bp; {
+void symwrite(sp, bp) struct nlist *sp; struct biobuf *bp; {
register int len;
register char *str;
sp->n_un.n_name = str;
}
-int dseek(sp, loc, s) register STREAM *sp; long loc; long s; {
+void dseek(sp, loc, s) register STREAM *sp; long loc; long s; {
register PAGE *p;
register b, o;
int n;
dseek(&text, 0L, SARMAG);
if (text.size <= 0)
error(1, "premature EOF");
- mget((char *)arcmag, SARMAG, &text);
+ mget(arcmag, SARMAG, &text);
arcmag[SARMAG] = 0;
if (strcmp(arcmag, ARMAG))
return (0);
}
error(1, "symbol table overflow");
/*NOTREACHED*/
+#ifdef __GNUC__
+ return 0;
+#endif
}
-int symfree(saved) struct nlist *saved; {
+void symfree(saved) struct nlist *saved; {
register struct symseg *gp;
register struct nlist *sp;
return ((gp - symseg) * NSYM + sp - gp->sy_first);
error(1, "symx botch");
/*NOTREACHED*/
+#ifdef __GNUC__
+ return -1;
+#endif
}
-int symreloc() {
+void symreloc() {
if(funding) return;
switch (cursym.n_type & 017) {
}
}
-int error(n, s) int n; char *s; {
+void error(n, s) int n; char *s; {
if (errlev==0)
printf("ld:");
errlev = 2;
}
-int readhdr(loc) off_t loc; {
+void readhdr(loc) off_t loc; {
dseek(&text, loc, (long)sizeof(filhdr));
- mget((short *)&filhdr, sizeof(filhdr), &text);
+ mget(&filhdr, sizeof(filhdr), &text);
if (N_BADMAG(filhdr)) {
if (filhdr.a_magic == OARMAG)
error(1, "old archive");
if (filhdr.a_text&01 || filhdr.a_data&01)
error(1, "text/data size odd");
if (filhdr.a_magic == NMAGIC || filhdr.a_magic == ZMAGIC) {
- cdrel = -round(filhdr.a_text, pagesize);
+ cdrel = -_round(filhdr.a_text, pagesize);
cbrel = cdrel - filhdr.a_data;
} else if (filhdr.a_magic == OMAGIC) {
cdrel = -filhdr.a_text;
error(1, "bad format");
}
-int round(v, r) int v; u_long r; {
+int _round(v, r) int v; u_long r; {
r--;
v += r;
return (cp);
}
-int bopen(bp, off, bufsize) register struct biobuf *bp; int off; int bufsize; {
+void bopen(bp, off, bufsize) register struct biobuf *bp; int off; int bufsize; {
bp->b_ptr = bp->b_buf = malloc(bufsize);
if (bp->b_ptr == (char *)0)
int bwrerror;
-int bwrite(p, cnt, bp) register char *p; register int cnt; register struct biobuf *bp; {
+void bwrite(_p, cnt, bp) void *_p; register int cnt; register struct biobuf *bp; {
+#define p (*(char **)&_p)
register int put;
register char *to;
}
bflush1(bp);
goto top;
+#undef p
}
-int bflush() {
+void bflush() {
register struct biobuf *bp;
if (bwrerror)
bflush1(bp);
}
-int bflush1(bp) register struct biobuf *bp; {
+void bflush1(bp) register struct biobuf *bp; {
register int cnt = bp->b_ptr - bp->b_buf;
if (cnt == 0)
bp->b_nleft = bp->b_bufsize;
}
-int bflushc(bp, c) register struct biobuf *bp; int c; {
+void bflushc(bp, c) register struct biobuf *bp; int c; {
bflush1(bp);
bputc(c, bp);
}
-int bseek(bp, off) register struct biobuf *bp; register off_t off; {
+void bseek(bp, off) register struct biobuf *bp; register off_t off; {
bflush1(bp);
bp->b_nleft = bp->b_bufsize - (off % bp->b_bufsize);
#endif
#endif
-int main __P((int argc, register char **argv));
+void main __P((int argc, register char **argv));
int linkit __P((char *from, char *to));
-int main(argc, argv) int argc; register char **argv; {
+void main(argc, argv) int argc; register char **argv; {
register int i, r;
argc--, argv++;
-again:
if (argc && strcmp(argv[0], "-f") == 0) {
fflag++;
argv++;
#endif
#endif
-int main __P((int argc, char *argv[]));
-int getloginname __P((register struct utmp *up));
-int timedout __P((void));
-int catch __P((void));
+void main __P((int argc, char *argv[]));
+void getloginname __P((register struct utmp *up));
+void timedout __P((void));
+void catch __P((void));
int rootterm __P((char *tty));
-int showmotd __P((void));
+void showmotd __P((void));
char *stypeof __P((char *ttyid));
int doremotelogin __P((char *host));
-int getstr __P((char *buf, int cnt, char *err));
-int doremoteterm __P((char *term, struct sgttyb *tp));
-int setenv __P((char *var, char *value, int clobber));
+void getstr __P((char *buf, int cnt, char *err));
+void doremoteterm __P((char *term, struct sgttyb *tp));
+void setenv __P((char *var, char *value, int clobber));
int tty_gid __P((int default_gid));
-int main(argc, argv) int argc; char *argv[]; {
+void main(argc, argv) int argc; char *argv[]; {
register char *namep;
int pflag = 0, hflag = 0, t, f, c;
int invalid, quietlog;
int ldisc = 0, zero = 0, i;
char **envnew;
- signal(SIGALRM, timedout);
+ signal(SIGALRM, (void (*) __P((int sig)))timedout);
alarm(timeout);
signal(SIGQUIT, SIG_IGN);
signal(SIGINT, SIG_IGN);
exit(0);
}
-int getloginname(up) register struct utmp *up; {
+void getloginname(up) register struct utmp *up; {
register char *namep;
char c;
pwd = &nouser;
}
-int timedout() {
+void timedout() {
printf("Login timed out after %d seconds\n", timeout);
exit(0);
}
int stopmotd;
-int catch() {
+void catch() {
signal(SIGINT, SIG_IGN);
stopmotd++;
return (0);
}
-int showmotd() {
+void showmotd() {
FILE *mf;
register c;
- signal(SIGINT, catch);
+ signal(SIGINT, (void (*) __P((int sig)))catch);
if ((mf = fopen("/etc/motd", "r")) != NULL) {
while ((c = getc(mf)) != EOF && stopmotd == 0)
putchar(c);
return(ruserok(host, (pwd->pw_uid == 0), rusername, lusername));
}
-int getstr(buf, cnt, err) char *buf; int cnt; char *err; {
+void getstr(buf, cnt, err) char *buf; int cnt; char *err; {
char c;
do {
"600", "1200", "1800", "2400", "4800", "9600", "19200", "38400" };
#define NSPEEDS (sizeof (speeds) / sizeof (speeds[0]))
-int doremoteterm(term, tp) char *term; struct sgttyb *tp; {
+void doremoteterm(term, tp) char *term; struct sgttyb *tp; {
register char *cp = index(term, '/'), **cpp;
char *speed;
* This procedure assumes the memory for the first level of environ
* was allocated using malloc.
*/
-int setenv(var, value, clobber) char *var; char *value; int clobber; {
+void setenv(var, value, clobber) char *var; char *value; int clobber; {
extern char **environ;
int index = 0;
int varlen = strlen(var);
#endif
#endif
-int main __P((int argc, char *argv[]));
-int formatd __P((char *name, int title));
+void main __P((int argc, char *argv[]));
+void formatd __P((char *name, int title));
int getdir __P((char *dir, struct afile **pfp0, struct afile **pfplast));
struct afile *gstat __P((register struct afile *fp, char *file, int statarg, int *pnb));
-int formatf __P((struct afile *fp0, struct afile *fplast));
+void formatf __P((struct afile *fp0, struct afile *fplast));
int fcmp __P((register struct afile *f1, register struct afile *f2));
char *cat __P((char *dir, char *file));
char *savestr __P((char *str));
char *getname __P((int uid));
char *getgroup __P((int gid));
-int main(argc, argv) int argc; char *argv[]; {
+void main(argc, argv) int argc; char *argv[]; {
int i;
struct afile *fp0, *fplast;
register struct afile *fp;
argv++;
}
fplast = fp;
- qsort(fp0, fplast - fp0, sizeof (struct afile), fcmp);
+ qsort(fp0, fplast - fp0, sizeof (struct afile), (int (*) __P((void *p0, void *p1)))fcmp);
if (dflg) {
formatf(fp0, fplast);
exit(0);
exit(0);
}
-int formatd(name, title) char *name; int title; {
+void formatd(name, title) char *name; int title; {
register struct afile *fp;
register struct subdirs *dp;
struct afile *dfp0, *dfplast;
if (dfp0 == 0)
return;
if (fflg == 0)
- qsort(dfp0, dfplast - dfp0, sizeof (struct afile), fcmp);
+ qsort(dfp0, dfplast - dfp0, sizeof (struct afile), (int (*) __P((void *p0, void *p1)))fcmp);
if (title)
printf("%s:\n", name);
if (lflg || sflg)
return (fp);
}
-int formatf(fp0, fplast) struct afile *fp0; struct afile *fplast; {
+void formatf(fp0, fplast) struct afile *fp0; struct afile *fplast; {
register struct afile *fp;
int width = 0, w, nentry = fplast - fp0;
int i, j, columns, lines;
#endif
#endif
-int main __P((int argc, char **argv));
-int setsig __P((int i, int (*f)(void)));
+void main __P((int argc, char **argv));
+void setsig __P((int i, void (*f)(int sig)));
int any __P((register int c, register char *str));
-int printmail __P((int argc, char **argv));
-int copyback __P((void));
-int copymt __P((FILE *f1, FILE *f2));
-int copylet __P((int n, FILE *f, int type));
+void printmail __P((int argc, char **argv));
+void copyback __P((void));
+void copymt __P((FILE *f1, FILE *f2));
+void copylet __P((int n, FILE *f, int type));
int isfrom __P((register char *lp));
-int bulkmail __P((int argc, char **argv));
+void bulkmail __P((int argc, char **argv));
int sendrmt __P((int n, char *name));
-int usage __P((void));
-int notifybiff __P((char *msg));
+void usage __P((void));
+void notifybiff __P((char *msg));
int sendmail __P((int n, char *name, char *fromaddr));
-int delex __P((int i));
-int done __P((void));
-int cat __P((char *to, char *from1, char *from2));
+void delex __P((int i));
+void done __P((void));
+void cat __P((char *to, char *from1, char *from2));
char *getarg __P((register char *s, register char *p));
int safefile __P((char *f));
-int panic __P((char *msg, ...));
+void panic __P((char *msg, ...));
-int main(argc, argv) int argc; char **argv; {
+void main(argc, argv) int argc; char **argv; {
register i;
struct passwd *pwent;
if (setjmp(sjbuf))
done();
for (i=SIGHUP; i<=SIGTERM; i++)
- setsig(i, delex);
+ setsig(i, (void (*) __P((int sig)))delex);
i = mkstemp(lettmp);
tmpf = fdopen(i, "r+w");
if (i < 0 || tmpf == NULL)
done();
}
-int setsig(i, f) int i; int (*f)(); {
+void setsig(i, f) int i; void (*f) __P((int sig)); {
if (signal(i, SIG_IGN) != SIG_IGN)
signal(i, f);
}
return(0);
}
-int printmail(argc, argv) int argc; char **argv; {
+void printmail(argc, argv) int argc; char **argv; {
int flg, i, j, print;
char *p, *getarg();
+#ifdef notdef
struct stat statb;
+#endif
setuid(getuid());
cat(mailfile, maildir, my_name);
}
/* copy temp or whatever back to /usr/spool/mail */
-int copyback() {
+void copyback() {
register i, c;
int fd, new = 0, oldmask;
struct stat stbuf;
}
/* copy mail (f1) to temp (f2) */
-int copymt(f1, f2) FILE *f1; FILE *f2; {
+void copymt(f1, f2) FILE *f1; FILE *f2; {
long nextadr;
nlet = nextadr = 0;
let[nlet].adr = nextadr; /* last plus 1 */
}
-int copylet(n, f, type) int n; FILE *f; int type; {
+void copylet(n, f, type) int n; FILE *f; int type; {
int ch;
long k;
char hostname[32];
return(1);
}
-int bulkmail(argc, argv) int argc; char **argv; {
+void bulkmail(argc, argv) int argc; char **argv; {
char truename[100];
int first;
register char *cp;
printf("null name\n");
return(0);
}
+#ifdef notdef
skip:
+#endif
if ((pid = fork()) == -1) {
fprintf(stderr, "mail: can't create proc for remote\n");
return(0);
exit(pclose(rmf) != 0);
}
-int usage() {
+void usage() {
fprintf(stderr, "Usage: mail [ -f ] people . . .\n");
error = EX_USAGE;
/*#include <netinet/in.h>*/
/*#include <netdb.h>*/
-int notifybiff(msg) char *msg; {
+void notifybiff(msg) char *msg; {
static struct sockaddr_in addr;
static int f = -1;
if (addr.sin_family) {
if (f < 0)
f = socket(AF_INET, SOCK_DGRAM, 0);
- sendto(f, msg, strlen(msg)+1, 0, &addr, sizeof (addr));
+ sendto(f, msg, strlen(msg)+1, 0, (struct sockaddr *)&addr, sizeof (addr));
}
}
int sendmail(n, name, fromaddr) int n; char *name; char *fromaddr; {
char file[256];
- int mask, fd;
+ int fd;
struct passwd *pw;
#ifdef notdef
struct stat statb;
return(1);
}
-int delex(i) int i; {
- setsig(i, delex);
+void delex(i) int i; {
+ setsig(i, (void (*) __P((int sig)))delex);
putc('\n', stderr);
if (delflg)
longjmp(sjbuf, 1);
done();
}
-int done() {
+void done() {
unlink(lettmp);
exit(error);
}
-int cat(to, from1, from2) char *to; char *from1; char *from2; {
+void cat(to, from1, from2) char *to; char *from1; char *from2; {
register char *cp, *dp;
cp = to;
}
#ifdef __STDC__
-int panic(char *msg, ...)
+void panic(char *msg, ...)
#else
-int panic(msg, va_alist) char *msg; va_dcl
+void panic(msg, va_alist) char *msg; va_dcl
#endif
{
va_list argp;
fprintf(stderr, "mail: ");
- _va_start(argp, fmt);
+ _va_start(argp, msg);
vfprintf(stderr, msg, argp);
va_end(argp);
fprintf(stderr, "\n");
*/
/*#include <stdio.h>*/
-int main(argc, argv) int argc; char *argv[]; {
+void main(argc, argv) int argc; char *argv[]; {
int errors = 0;
if (argc < 2) {
#endif
#endif
-int main __P((int argc, char **argv));
-int status __P((register struct mtget *bp));
-int printreg __P((char *s, int v, register char *bits));
+void main __P((int argc, char **argv));
+void status __P((register struct mtget *bp));
+void printreg __P((char *s, int v, register char *bits));
-int main(argc, argv) int argc; char **argv; {
- char line[80], *getenv();
+void main(argc, argv) int argc; char **argv; {
+ char *getenv();
register char *cp;
register struct commands *comp;
/*
* Interpret the status buffer returned
*/
-int status(bp) register struct mtget *bp; {
+void status(bp) register struct mtget *bp; {
register struct tape_desc *mt;
for (mt = tapes; mt->t_type; mt++)
/*
* Print a register a la the %b format of the kernel's printf
*/
-int printreg(s, v, bits) char *s; int v; register char *bits; {
+void printreg(s, v, bits) char *s; int v; register char *bits; {
register int i, any = 0;
register char c;
int move __P((char *source, char *target));
int query __P((char *prompt, ...));
char *dname __P((register char *name));
-int error __P((char *fmt, ...));
-int Perror __P((char *s));
-int Perror2 __P((char *s1, char *s2));
+void error __P((char *fmt, ...));
+void Perror __P((char *s));
+void Perror2 __P((char *s1, char *s2));
int main(argc, argv) int argc; register char *argv[]; {
register i, r;
va_list argp;
register int i, c;
- _va_start(argp, fmt);
+ _va_start(argp, prompt);
vfprintf(stderr, prompt, argp);
va_end(argp);
i = c = getchar();
}
#ifdef __STDC__
-int error(char *fmt, ...)
+void error(char *fmt, ...)
#else
-int error(fmt, va_alist) char *fmt; va_dcl
+void error(fmt, va_alist) char *fmt; va_dcl
#endif
{
va_list argp;
fprintf(stderr, "\n");
}
-int Perror(s) char *s; {
+void Perror(s) char *s; {
char buf[MAXPATHLEN + 10];
sprintf(buf, "mv: %s", s);
perror(buf);
}
-int Perror2(s1, s2) char *s1; char *s2; {
+void Perror2(s1, s2) char *s1; char *s2; {
char buf[MAXPATHLEN + 20];
sprintf(buf, "mv: %s: %s", s1, s2);
/*#include <sys/time.h>*/
/*#include <sys/resource.h>*/
-int main(argc, argv) int argc; char *argv[]; {
+void main(argc, argv) int argc; char *argv[]; {
int nicarg = 10;
if (argc > 1 && argv[1][0] == '-') {
#endif
#endif
-int main __P((int argc, char **argv));
-int namelist __P((void));
-int psyms __P((register struct nlist *symp, int nsyms));
+void main __P((int argc, char **argv));
+void namelist __P((void));
+void psyms __P((register struct nlist *symp, int nsyms));
int compare __P((struct nlist *p1, struct nlist *p2));
int nextel __P((FILE *af));
-int error __P((int n, char *s));
+void error __P((int n, char *s));
char *stab __P((int val));
-int main(argc, argv) int argc; char **argv; {
+void main(argc, argv) int argc; char **argv; {
if (--argc>0 && argv[1][0]=='-' && argv[1][1]!=0) {
argv++;
exit(errs);
}
-int namelist() {
+void namelist() {
register int j;
archive = 0;
}
do {
off_t o;
- register i, n, c;
+ register i, n;
struct nlist *symp = NULL;
struct nlist sym;
struct stat stb;
else
symp[j].n_un.n_name = "";
if (pflg==0)
- qsort(symp, i, sizeof(struct nlist), compare);
+ qsort(symp, i, sizeof(struct nlist), (int (*) __P((void *p0, void *p1)))compare);
if ((archive || narg>1) && oflg==0)
printf("\n%s:\n", SELECT);
psyms(symp, i);
fclose(fi);
}
-int psyms(symp, nsyms) register struct nlist *symp; int nsyms; {
+void psyms(symp, nsyms) register struct nlist *symp; int nsyms; {
register int n, c;
for (n=0; n<nsyms; n++) {
printf(" %c ", c);
}
printf("%s\n", symp[n].n_un.n_name);
-l1: ;
}
}
int compare(p1, p2) struct nlist *p1; struct nlist *p2; {
- register i;
-
if (nflg) {
if (p1->n_value > p2->n_value)
return(rflg);
return(1);
}
-int error(n, s) int n; char *s; {
+void error(n, s) int n; char *s; {
fprintf(stderr, "nm: %s:", *xargv);
if (archive) {
fprintf(stderr, "(%s)", archdr.ar_name);
int st_value;
char *st_name;
} stabnames[] ={
- N_GSYM, "GSYM",
- N_FNAME, "FNAME",
- N_FUN, "FUN",
- N_STSYM, "STSYM",
- N_LCSYM, "LCSYM",
- N_RSYM, "RSYM",
- N_SLINE, "SLINE",
- N_SSYM, "SSYM",
- N_SO, "SO",
- N_LSYM, "LSYM",
- N_SOL, "SOL",
- N_PSYM, "PSYM",
- N_ENTRY, "ENTRY",
- N_LBRAC, "LBRAC",
- N_RBRAC, "RBRAC",
- N_BCOMM, "BCOMM",
- N_ECOMM, "ECOMM",
- N_ECOML, "ECOML",
- N_LENG, "LENG",
- N_PC, "PC",
- 0, 0
+ {N_GSYM, "GSYM"},
+ {N_FNAME, "FNAME"},
+ {N_FUN, "FUN"},
+ {N_STSYM, "STSYM"},
+ {N_LCSYM, "LCSYM"},
+ {N_RSYM, "RSYM"},
+ {N_SLINE, "SLINE"},
+ {N_SSYM, "SSYM"},
+ {N_SO, "SO"},
+ {N_LSYM, "LSYM"},
+ {N_SOL, "SOL"},
+ {N_PSYM, "PSYM"},
+ {N_ENTRY, "ENTRY"},
+ {N_LBRAC, "LBRAC"},
+ {N_RBRAC, "RBRAC"},
+ {N_BCOMM, "BCOMM"},
+ {N_ECOMM, "ECOMM"},
+ {N_ECOML, "ECOML"},
+ {N_LENG, "LENG"},
+ {N_PC, "PC"},
+ {0, 0}
};
char *stab(val) int val; {
char *df_fmt; /* output string format */
} *conv_vec[32]; /* vector of conversions to be done */
+#ifndef __P
+#ifdef __STDC__
+#define __P(args) args
+#else
+#define __P(args) ()
+#endif
+#endif
+
+void main __P((int argc, char **argv));
+void put_addr __P((long a, long l, int c));
+void line __P((int n));
+int s_put __P((short *n, struct dfmt *d));
+int us_put __P((unsigned short *n, struct dfmt *d));
+int l_put __P((long *n, struct dfmt *d));
+int d_put __P((double *f, struct dfmt *d));
+int f_put __P((float *f, struct dfmt *d));
+int a_put __P((char *cc, struct dfmt *d));
+int parity __P((int word));
+char *underline __P((char *s));
+int b_put __P((char *b, struct dfmt *d));
+int c_put __P((char *cc, struct dfmt *d));
+char *scvt __P((int c, struct dfmt *d));
+int st_put __P((char *cc, struct dfmt *d));
+void put_sbuf __P((int c, struct dfmt *d));
+void pr_sbuf __P((struct dfmt *d, int end));
+char *icvt __P((long value, int radix, int _signed, int ndigits));
+long get_addr __P((register char *s));
+void offset __P((long a));
+void dumbseek __P((FILE *s, long offset));
+int canseek __P((FILE *f));
+
struct dfmt ascii = { 3, sizeof (char), 10, 0, PADDR, a_put, 0};
struct dfmt byte = { 3, sizeof (char), 8, UNSIGNED, PADDR, b_put, 0};
struct dfmt cchar = { 3, sizeof (char), 8, UNSIGNED, PADDR, c_put, 0};
/* 370 */ 0, 0, 0, 0, 0, 0, 0, 0,
};
-#ifndef __P
-#ifdef __STDC__
-#define __P(args) args
-#else
-#define __P(args) ()
-#endif
-#endif
-
-int main __P((int argc, char **argv));
-int put_addr __P((long a, long l, int c));
-int line __P((int n));
-int s_put __P((short *n, struct dfmt *d));
-int us_put __P((unsigned short *n, struct dfmt *d));
-int l_put __P((long *n, struct dfmt *d));
-int d_put __P((double *f, struct dfmt *d));
-int f_put __P((float *f, struct dfmt *d));
-int a_put __P((char *cc, struct dfmt *d));
-int parity __P((int word));
-char *underline __P((char *s));
-int b_put __P((char *b, struct dfmt *d));
-int c_put __P((char *cc, struct dfmt *d));
-char *scvt __P((int c, struct dfmt *d));
-int st_put __P((char *cc, struct dfmt *d));
-int put_sbuf __P((int c, struct dfmt *d));
-int pr_sbuf __P((struct dfmt *d, int end));
-char *icvt __P((long value, int radix, int _signed, int ndigits));
-long get_addr __P((register char *s));
-int offset __P((long a));
-int dumbseek __P((FILE *s, long offset));
-int canseek __P((FILE *f));
-
-int main(argc, argv) int argc; char **argv; {
+void main(argc, argv) int argc; char **argv; {
register char *p;
register char *l;
register n, same;
}
}
-int put_addr(a, l, c) long a; long l; int c; {
+void put_addr(a, l, c) long a; long l; int c; {
fputs(icvt(a, addr_base, UNSIGNED, 7), stdout);
if (l >= 0)
printf(" (%s)", icvt(l, addr_base, UNSIGNED, 7));
putchar(c);
}
-int line(n) int n; {
+void line(n) int n; {
register i, first;
register struct dfmt *c;
register struct dfmt **cv = conv_vec;
return(1);
}
-int put_sbuf(c, d) int c; struct dfmt *d; {
+void put_sbuf(c, d) int c; struct dfmt *d; {
*str_ptr++ = c;
if (str_ptr >= (str_buf + SBUFSIZE)) {
pr_sbuf(d, NO);
}
}
-int pr_sbuf(d, end) struct dfmt *d; int end; {
+void pr_sbuf(d, end) struct dfmt *d; int end; {
register char *p = str_buf;
if (str_mode == S_EMPTY
return(a);
}
-int offset(a) long a; {
+void offset(a) long a; {
if (canseek(stdin)) {
/*
* in case we're accessing a raw disk,
dumbseek(stdin, a);
}
-int dumbseek(s, offset) FILE *s; long offset; {
+void dumbseek(s, offset) FILE *s; long offset; {
char buf[BUFSIZ];
int n;
int nr;
static char sccsid[] = "@(#)pagesize.c 5.1 (Berkeley) 4/30/85";
#endif
-int main() {
+void main() {
printf("%d\n", getpagesize());
}
#endif
#endif
-int main __P((int argc, char *argv[]));
-int unlimit __P((int lim));
-int replace __P((DBM *dp, struct passwd *pwd));
+void main __P((int argc, char *argv[]));
+void unlimit __P((int lim));
+void replace __P((DBM *dp, struct passwd *pwd));
char *getnewpasswd __P((register struct passwd *pwd, int u));
char *getloginshell __P((struct passwd *pwd, int u, char *arg));
char *getfingerinfo __P((struct passwd *pwd));
int illegal_input __P((char *input_str));
-int remove_hyphens __P((char *str));
+void remove_hyphens __P((char *str));
int not_all_digits __P((char *str));
int illegal_building __P((register char *str));
struct default_values *get_defaults __P((char *str));
int special_case __P((char *str, char *default_str));
-int main(argc, argv) int argc; char *argv[]; {
+void main(argc, argv) int argc; char *argv[]; {
struct passwd *pwd;
char *cp, *uname, *progname;
int fd, u, dochfn, dochsh, err;
exit(0);
}
-int unlimit(lim) int lim; {
+void unlimit(lim) int lim; {
struct rlimit rlim;
rlim.rlim_cur = rlim.rlim_max = RLIM_INFINITY;
/*
* Replace the password entry in the dbm data base with pwd.
*/
-int replace(dp, pwd) DBM *dp; struct passwd *pwd; {
+void replace(dp, pwd) DBM *dp; struct passwd *pwd; {
datum key, content;
register char *cp, *tp;
char buf[BUFSIZ];
return;
cp = buf;
+#ifdef __STDC__
+#define COMPACT(e) tp = pwd->pw_ ## e; while (*cp++ = *tp++);
+#else
#define COMPACT(e) tp = pwd->pw_/**/e; while (*cp++ = *tp++);
+#endif
+#ifdef X_
+/* without this adjustment it tries to access x_pwd->x_pw_x_name etc */
+ COMPACT(nox_name);
+ COMPACT(nox_passwd);
+#else
COMPACT(name);
COMPACT(passwd);
+#endif
bcopy((char *)&pwd->pw_uid, cp, sizeof (int));
cp += sizeof (int);
bcopy((char *)&pwd->pw_gid, cp, sizeof (int));
cp += sizeof (int);
bcopy((char *)&pwd->pw_quota, cp, sizeof (int));
cp += sizeof (int);
+#ifdef X_
+/* without this adjustment it tries to access x_pwd->x_pw_x_name etc */
+ COMPACT(nox_comment);
+ COMPACT(nox_gecos);
+ COMPACT(nox_dir);
+ COMPACT(nox_shell);
+#else
COMPACT(comment);
COMPACT(gecos);
COMPACT(dir);
COMPACT(shell);
+#endif
content.dptr = buf;
content.dsize = cp - buf;
key.dptr = pwd->pw_name;
/*
* Removes '-'s from the input string.
*/
-int remove_hyphens(str) char *str; {
+void remove_hyphens(str) char *str; {
char *hyphen;
while ((hyphen = index(str, '-')) != NULL)
#endif
#endif
-int main __P((int argc, char **argv));
-int done __P((void));
+void main __P((int argc, char **argv));
+void done __P((void));
int numeric __P((char *str));
-int onintr __P((void));
-int fixtty __P((void));
-int print __P((char *fp, char **argp));
-int mopen __P((char **ap));
-int putpage __P((void));
-int nexbuf __P((void));
+void onintr __P((void));
+void fixtty __P((void));
+void print __P((char *fp, char **argp));
+void mopen __P((char **ap));
+void putpage __P((void));
+void nexbuf __P((void));
int tpgetc __P((int ai));
int pgetc __P((int i));
-int put __P((int ac));
+void put __P((int ac));
-int main(argc, argv) int argc; char **argv; {
+void main(argc, argv) int argc; char **argv; {
int nfdone;
- int onintr();
+ void onintr();
setbuf(stdout, obuf);
if (signal(SIGINT, SIG_IGN) != SIG_IGN)
- signal(SIGINT, onintr);
+ signal(SIGINT, (void (*) __P((int sig)))onintr);
lastarg = &argv[argc-1];
fixtty();
for (nfdone=0; argc>1; argc--) {
done();
}
-int done() {
+void done() {
if (tty)
chmod(tty, mode);
return(1);
}
-int onintr() {
+void onintr() {
if (tty)
chmod(tty, mode);
_exit(1);
}
-int fixtty() {
+void fixtty() {
struct stat sbuf;
tty = ttyname(1);
}
/* print -- print file */
-int print(fp, argp) char *fp; char **argp; {
+void print(fp, argp) char *fp; char **argp; {
struct stat sbuf;
register sncol;
register char *sheader;
header = sheader;
}
-int mopen(ap) char **ap; {
+void mopen(ap) char **ap; {
register char **p, *p1;
p = ap;
}
}
-int putpage() {
+void putpage() {
register int lastcol, i, c;
int j;
}
}
-int nexbuf() {
+void nexbuf() {
register int n;
register char *rbufp;
icol++;
return(c);
}
-int put(ac) int ac; {
+void put(ac) int ac; {
register int ns, c;
c = ac;
+#include <nox_math.h>
+
/*#include <a.out.h> gen.h*/
/*#include <ctype.h> gen.h*/
#include <gen.h>
#endif
#endif
-int main __P((int argc, char **argv));
+void main __P((int argc, char **argv));
int _getw __P((unsigned long loc));
-int klseek __P((int fd, long loc, int off));
-int writepsdb __P((char *unixname));
+void klseek __P((int fd, long loc, int off));
+void writepsdb __P((char *unixname));
int readpsdb __P((char *unixname));
-int openfiles __P((int argc, char **argv));
-int getkvars __P((int argc, char **argv));
-int getvchans __P((void));
-int printhdr __P((void));
-int cantread __P((char *what, char *fromwhat));
-int getdev __P((void));
-int maybetty __P((void));
+void openfiles __P((int argc, char **argv));
+void getkvars __P((int argc, char **argv));
+void getvchans __P((void));
+void printhdr __P((void));
+void cantread __P((char *what, char *fromwhat));
+void getdev __P((void));
+void maybetty __P((void));
char *gettty __P((void));
-int save __P((void));
+void save __P((void));
double pmem __P((register struct asav *ap));
double pcpu __P((void));
int getu __P((void));
char *getcmd __P((void));
-int lpr __P((struct savcom *sp));
-int ptty __P((char *tp));
-int ptime __P((struct asav *ap));
-int upr __P((struct savcom *sp));
-int vpr __P((struct savcom *sp));
-int spr __P((struct savcom *sp));
+void lpr __P((struct savcom *sp));
+void ptty __P((char *tp));
+void ptime __P((struct asav *ap));
+void upr __P((struct savcom *sp));
+void vpr __P((struct savcom *sp));
+void spr __P((struct savcom *sp));
char *state __P((register struct asav *ap));
-int vstodb __P((register int vsbase, int vssize, struct dmap *dmp, register struct dblock *dbp, int rev));
-int panic __P((char *cp));
+void vstodb __P((register int vsbase, int vssize, struct dmap *dmp, register struct dblock *dbp, int rev));
+void panic __P((char *cp));
int min __P((int a, int b));
int pscomp __P((struct savcom *s1, struct savcom *s2));
int vsize __P((struct savcom *sp));
char *getname __P((int uid));
char *savestr __P((char *cp));
off_t vtophys __P((long loc));
-int init_nlist __P((void));
+void init_nlist __P((void));
int nlist __P((char *name, struct nlist *list));
-int addchan __P((char *name, caddr_t caddr));
+void addchan __P((char *name, caddr_t caddr));
char *getchan __P((register caddr_t chan));
int wchancomp __P((struct wchan *w1, struct wchan *w2));
-int main(argc, argv) int argc; char **argv; {
+void main(argc, argv) int argc; char **argv; {
register int i, j;
register char *ap;
int uid;
width = twidth - cmdstart - 2;
if (width < 0)
width = 0;
- qsort((char *) savcom, npr, sizeof(savcom[0]), pscomp);
+ qsort((char *) savcom, npr, sizeof(savcom[0]), (int (*) __P((void *p0, void *p1)))pscomp);
for (i=0; i<npr; i++) {
register struct savcom *sp = &savcom[i];
if (lflg)
return (word);
}
-int klseek(fd, loc, off) int fd; long loc; int off; {
+void klseek(fd, loc, off) int fd; long loc; int off; {
if (kflg) {
if ((loc = vtophys(loc)) == -1)
return;
*/
char thisversion[4] = "V2"; /* length must remain 4 */
-int writepsdb(unixname) char *unixname; {
+void writepsdb(unixname) char *unixname; {
register FILE *fp;
struct lttys *lt;
struct stat stb;
}
int readpsdb(unixname) char *unixname; {
- register i;
register FILE *fp;
char unamebuf[BUFSIZ];
char *p = unamebuf;
return(0);
}
-int openfiles(argc, argv) int argc; char **argv; {
+void openfiles(argc, argv) int argc; char **argv; {
kmemf = "/dev/kmem";
if (kflg)
}
}
-int getkvars(argc, argv) int argc; char **argv; {
+void getkvars(argc, argv) int argc; char **argv; {
int faildb = 0; /* true if psdatabase init failed */
- int i;
nlistf = argc > 1 ? argv[1] : "/vmunix";
if (Uflg) {
/*
* get the valloc'ed kernel variables for symbolic wait channels
*/
-int getvchans() {
+void getvchans() {
int i, tmp;
if (nflg)
addv(X_BUF);
addv(X_CMAP);
addv(X_BUFFERS);
- qsort(wchanhd, nchans, sizeof (struct wchan), wchancomp);
+ qsort(wchanhd, nchans, sizeof (struct wchan), (int (*) __P((void *p0, void *p1)))wchancomp);
for (i = 0; i < NWCINDEX; i++) {
tmp = i * nchans;
wchan_index[i] = wchanhd[tmp / NWCINDEX].wc_caddr;
}
#undef addv
}
-int printhdr() {
+void printhdr() {
char *hdr;
if (sflg+lflg+vflg+uflg > 1) {
(void) fflush(stdout);
}
-int cantread(what, fromwhat) char *what; char *fromwhat; {
+void cantread(what, fromwhat) char *what; char *fromwhat; {
fprintf(stderr, "ps: error reading %s from %s\n", what, fromwhat);
}
struct direct *dbuf;
int dialbase;
-int getdev() {
+void getdev() {
register DIR *df;
struct ttys *t;
struct lttys *lt;
* know that r(hp|up|mt) are unlikely as are different mem's,
* floppy, null, tty, etc.
*/
-int maybetty() {
+void maybetty() {
register char *cp = dbuf->d_name;
static struct lttys *dp;
struct lttys *olddp;
return (p);
}
-int save() {
+void save() {
register struct savcom *sp;
register struct asav *ap;
register char *cp;
return (0.0);
if (rawcpu)
return (100.0 * mproc->p_pctcpu);
- return (100.0 * mproc->p_pctcpu / (1.0 - exp(time * log(ccpu))));
+ return (100.0 * mproc->p_pctcpu / (1.0 - nox_exp(time * nox_log(ccpu))));
}
int getu() {
char *lhdr =
" F UID PID PPID CP PRI NI ADDR SZ RSS %*s STAT TT TIME";
-int lpr(sp) struct savcom *sp; {
+void lpr(sp) struct savcom *sp; {
register struct asav *ap = sp->ap;
register struct lsav *lp = sp->s_un.lp;
ptime(ap);
}
-int ptty(tp) char *tp; {
+void ptty(tp) char *tp; {
printf("%-2.2s", tp);
}
-int ptime(ap) struct asav *ap; {
+void ptime(ap) struct asav *ap; {
printf("%3ld:%02ld", ap->a_cpu / 60, ap->a_cpu % 60);
}
char *uhdr =
"%s PID %%CPU %%MEM SZ RSS TT STAT TIME";
-int upr(sp) struct savcom *sp; {
+void upr(sp) struct savcom *sp; {
register struct asav *ap = sp->ap;
int vmsize, rmsize;
char *vhdr =
" SIZE PID TT STAT TIME SL RE PAGEIN SIZE RSS LIM TSIZ TRS %CPU %MEM"+5;
-int vpr(sp) struct savcom *sp; {
+void vpr(sp) struct savcom *sp; {
register struct vsav *vp = sp->s_un.vp;
register struct asav *ap = sp->ap;
char *shdr =
"SSIZ PID TT STAT TIME";
-int spr(sp) struct savcom *sp; {
+void spr(sp) struct savcom *sp; {
register struct asav *ap = sp->ap;
if (sflg)
* return a physical base/size pair which is the
* (largest) initial, physically contiguous block.
*/
-int vstodb(vsbase, vssize, dmp, dbp, rev) register int vsbase; int vssize; struct dmap *dmp; register struct dblock *dbp; int rev; {
+void vstodb(vsbase, vssize, dmp, dbp, rev) register int vsbase; int vssize; struct dmap *dmp; register struct dblock *dbp; int rev; {
register int blk = dmmin;
register swblk_t *ip = dmp->dm_map;
}
/*ARGSUSED*/
-int panic(cp) char *cp; {
+void panic(cp) char *cp; {
#ifdef DEBUG
printf("%s\n", cp);
* of nlist.h (required since nlist() uses some defines) is to do a
* runtime copy into the nl array -- sigh
*/
-int init_nlist() {
+void init_nlist() {
register struct nlist *np;
register char **namep;
*/
int nlist(name, list) char *name; struct nlist *list; {
register struct nlist *p, *q;
- register char *s1, *s2;
register n, m;
int maxlen, nreq;
FILE *f;
/* if using wchans, add it to the list of channels */
if (!nflg)
addchan(&nambuf[1], (caddr_t) q->n_value);
- for (p = list; p->n_un.n_name && p->n_un.n_name[0]; p++) {
- s1 = p->n_un.n_name;
- s2 = nambuf;
+ for (p = list; p->n_un.n_name && p->n_un.n_name[0]; p++)
if (strcmp(p->n_un.n_name, nambuf) == 0) {
p->n_value = q->n_value;
p->n_type = q->n_type;
--nreq;
break;
}
- }
}
}
-alldone:
fclose(f);
fclose(sf);
return (nreq);
/*
* add the given channel to the channel list
*/
-int addchan(name, caddr) char *name; caddr_t caddr; {
+void addchan(name, caddr) char *name; caddr_t caddr; {
static int left = 0;
register struct wchan *wp;
register char **p;
/*char *getwd();*/
-int main() {
+void main() {
char pathname[MAXPATHLEN + 1];
if (getwd(pathname) == NULL) {
int errs;
/*int lostconn();*/
int errno;
-char *sys_errlist[];
+extern char *sys_errlist[];
int iamremote, targetshouldbedirectory;
int iamrecursive;
int pflag;
#endif
#endif
-int main __P((int argc, char **argv));
-int verifydir __P((char *cp));
+void main __P((int argc, char **argv));
+void verifydir __P((char *cp));
char *colon __P((char *cp));
int okname __P((char *cp0));
int susystem __P((char *s));
-int source __P((int argc, char **argv));
-int rsource __P((char *name, struct stat *statp));
+void source __P((int argc, char **argv));
+void rsource __P((char *name, struct stat *statp));
int response __P((void));
-int lostconn __P((void));
-int sink __P((int argc, char **argv));
+void lostconn __P((void));
+void sink __P((int argc, char **argv));
struct buffer *allocbuf __P((struct buffer *bp, int fd, int blksize));
-int error __P((char *fmt, ...));
+void error __P((char *fmt, ...));
-int main(argc, argv) int argc; char **argv; {
+void main(argc, argv) int argc; char **argv; {
char *targ, *host, *src;
char *suser, *tuser, *thost;
int i;
(void) sprintf(cmd, "rcp%s%s%s",
iamrecursive ? " -r" : "", pflag ? " -p" : "",
targetshouldbedirectory ? " -d" : "");
- (void) signal(SIGPIPE, lostconn);
+ (void) signal(SIGPIPE, (void (*) __P((int sig)))lostconn);
targ = colon(argv[argc - 1]);
if (targ) { /* ... to remote */
*targ++ = 0;
exit(errs);
}
-int verifydir(cp) char *cp; {
+void verifydir(cp) char *cp; {
struct stat stb;
if (stat(cp, &stb) >= 0) {
int susystem(s) char *s; {
int status, pid, w;
- register int (*istat)(), (*qstat)();
+ register void (*istat) __P((int sig)), (*qstat) __P((int sig));
if ((pid = vfork()) == 0) {
(void) setuid(userid);
return (status);
}
-int source(argc, argv) int argc; char **argv; {
+void source(argc, argv) int argc; char **argv; {
char *last, *name;
struct stat stb;
static struct buffer buffer;
/*#include <sys/dir.h>*/
-int rsource(name, statp) char *name; struct stat *statp; {
+void rsource(name, statp) char *name; struct stat *statp; {
DIR *d = opendir(name);
char *last;
struct direct *dp;
/*NOTREACHED*/
}
-int lostconn() {
+void lostconn() {
if (iamremote == 0)
fprintf(stderr, "rcp: lost connection\n");
exit(1);
}
-int sink(argc, argv) int argc; char **argv; {
+void sink(argc, argv) int argc; char **argv; {
off_t i, j;
char *targ, *whopp, *cp;
int of, mode, wrerr, exists, first, count, amt, size;
}
#ifdef __STDC__
-int error(char *fmt, ...)
+void error(char *fmt, ...)
#else
-int error(fmt, va_alist) char *fmt; va_dcl
+void error(fmt, va_alist) char *fmt; va_dcl
#endif
{
char buf[BUFSIZ], *cp = buf;
#endif
#endif
-int main __P((int argc, char *argv[]));
+void main __P((int argc, char *argv[]));
int rm __P((char arg[], int level));
int dotname __P((char *s));
int yes __P((void));
-int append __P((char *name));
+void append __P((char *name));
-int main(argc, argv) int argc; char *argv[]; {
+void main(argc, argv) int argc; char *argv[]; {
register char *arg;
fflg = !isatty(0);
/*
* Append 'name' to 'path'.
*/
-int append(name) char *name; {
+void append(name) char *name; {
register int n;
n = strlen(name);
# define MAILER "/usr/lib/sendmail"
-int main(argc, argv) int argc; char **argv; {
+void main(argc, argv) int argc; char **argv; {
FILE *out; /* output to sendmail */
char lbuf[1024]; /* one line of the message */
char from[512]; /* accumulated path of sender */
*/
/*#include <stdio.h>*/
-int main(argc, argv) int argc; char **argv; {
+void main(argc, argv) int argc; char **argv; {
int errors = 0;
if (argc < 2) {
int header;
-int main(argc, argv) int argc; char **argv; {
+void main(argc, argv) int argc; char **argv; {
struct exec buf;
long sum;
- int gorp,i;
+ int gorp;
int err = 0;
FILE *f;
#endif
#endif
-int main __P((int argc, char *argv[]));
-int strip __P((char *name));
+void main __P((int argc, char *argv[]));
+void strip __P((char *name));
-int main(argc, argv) int argc; char *argv[]; {
+void main(argc, argv) int argc; char *argv[]; {
register i;
pagesize = getpagesize();
exit(status);
}
-int strip(name) char *name; {
+void strip(name) char *name; {
register f;
long size;
char *string;
int speed;
} speeds[] = {
- "0", B0,
- "50", B50,
- "75", B75,
- "110", B110,
- "134", B134,
- "134.5",B134,
- "150", B150,
- "200", B200,
- "300", B300,
- "600", B600,
- "1200", B1200,
- "1800", B1800,
- "2400", B2400,
- "4800", B4800,
- "9600", B9600,
- "exta", EXTA,
- "19200", EXTA,
- "extb", EXTB,
- "38400", EXTB,
- 0,
+ {"0", B0},
+ {"50", B50},
+ {"75", B75},
+ {"110", B110},
+ {"134", B134},
+ {"134.5", B134},
+ {"150", B150},
+ {"200", B200},
+ {"300", B300},
+ {"600", B600},
+ {"1200", B1200},
+ {"1800", B1800},
+ {"2400", B2400},
+ {"4800", B4800},
+ {"9600", B9600},
+ {"exta", EXTA},
+ {"19200", EXTA},
+ {"extb", EXTB},
+ {"38400", EXTB},
+ {0, 0}
};
struct {
char *string;
int lset;
int lreset;
} modes[] = {
- "even", EVENP, 0, 0, 0,
- "-even", 0, EVENP, 0, 0,
- "odd", ODDP, 0, 0, 0,
- "-odd", 0, ODDP, 0, 0,
- "raw", RAW, 0, 0, 0,
- "-raw", 0, RAW, 0, 0,
- "cooked", 0, RAW, 0, 0,
- "-nl", CRMOD, 0, 0, 0,
- "nl", 0, CRMOD, 0, 0,
- "echo", ECHO, 0, 0, 0,
- "-echo", 0, ECHO, 0, 0,
- "LCASE", LCASE, 0, 0, 0,
- "lcase", LCASE, 0, 0, 0,
- "-LCASE", 0, LCASE, 0, 0,
- "-lcase", 0, LCASE, 0, 0,
- "-tabs", XTABS, 0, 0, 0,
- "tabs", 0, XTABS, 0, 0,
- "tandem", TANDEM, 0, 0, 0,
- "-tandem", 0, TANDEM, 0, 0,
- "cbreak", CBREAK, 0, 0, 0,
- "-cbreak", 0, CBREAK, 0, 0,
- "cr0", CR0, CR3, 0, 0,
- "cr1", CR1, CR3, 0, 0,
- "cr2", CR2, CR3, 0, 0,
- "cr3", CR3, CR3, 0, 0,
- "tab0", TAB0, XTABS, 0, 0,
- "tab1", TAB1, XTABS, 0, 0,
- "tab2", TAB2, XTABS, 0, 0,
- "nl0", NL0, NL3, 0, 0,
- "nl1", NL1, NL3, 0, 0,
- "nl2", NL2, NL3, 0, 0,
- "nl3", NL3, NL3, 0, 0,
- "ff0", FF0, FF1, 0, 0,
- "ff1", FF1, FF1, 0, 0,
- "bs0", BS0, BS1, 0, 0,
- "bs1", BS1, BS1, 0, 0,
- "33", CR1, ALLDELAY, 0, 0,
- "tty33", CR1, ALLDELAY, 0, 0,
- "37", FF1+CR2+TAB1+NL1, ALLDELAY, 0, 0,
- "tty37", FF1+CR2+TAB1+NL1, ALLDELAY, 0, 0,
- "05", NL2, ALLDELAY, 0, 0,
- "vt05", NL2, ALLDELAY, 0, 0,
- "tn", CR1, ALLDELAY, 0, 0,
- "tn300", CR1, ALLDELAY, 0, 0,
- "ti", CR2, ALLDELAY, 0, 0,
- "ti700", CR2, ALLDELAY, 0, 0,
- "tek", FF1, ALLDELAY, 0, 0,
- "crtbs", 0, 0, LCRTBS, LPRTERA,
- "-crtbs", 0, 0, 0, LCRTBS,
- "prterase", 0, 0, LPRTERA, LCRTBS+LCRTKIL+LCRTERA,
- "-prterase", 0, 0, 0, LPRTERA,
- "crterase", 0, 0, LCRTERA, LPRTERA,
- "-crterase", 0, 0, 0, LCRTERA,
- "crtkill", 0, 0, LCRTKIL, LPRTERA,
- "-crtkill", 0, 0, 0, LCRTKIL,
- "tilde", 0, 0, LTILDE, 0,
- "-tilde", 0, 0, 0, LTILDE,
- "mdmbuf", 0, 0, LMDMBUF, 0,
- "-mdmbuf", 0, 0, 0, LMDMBUF,
- "litout", 0, 0, LLITOUT, 0,
- "-litout", 0, 0, 0, LLITOUT,
- "pass8", 0, 0, LPASS8, 0,
- "-pass8", 0, 0, 0, LPASS8,
- "tostop", 0, 0, LTOSTOP, 0,
- "-tostop", 0, 0, 0, LTOSTOP,
- "flusho", 0, 0, LFLUSHO, 0,
- "-flusho", 0, 0, 0, LFLUSHO,
- "nohang", 0, 0, LNOHANG, 0,
- "-nohang", 0, 0, 0, LNOHANG,
+ {"even", EVENP, 0, 0, 0},
+ {"-even", 0, EVENP, 0, 0},
+ {"odd", ODDP, 0, 0, 0},
+ {"-odd", 0, ODDP, 0, 0},
+ {"raw", RAW, 0, 0, 0},
+ {"-raw", 0, RAW, 0, 0},
+ {"cooked", 0, RAW, 0, 0},
+ {"-nl", CRMOD, 0, 0, 0},
+ {"nl", 0, CRMOD, 0, 0},
+ {"echo", ECHO, 0, 0, 0},
+ {"-echo", 0, ECHO, 0, 0},
+ {"LCASE", LCASE, 0, 0, 0},
+ {"lcase", LCASE, 0, 0, 0},
+ {"-LCASE", 0, LCASE, 0, 0},
+ {"-lcase", 0, LCASE, 0, 0},
+ {"-tabs", XTABS, 0, 0, 0},
+ {"tabs", 0, XTABS, 0, 0},
+ {"tandem", TANDEM, 0, 0, 0},
+ {"-tandem", 0, TANDEM, 0, 0},
+ {"cbreak", CBREAK, 0, 0, 0},
+ {"-cbreak", 0, CBREAK, 0, 0},
+ {"cr0", CR0, CR3, 0, 0},
+ {"cr1", CR1, CR3, 0, 0},
+ {"cr2", CR2, CR3, 0, 0},
+ {"cr3", CR3, CR3, 0, 0},
+ {"tab0", TAB0, XTABS, 0, 0},
+ {"tab1", TAB1, XTABS, 0, 0},
+ {"tab2", TAB2, XTABS, 0, 0},
+ {"nl0", NL0, NL3, 0, 0},
+ {"nl1", NL1, NL3, 0, 0},
+ {"nl2", NL2, NL3, 0, 0},
+ {"nl3", NL3, NL3, 0, 0},
+ {"ff0", FF0, FF1, 0, 0},
+ {"ff1", FF1, FF1, 0, 0},
+ {"bs0", BS0, BS1, 0, 0},
+ {"bs1", BS1, BS1, 0, 0},
+ {"33", CR1, ALLDELAY, 0, 0},
+ {"tty33", CR1, ALLDELAY, 0, 0},
+ {"37", FF1+CR2+TAB1+NL1, ALLDELAY, 0, 0},
+ {"tty37", FF1+CR2+TAB1+NL1, ALLDELAY, 0, 0},
+ {"05", NL2, ALLDELAY, 0, 0},
+ {"vt05", NL2, ALLDELAY, 0, 0},
+ {"tn", CR1, ALLDELAY, 0, 0},
+ {"tn300", CR1, ALLDELAY, 0, 0},
+ {"ti", CR2, ALLDELAY, 0, 0},
+ {"ti700", CR2, ALLDELAY, 0, 0},
+ {"tek", FF1, ALLDELAY, 0, 0},
+ {"crtbs", 0, 0, LCRTBS, LPRTERA},
+ {"-crtbs", 0, 0, 0, LCRTBS},
+ {"prterase", 0, 0, LPRTERA, LCRTBS+LCRTKIL+LCRTERA},
+ {"-prterase", 0, 0, 0, LPRTERA},
+ {"crterase", 0, 0, LCRTERA, LPRTERA},
+ {"-crterase", 0, 0, 0, LCRTERA},
+ {"crtkill", 0, 0, LCRTKIL, LPRTERA},
+ {"-crtkill", 0, 0, 0, LCRTKIL},
+ {"tilde", 0, 0, LTILDE, 0},
+ {"-tilde", 0, 0, 0, LTILDE},
+ {"mdmbuf", 0, 0, LMDMBUF, 0},
+ {"-mdmbuf", 0, 0, 0, LMDMBUF},
+ {"litout", 0, 0, LLITOUT, 0},
+ {"-litout", 0, 0, 0, LLITOUT},
+ {"pass8", 0, 0, LPASS8, 0},
+ {"-pass8", 0, 0, 0, LPASS8},
+ {"tostop", 0, 0, LTOSTOP, 0},
+ {"-tostop", 0, 0, 0, LTOSTOP},
+ {"flusho", 0, 0, LFLUSHO, 0},
+ {"-flusho", 0, 0, 0, LFLUSHO},
+ {"nohang", 0, 0, LNOHANG, 0},
+ {"-nohang", 0, 0, 0, LNOHANG},
#ifdef notdef
- "etxack", 0, 0, LETXACK, 0,
- "-etxack", 0, 0, 0, LETXACK,
+ {"etxack", 0, 0, LETXACK, 0},
+ {"-etxack", 0, 0, 0, LETXACK},
#endif
- "ctlecho", 0, 0, LCTLECH, 0,
- "-ctlecho", 0, 0, 0, LCTLECH,
- "pendin", 0, 0, LPENDIN, 0,
- "-pendin", 0, 0, 0, LPENDIN,
- "decctlq", 0, 0, LDECCTQ, 0,
- "-decctlq", 0, 0, 0, LDECCTQ,
- "noflsh", 0, 0, LNOFLSH, 0,
- "-noflsh", 0, 0, 0, LNOFLSH,
- 0,
+ {"ctlecho", 0, 0, LCTLECH, 0},
+ {"-ctlecho", 0, 0, 0, LCTLECH},
+ {"pendin", 0, 0, LPENDIN, 0},
+ {"-pendin", 0, 0, 0, LPENDIN},
+ {"decctlq", 0, 0, LDECCTQ, 0},
+ {"-decctlq", 0, 0, 0, LDECCTQ},
+ {"noflsh", 0, 0, LNOFLSH, 0},
+ {"-noflsh", 0, 0, 0, LNOFLSH},
+ {0, 0, 0, 0, 0},
};
struct tchars tc;
char *cp;
char def;
} special[] = {
- "erase", &mode.sg_erase, CERASE,
- "kill", &mode.sg_kill, CKILL,
- "intr", &tc.t_intrc, CINTR,
- "quit", &tc.t_quitc, CQUIT,
- "start", &tc.t_startc, CSTART,
- "stop", &tc.t_stopc, CSTOP,
- "eof", &tc.t_eofc, CEOF,
- "brk", &tc.t_brkc, CBRK,
- "susp", <c.t_suspc, CSUSP,
- "dsusp", <c.t_dsuspc, CDSUSP,
- "rprnt", <c.t_rprntc, CRPRNT,
- "flush", <c.t_flushc, CFLUSH,
- "werase", <c.t_werasc, CWERASE,
- "lnext", <c.t_lnextc, CLNEXT,
- 0
+ {"erase", &mode.sg_erase, CERASE},
+ {"kill", &mode.sg_kill, CKILL},
+ {"intr", &tc.t_intrc, CINTR},
+ {"quit", &tc.t_quitc, CQUIT},
+ {"start", &tc.t_startc, CSTART},
+ {"stop", &tc.t_stopc, CSTOP},
+ {"eof", &tc.t_eofc, CEOF},
+ {"brk", &tc.t_brkc, CBRK},
+ {"susp", <c.t_suspc, CSUSP},
+ {"dsusp", <c.t_dsuspc, CDSUSP},
+ {"rprnt", <c.t_rprntc, CRPRNT},
+ {"flush", <c.t_flushc, CFLUSH},
+ {"werase", <c.t_werasc, CWERASE},
+ {"lnext", <c.t_lnextc, CLNEXT},
+ {0, 0, 0}
};
char *arg;
#endif
#endif
-int main __P((int iargc, char **iargv));
+void main __P((int iargc, char **iargv));
int eq __P((char *string));
-int prmodes __P((int all));
-int pcol __P((int ch1, int ch2));
-int pit __P((unsigned what, char *itsname, char *sep));
-int delay __P((int m, char *s));
-int prspeed __P((char *c, int s));
+void prmodes __P((int all));
+void pcol __P((int ch1, int ch2));
+void pit __P((unsigned what, char *itsname, char *sep));
+void delay __P((int m, char *s));
+void prspeed __P((char *c, int s));
-int main(iargc, iargv) int iargc; char **iargv; {
+void main(iargc, iargv) int iargc; char **iargv; {
int i;
register struct special *sp;
char obuf[BUFSIZ];
return(1);
}
-int prmodes(all) int all; {
+void prmodes(all) int all; {
register m;
int any;
}
}
-int pcol(ch1, ch2) int ch1; int ch2; {
+void pcol(ch1, ch2) int ch1; int ch2; {
int nout = 0;
ch1 &= 0377;
}
}
-int pit(what, itsname, sep) unsigned what; char *itsname; char *sep; {
+void pit(what, itsname, sep) unsigned what; char *itsname; char *sep; {
what &= 0377;
fprintf(stderr, "%s%s", sep, itsname);
fprintf(stderr, "%c", what);
}
-int delay(m, s) int m; char *s; {
+void delay(m, s) int m; char *s; {
if(m)
fprintf(stderr,"%s%d ", s, m);
0,50,75,110,134,150,200,300,600,1200,1800,2400,4800,9600,19200,38400
};
-int prspeed(c, s) char *c; int s; {
+void prspeed(c, s) char *c; int s; {
fprintf(stderr,"%s%d baud", c, speed[s]);
}
#endif
#endif
-int main __P((int argc, char *argv[]));
-int setenv __P((char *ename, char *eval, char *buf));
+void main __P((int argc, char *argv[]));
+void setenv __P((char *ename, char *eval, char *buf));
char *getenv __P((char *ename));
-int main(argc, argv) int argc; char *argv[]; {
+void main(argc, argv) int argc; char *argv[]; {
char *password;
char buf[1000];
- FILE *fp;
register char *p;
openlog("su", LOG_ODELAY, LOG_AUTH);
exit(7);
}
-int setenv(ename, eval, buf) char *ename; char *eval; char *buf; {
+void setenv(ename, eval, buf) char *ename; char *eval; char *buf; {
register char *cp, *dp;
register char **ep = environ;
#if defined(DOSCCS) && !defined(lint)
static char *sccsid = "@(#)sync.c 4.1 (Berkeley) 10/1/80";
#endif
-int main() {
+void main() {
sync();
}
#endif
#endif
-int main __P((int argc, char *argv[]));
-int usage __P((void));
+void main __P((int argc, char *argv[]));
+void usage __P((void));
int openmt __P((char *tape, int writing));
-int dorep __P((char *argv[]));
+void dorep __P((char *argv[]));
int endtape __P((void));
-int getdir __P((void));
-int passtape __P((void));
-int putfile __P((char *longname, char *shortname, char *parent));
-int doxtract __P((char *argv[]));
-int dotable __P((char *argv[]));
-int putempty __P((void));
-int longt __P((register struct stat *st));
-int pmode __P((register struct stat *st));
-int selectbits __P((int *pairp, struct stat *st));
+void getdir __P((void));
+void passtape __P((void));
+void putfile __P((char *longname, char *shortname, char *parent));
+void doxtract __P((char *argv[]));
+void dotable __P((char *argv[]));
+void putempty __P((void));
+void longt __P((register struct stat *st));
+void pmode __P((register struct stat *st));
+void selectbits __P((int *pairp, struct stat *st));
int checkdir __P((register char *name));
-int onintr __P((void));
-int onquit __P((void));
-int onhup __P((void));
+void onintr __P((void));
+void onquit __P((void));
+void onhup __P((void));
int onterm __P((void));
-int tomodes __P((register struct stat *sp));
+void tomodes __P((register struct stat *sp));
int checksum __P((void));
int checkw __P((int c, char *name));
int response __P((void));
int checkf __P((char *name, int mode, int howmuch));
int checkupdate __P((char *arg));
-int done __P((int n));
+void done __P((int n));
int wantit __P((char *argv[]));
int prefix __P((register char *s1, register char *s2));
daddr_t lookup __P((char *s));
int readtape __P((char *buffer));
int readtbuf __P((char **bufpp, int size));
int writetbuf __P((register char *buffer, register int n));
-int backtape __P((void));
-int flushtape __P((void));
-int mterr __P((char *operation, int i, int exitcode));
+void backtape __P((void));
+void flushtape __P((void));
+void mterr __P((char *operation, int i, int exitcode));
int bread __P((int fd, char *buf, int size));
char *getcwd __P((char *buf));
-int getbuf __P((void));
-int dodirtimes __P((union hblock *hp));
-int setimes __P((char *path, time_t mt));
+void getbuf __P((void));
+void dodirtimes __P((union hblock *hp));
+void setimes __P((char *path, time_t mt));
char *getmem __P((int size));
-int main(argc, argv) int argc; char *argv[]; {
+void main(argc, argv) int argc; char *argv[]; {
char *cp;
if (argc < 2)
if (cflag && tfile != NULL)
usage();
if (signal(SIGINT, SIG_IGN) != SIG_IGN)
- (void) signal(SIGINT, onintr);
+ (void) signal(SIGINT, (void (*) __P((int sig)))onintr);
if (signal(SIGHUP, SIG_IGN) != SIG_IGN)
- (void) signal(SIGHUP, onhup);
+ (void) signal(SIGHUP, (void (*) __P((int sig)))onhup);
if (signal(SIGQUIT, SIG_IGN) != SIG_IGN)
- (void) signal(SIGQUIT, onquit);
+ (void) signal(SIGQUIT, (void (*) __P((int sig)))onquit);
#ifdef notdef
if (signal(SIGTERM, SIG_IGN) != SIG_IGN)
- (void) signal(SIGTERM, onterm);
+ (void) signal(SIGTERM, (void (*) __P((int sig)))onterm);
#endif
mt = openmt(usefile, 1);
dorep(argv);
done(0);
}
-int usage() {
+void usage() {
fprintf(stderr,
"tar: usage: tar -{txru}[cvfblmhopwBi] [tapefile] [blocksize] file1 file2...\n");
done(1);
return(mt);
}
-int dorep(argv) char *argv[]; {
+void dorep(argv) char *argv[]; {
register char *cp, *cp2;
char wdir[MAXPATHLEN], tempdir[MAXPATHLEN], *parent;
return (dblock.dbuf.name[0] == '\0');
}
-int getdir() {
+void getdir() {
register struct stat *sp;
int i;
fprintf(tfile, "%s %s\n", dblock.dbuf.name, dblock.dbuf.mtime);
}
-int passtape() {
+void passtape() {
long blocks;
char *bufp;
(void) readtbuf(&bufp, TBLOCK);
}
-int putfile(longname, shortname, parent) char *longname; char *shortname; char *parent; {
+void putfile(longname, shortname, parent) char *longname; char *shortname; char *parent; {
int infile = 0;
long blocks;
char buf[TBLOCK];
register int i;
long l;
char newparent[NAMSIZ+64];
- extern int errno;
int maxread;
int hint; /* amount to write to get "in sync" */
}
}
-int doxtract(argv) char *argv[]; {
+void doxtract(argv) char *argv[]; {
long blocks, bytes;
int ofile, i;
}
}
-int dotable(argv) char *argv[]; {
+void dotable(argv) char *argv[]; {
register int i;
for (;;) {
}
}
-int putempty() {
+void putempty() {
char buf[TBLOCK];
bzero(buf, sizeof (buf));
(void) writetape(buf);
}
-int longt(st) register struct stat *st; {
+void longt(st) register struct stat *st; {
register char *cp;
char *ctime();
int *m[] = { m1, m2, m3, m4, m5, m6, m7, m8, m9};
-int pmode(st) register struct stat *st; {
+void pmode(st) register struct stat *st; {
register int **mp;
for (mp = &m[0]; mp < &m[9];)
selectbits(*mp++, st);
}
-int selectbits(pairp, st) int *pairp; struct stat *st; {
+void selectbits(pairp, st) int *pairp; struct stat *st; {
register int n, *ap;
ap = pairp;
return (cp[-1]=='/');
}
-int onintr() {
+void onintr() {
(void) signal(SIGINT, SIG_IGN);
term++;
}
-int onquit() {
+void onquit() {
(void) signal(SIGQUIT, SIG_IGN);
term++;
}
-int onhup() {
+void onhup() {
(void) signal(SIGHUP, SIG_IGN);
term++;
}
}
#endif
-int tomodes(sp) register struct stat *sp; {
+void tomodes(sp) register struct stat *sp; {
register char *cp;
for (cp = dblock.dummy; cp < &dblock.dummy[TBLOCK]; cp++)
}
}
-int done(n) int n; {
+void done(n) int n; {
unlink(tname);
exit(n);
}
return (nblock - recno);
}
-int backtape() {
+void backtape() {
static int mtdev = 1;
static struct mtop mtop = {MTBSR, 1};
struct mtget mtget;
recno--;
}
-int flushtape() {
+void flushtape() {
int i;
i = write(mt, (char *)tbuf, TBLOCK*nblock);
mterr("write", i, 2);
}
-int mterr(operation, i, exitcode) char *operation; int i; int exitcode; {
+void mterr(operation, i, exitcode) char *operation; int i; int exitcode; {
fprintf(stderr, "tar: tape %s error: ", operation);
if (i < 0)
perror("");
return (buf);
}
-int getbuf() {
+void getbuf() {
if (nblock == 0) {
fstat(mt, &stbuf);
#define NTIM (NAMSIZ/2+1) /* a/b/c/d/... */
time_t mtime[NTIM];
-int dodirtimes(hp) union hblock *hp; {
+void dodirtimes(hp) union hblock *hp; {
register char *p = dirstack;
register char *q = hp->dbuf.name;
register int ndir = 0;
mtime[ndir] = stbuf.st_mtime; /* overwrite the last one */
}
-int setimes(path, mt) char *path; time_t mt; {
+void setimes(path, mt) char *path; time_t mt; {
struct timeval tv[2];
tv[0].tv_sec = time((time_t *) 0);
#endif
#endif
-int main __P((int argc, char **argv));
-int stash __P((int p));
-int puts __P((char *s));
+void main __P((int argc, char **argv));
+void stash __P((int p));
+void puts __P((char *s));
-int main(argc, argv) int argc; char **argv; {
+void main(argc, argv) int argc; char **argv; {
register r,w,p;
struct stat buf;
while(argc>1&&argv[1][0]=='-') {
}
}
-int stash(p) int p; {
+void stash(p) int p; {
int k;
int i;
int d;
write(openf[k], out+i, d<p-i?d:p-i);
}
-int puts(s) char *s; {
+void puts(s) char *s; {
while(*s)
write(2,s++,1);
}
#endif
#endif
-int main __P((int argc, char *argv[]));
+void main __P((int argc, char *argv[]));
char *nxtarg __P((int mt));
int exp __P((void));
int e1 __P((void));
int tio __P((char *a, int f));
int ftype __P((char *f));
int fsizep __P((char *f));
-int synbad __P((char *s1, char *s2));
+void synbad __P((char *s1, char *s2));
int length __P((char *s));
-int main(argc, argv) int argc; char *argv[]; {
+void main(argc, argv) int argc; char *argv[]; {
int status;
ac = argc; av = argv; ap = 1;
return(statb.st_size>0);
}
-int synbad(s1, s2) char *s1; char *s2; {
+void synbad(s1, s2) char *s1; char *s2; {
(void) write(2, "test: ", 6);
(void) write(2, s1, strlen(s1));
(void) write(2, s2, strlen(s2));
#endif
#endif
-int main __P((int argc, char **argv));
-int printt __P((char *s, struct timeval *tv));
+void main __P((int argc, char **argv));
+void printt __P((char *s, struct timeval *tv));
-int main(argc, argv) int argc; char **argv; {
+void main(argc, argv) int argc; char **argv; {
int status;
register int p;
struct timeval before, after;
exit (status>>8);
}
-int printt(s, tv) char *s; struct timeval *tv; {
+void printt(s, tv) char *s; struct timeval *tv; {
fprintf(stderr, "%9d.%01d %s ", tv->tv_sec, tv->tv_usec/100000, s);
}
#endif
#endif
-int main __P((int argc, char *argv[]));
-int sendmes __P((char *tty));
+void main __P((int argc, char *argv[]));
+void sendmes __P((char *tty));
-int main(argc, argv) int argc; char *argv[]; {
+void main(argc, argv) int argc; char *argv[]; {
register int i, c;
register struct utmp *p;
int f;
exit(0);
}
-int sendmes(tty) char *tty; {
+void sendmes(tty) char *tty; {
register f, flags;
static char t[50] = "/dev/";
int e, i;
#endif
#endif
-int main __P((int argc, char **argv));
-int putline __P((void));
+void main __P((int argc, char **argv));
+void putline __P((void));
-int main(argc, argv) int argc; char **argv; {
+void main(argc, argv) int argc; char **argv; {
register char *tp, *s;
register FILE *fi;
extern char _sobuf[];
}
}
-int putline() {
+void putline() {
register char *cbuf;
printf("%-*.*s %-*.*s",
#endif
#endif
-int main __P((int argc, char *argv[]));
-int timout __P((void));
-int eof __P((void));
-int ex __P((char *bp));
-int sigs __P((int (*sig)(void)));
+void main __P((int argc, char *argv[]));
+void timout __P((void));
+void eof __P((void));
+void ex __P((char *bp));
+void sigs __P((void (*sig)(int sig)));
-int main(argc, argv) int argc; char *argv[]; {
+void main(argc, argv) int argc; char *argv[]; {
struct stat stbuf;
register i;
register FILE *uf;
fprintf(stderr, "write: No such tty\n");
exit(1);
}
- signal(SIGALRM, timout);
+ signal(SIGALRM, (void (*) __P((int sig)))timout);
alarm(5);
if ((tf = fopen(histty, "w")) == NULL) {
fprintf(stderr, "write: Permission denied\n");
exit(1);
}
alarm(0);
- sigs(eof);
+ sigs((void (*) __P((int sig)))eof);
{ char hostname[32];
gethostname(hostname, sizeof (hostname));
fprintf(tf,
}
}
-int timout() {
+void timout() {
fprintf(stderr, "write: Timeout opening their tty\n");
exit(1);
}
-int eof() {
+void eof() {
fprintf(tf, "EOF\r\n");
exit(0);
}
-int ex(bp) char *bp; {
+void ex(bp) char *bp; {
register i;
sigs(SIG_IGN);
if (i == 0) {
fclose(tf); /* Close his terminal */
setgid(getgid()); /* Give up effective group privs */
- sigs((int (*)())0);
+ sigs(SIG_DFL);
execl(getenv("SHELL") ?
getenv("SHELL") : "/bin/sh", "sh", "-c", bp+1, 0);
exit(0);
;
printf("!\n");
out:
- sigs(eof);
+ sigs((void (*) __P((int sig)))eof);
}
-int sigs(sig) int (*sig)(); {
+void sigs(sig) void (*sig) __P((int sig)); {
register i;
for (i=0; signum[i]; i++)
public / 43bsd.git / commitdiff