--- /dev/null
+CC = cl65
+PLATFORM = --target fuzixtg
+#PLATFORM = -tzx128
+
+.SUFFIXES: .c .o
+
+SRCS = args.c blok.c builtin.c cmd.c ctype.c error.c expand.c fault.c io.c \
+ macro.c main.c msg.c name.c print.c service.c setbrk.c stak.c \
+ string.c word.c xec.c glob.c
+
+INCS = brkincr.h ctype.h defs.h dup.h mac.h mode.h name.h stak.h sym.h timeout.h
+
+OBJS = $(SRCS:.c=.o)
+
+LIBS = ../../../../Library/libs/c6502.lib
+
+all: sh
+
+sh: $(OBJS)
+ $(CC) $(PLATFORM) ../../../../Library/libs/crt0_6502.o $(OBJS) $(LIBS) -o $@
+
+$(OBJS): $(INCS)
+
+.c.o:
+ $(CC) -O2 $(PLATFORM) -D __STDC__ -c -I ../../../../Library/include/6502 -I ../../../../Library/include $<
+
+clean:
+ rm -f $(OBJS) sh *~ core
+
+rmbak:
+ rm -f *~ core
+
all: sh
-$(OBJS): $(SRCS) $(CRT0)
+$(OBJS): $(SRCS)
$(OBJS): %.o : %.c
$(CC) -c $(CFLAGS) $(COPT) $<
--- /dev/null
+CC = sdcc
+ASM = sdasz80
+AR = sdar
+LINKER = sdcc
+FCC = ../../../../Library/tools/fcc -O2
+PLATFORM =
+#PLATFORM = -tzx128
+
+.SUFFIXES: .c .rel
+
+SRCS = args.c blok.c builtin.c cmd.c ctype.c error.c expand.c fault.c io.c \
+ macro.c main.c msg.c name.c print.c service.c setbrk.c stak.c \
+ string.c word.c xec.c glob.c
+
+INCS = brkincr.h ctype.h defs.h dup.h mac.h mode.h name.h stak.h sym.h timeout.h
+
+OBJS = $(SRCS:.c=.rel)
+
+LIBS = ../../../../Library/libs/syslib.lib
+
+all: sh
+
+sh: $(OBJS)
+ $(FCC) $(PLATFORM) $(OBJS) -o $@
+
+$(OBJS): $(INCS)
+
+.c.rel:
+ $(FCC) $(PLATFORM) -c $<
+
+%: %.rel
+ $(FCC) $(PLATFORM) $< -o $@
+
+clean:
+ rm -f $(OBJS) sh $(SRCS:.c=) core *~ *.asm *.lst *.sym *.map *.noi *.lk *.ihx *.tmp *.bin
+
+rmbak:
+ rm -f *~ core
+
#include <stdlib.h>
#include "defs.h"
-static STRING *copyargs(const char *from[], int n);
+static const char **copyargs(const char *from[], int n);
static DOLPTR dolh;
CHAR flagadr[10];
/* ======== option handling ======== */
-int options(int argc, const char **argv)
+int options(int argc, const char *argv[])
{
register const char *cp;
register const char **argp = argv;
DOLPTR freeargs(DOLPTR blk)
{
- register STRING *argp;
+ register char **argp;
register DOLPTR argr = 0;
register DOLPTR argblk;
if (argblk = blk) {
argr = argblk->dolnxt;
if ((--argblk->doluse) == 0) {
- for (argp = (STRING *) argblk->dolarg;
+ for (argp = (char **) argblk->dolarg;
Rcheat(*argp) != ENDARGS; argp++) {
- free(*argp);
+ sh_free(*argp);
}
- free(argblk);
- ;
- };
+ sh_free(argblk);
+ }
}
return (argr);
}
-static STRING *copyargs(const char *from[], int n)
+static const char **copyargs(const char *from[], int n)
{
- register char **np =
- (STRING *) alloc(sizeof(STRING *) * n + 3 * BYTESPERWORD);
+ register const char **np =
+ (const char **) alloc(sizeof(char *) * n + 3 * BYTESPERWORD);
register const char **fp = from;
- register char **pp = np;
+ register const char **pp = np;
((DOLPTR) np)->doluse = 1; /* use count */
- np = (STRING *) ((DOLPTR) np)->dolarg;
+ np = (const char **) ((DOLPTR) np)->dolarg;
dolv = np;
while (n--) {
*np++ = make(*fp++);
}
*np++ = ENDARGS;
- return (pp);
+ return pp;
}
void clearup(void)
}
}
-void free(void *ap)
+void sh_free(void *ap)
{
BLKPTR p;
- if ((p = ap) && p < bloktop) {
+ if ((p = ap) && p < bloktop)
Lcheat((--p)->word) &= ~BUSY;
- ;
- }
}
#ifdef DEBUG
p = (PARPTR) getstak(PARTYPE);
p->partre = cmd(')', NLFLG);
p->partyp = TPAR;
- t = makefork(0, p);
+ t = makefork(0, /*FIXME*/(void *)p);
break;
}
/* UNIX V7 source code: see /COPYRIGHT or www.tuhs.org for details. */
/* Changes: Copyright (c) 1999 Robert Nordier. All rights reserved. */
-//#include <stdint.h>
+#include <stdint.h>
#include <stddef.h>
#include <unistd.h>
+#include <stdlib.h>
/*
* UNIX shell
/* result type declarations */
extern void *setbrk(intptr_t);
-extern void sh_getenv(void);
extern char **sh_setenv(void);
-#define alloc malloc
-ADDRESS alloc();
-void addblok();
-STRING make();
-STRING movstr();
-TREPTR cmd();
-TREPTR makefork();
-NAMPTR lookup();
-void setname();
-DOLPTR useargs();
-DOLPTR freeargs();
-REAL expr();
-STRING macro();
-void exname();
-void printnam();
-void printflg();
-
#define attrib(n,f) (n->namflg |= f)
#define round(a,b) (((int)((ADR(a)+b)-1))&~((b)-1))
#define closepipe(x) (close(x[INPIPE]), close(x[OTPIPE]))
/* substitution */
extern int dolc;
-extern STRING *dolv;
+extern const char **dolv;
extern DOLPTR argfor;
extern ARGPTR gchain;
/* special names */
extern char flagadr[10];
-extern STRING cmdadr;
-extern STRING exitadr;
-extern STRING dolladr;
-extern STRING pcsadr;
-extern STRING pidadr;
+extern char * cmdadr;
+extern char * exitadr;
+extern char * dolladr;
+extern char * pcsadr;
+extern char * pidadr;
extern const char defpath[];
/* transput */
extern CHAR tmpout[];
-extern STRING tmpnam;
+extern char * tmpnam;
extern int serial;
#define TMPNAM 7
extern FILE standin;
#define SIGSET 4
#define SIGMOD 8
-void fault();
extern BOOL trapnote;
-extern STRING trapcom[];
+extern char * trapcom[];
extern BOOL trapflg[];
/* name tree and words */
-extern STRING *environ;
+extern char * *environ;
extern CHAR numbuf[];
extern const char export[];
extern const char readonly[];
/* blok.c */
ADDRESS alloc(POS nbytes);
extern void addblok(POS reqd);
-extern void free(void *ap); /* FIXME: rename sh_free */
-extern chkbptr(BLKPTR ptr);
+extern void sh_free(void *ap);
+extern int chkbptr(BLKPTR ptr);
/* builtin.c */
-extern int builtin(int argn, STRING *cmd);
+extern int builtin(int argn, char * *cmd);
/* cmd.c */
extern TREPTR makefork(int flgs, TREPTR i);
extern TREPTR cmd(int sym, int flg);
extern void exitsh(int xno);
extern void done(void);
extern void rmtemp(IOPTR base);
+/* expand.c */
+extern int expand(char *as, int rflg);
+extern int gmatch(register char *s, register char *p);
+extern void makearg(register char *args);
+/* fault.c */
+extern void fault(register int sig);
+extern void stdsigs(void);
+extern int ignsig(int n);
+extern void getsig(int n);
+extern void oldsigs(void);
+extern void clrsig(int i);
+extern void chktrap(void);
+/* io.c */
+extern void initf(UFD fd);
+extern int estabf(register const char *s);
+extern void push(FILE af);
+extern int pop(void);
+extern void chkpipe(int *pv);
+extern int chkopen(const char *idf);
+extern void sh_rename(register int f1, register int f2);
+extern int create(const char *s);
+extern int tmpfil(void);
+extern void copy(IOPTR ioparg);
+/* macro.c */
+extern char *macro(char *as);
+extern void subst(int in, int ot);
/* main.c */
extern int main(int c, const char *v[]);
extern void chkpr(char eor);
extern void settmp(void);
extern void Ldup(register int fa, register int fb);
+/* name.c */
+extern int syslook(char *w, SYSTAB syswds);
+extern void setlist(register ARGPTR arg, int xp);
+extern void setname(char *argi, int xp);
+extern void replace(char **a, const char *v);
+extern void dfault(NAMPTR n, const char *v);
+extern void assign(NAMPTR n, const char *v);
+extern int readvar(char **names);
+extern void assnum(char **p, int i);
+extern char *make(const char *v);
+extern NAMPTR lookup(register char *nam);
+extern void namscan(void (*fn)(NAMPTR));
+extern void printnam(NAMPTR n);
+extern void exname(register NAMPTR n);
+extern void printflg(register NAMPTR n);
+extern void sh_getenv(void);
+extern void countnam(NAMPTR n);
+extern void pushnam(NAMPTR n);
+extern char **sh_setenv(void);
/* print.c */
extern void newline(void);
extern void blank(void);
extern const char *getpath(const char *s);
extern int pathopen(const char *path, const char *name);
extern const char *catpath(register const char *path, const char *name);
-extern void execa(const char *at[]);
+extern void execa(const char **at);
extern void postclr(void);
extern void post(int pcsid);
extern void await(int i);
extern char **scan(int argn);
extern int getarg(COMPTR ac);
/* stak.c */
-extern STKPTR getstak(int asize);
-extern STKPTR locstak(void);
-extern STKPTR savstak(void);
-extern STKPTR endstak(register STRING argp);
-extern void tdystak(register STKPTR x);
+extern char * getstak(int asize);
+extern char * locstak(void);
+extern char * savstak(void);
+extern char * endstak(register char * argp);
+extern void tdystak(register char * x);
extern void stakchk(void);
-extern STKPTR cpystak(STKPTR x);
+extern char *cpystak(const char *x);
/* string.c */
extern char *movstr(register const char *a, register char *b);
extern int any(char c, const char *s);
extern int cf(register const char *s1, register const char *s2);
extern int length(const char *as);
+/* word.c */
+extern int word(void);
+extern int nextc(char quote);
+extern int readc(void);
+/* xec.c */
+extern int execute(TREPTR argt, int execflg, int *pf1, int *pf2);
+extern void execexp(char *s, UFD f);
*
*/
-static void addg();
+static void addg(const char *as1, char *as2, const char *as3);
-int expand(as, rflg)
-STRING as;
+int expand(char *as, int rflg)
{
int count, dirf;
BOOL dir = 0;
STRING rescan = 0;
- register STRING s, cs;
+ register char *s, *cs;
ARGPTR schain = gchain;
struct dirent entry;
STATBUF statb;
- if (trapnote & SIGSET) {
- return (0);;
- }
+ if (trapnote & SIGSET)
+ return (0);
s = cs = as;
entry.d_name[DIRSIZ - 1] = 0; /* to end the string */
{
register BOOL slash;
slash = 0;
- while (!fngchar(*cs)
- ) {
+ while (!fngchar(*cs)) {
if (*cs++ == 0) {
if (rflg && slash) {
break;
}
} else if (*cs == '/') {
slash++;
- ;
- };
+ }
}
}
for (;;) {
if (cs == s) {
- s = nullstr;
+ s = (char *)nullstr;
break;
} else if (*--cs == '/') {
*cs = 0;
s = "/";
}
break;
- ;
}
}
if (stat(s, &statb) >= 0
&& (statb.st_mode & S_IFMT) == S_IFDIR
&& (dirf = open(s, 0)) > 0) {
dir++;
- ;
}
count = 0;
if (*cs == 0) {
*cs++ = 0200;
}
if (dir) { /* check for rescan */
- register STRING rs;
+ register char *rs;
rs = cs;
do {
} while (*rs++);
// FIXME: readdir
- while (read(dirf, (void *) &entry, 32) == 32
- && (trapnote & SIGSET) == 0) {
- if (entry.d_ino == 0
- || (*entry.d_name == '.' && *cs != '.')
- ) {
+ while (read(dirf, (void *) &entry, 32) == 32 && (trapnote & SIGSET) == 0) {
+ if (entry.d_ino == 0 || (*entry.d_name == '.' && *cs != '.'))
continue;
- ;
- }
- if (gmatch(entry.d_name, cs)
- ) {
+ if (gmatch(entry.d_name, cs)) {
addg(s, entry.d_name, rescan);
count++;
- ;
- };
+ }
}
close(dirf);
while (rchain) {
count += expand(rchain->argval, 1);
rchain = rchain->argnxt;
- ;
}
- ;
}
*rescan = '/';
- ;
- };
+ }
}
{
- register CHAR c;
+ register char c;
s = as;
- while (c = *s) {
+ while (c = *s)
*s++ = (c & STRIP ? c : '/');
- }
}
- return (count);
+ return count;
}
-gmatch(s, p)
-register STRING s, p;
+int gmatch(register char *s, register char *p)
{
register int scc;
- CHAR c;
+ char c;
if (scc = *s++) {
if ((scc &= STRIP) == 0) {
scc = 0200;
- ;
- };
+ }
}
switch (c = *p++) {
case '[':
} else {
if (scc == (lc = (c & STRIP))) {
ok++;
- };
+ }
}
- ;
}
return (0);
}
default:
- if ((c & STRIP) != scc) {
+ if ((c & STRIP) != scc)
return (0);
- }
case '?':
return (scc ? gmatch(s, p) : 0);
case '*':
- if (*p == 0) {
- return (1);
- }
+ if (*p == 0)
+ return 1;
--s;
while (*s) {
- if (gmatch(s++, p)) {
- return (1);
- };
+ if (gmatch(s++, p))
+ return 1;
}
- return (0);
+ return 0;
case 0:
return (scc == 0);
}
}
-static void addg(as1, as2, as3)
-STRING as1, as2, as3;
+static void addg(const char *as1, char *as2, const char *as3)
{
- register STRING s1, s2;
+ register const char *s1;
+ register char *s2;
register int c;
s2 = locstak() + BYTESPERWORD;
;
}
*s2++ = c;
- ;
}
s1 = as2;
while (*s2 = *s1++) {
if (s1 = as3) {
*s2++ = '/';
while (*s2++ = *++s1);
- ;
}
makearg(endstak(s2));
}
-makearg(args)
-register STRING args;
+void makearg(register char *args)
{
((ARGPTR) args)->argnxt = gchain;
gchain = (ARGPTR) args;
/* ======== fault handling routines ======== */
-void fault(sig)
-register int sig;
+void fault(register int sig)
{
register int flag;
signal(sig, fault);
if (sig == MEMF) {
- if (setbrk(brkincr) == -1) {
+ if (setbrk(brkincr) == (void *)-1)
error(nospace);
- ;
- }
} else if (sig == ALARM) {
- if (flags & waiting) {
+ if (flags & waiting)
done();
- ;
- }
} else {
flag = (trapcom[sig] ? TRAPSET : SIGSET);
trapnote |= flag;
trapflg[sig] |= flag;
- ;
}
}
-stdsigs()
+void stdsigs(void)
{
ignsig(QUIT);
getsig(INTR);
getsig(ALARM);
}
-ignsig(n)
+int ignsig(int n)
{
register int s, i;
#if 0
// FIXME: need to do proper SIG_IGN checks/handling
if ((s = signal(i = n, 1) & 01) == 0) {
trapflg[i] |= SIGMOD;
- ;
}
#endif
return (s);
}
-getsig(n)
+void getsig(int n)
{
register int i;
}
}
-oldsigs()
+void oldsigs(void)
{
register int i;
- register STRING t;
+ register char *t;
i = MAXTRAP;
while (i--) {
t = trapcom[i];
- if (t == 0 || *t) {
+ if (t == 0 || *t)
clrsig(i);
- ;
- }
trapflg[i] = 0;
- ;
}
trapnote = 0;
}
-clrsig(i)
-int i;
+void clrsig(int i)
{
- free(trapcom[i]);
+ sh_free(trapcom[i]);
trapcom[i] = 0;
if (trapflg[i] & SIGMOD) {
signal(i, fault);
trapflg[i] &= ~SIGMOD;
- ;
}
}
-chktrap()
+void chktrap(void)
{
/* check for traps */
register int i = MAXTRAP;
while (--i) {
if (trapflg[i] & TRAPSET) {
trapflg[i] &= ~TRAPSET;
- if (t = trapcom[i]
- ) {
+ if (t = trapcom[i]) {
int savxit = exitval;
execexp(t, 0);
exitval = savxit;
exitset();
- ;
- };
- };
+ }
+ }
}
}
+#include "defs.h"
+
int wdval;
-int iopend;
int flags;
int peekc;
-char *comdiv;
+const char *comdiv;
int breakcnt;
int loopcnt;
-int execbrk;
+BOOL execbrk;
int exitval;
int dolc;
-char **dolv;
+const char **dolv;
/* FIXME */
-void *argfor;
-void *gchain;
-int iotemp;
-int iopend;
+DOLPTR argfor;
+ARGPTR gchain;
+IOPTR iotemp;
+IOPTR iopend;
int ioset;
-int output;
char *pidadr;
char *dolladr;
char *pcsadr;
-char *pidadr;
char *exitadr;
char *cmdadr;
int wdset;
-void *wdarg;
-int reserv;
+ARGPTR wdarg;
+BOOL reserv;
int wdnum;
-int trapnote;
-int end;
+BOOL trapnote;
+address end[1]; /* FIXME */
int serial;
+BLKPTR stakbsy;
+STKPTR stakbas;
+STKPTR brkend;
+STKPTR staktop;
#include <setjmp.h>
jmp_buf subshell;
jmp_buf errshell;
+#if 0
/* FIXME */
int setjmp(jmp_buf bar)
void longjmp(jmp_buf bar, int foo)
{
}
+#endif
/* ======== input output and file copying ======== */
-initf(fd)
-UFD fd;
+void initf(UFD fd)
{
register FILE f = standin;
f->feof = FALSE;
}
-estabf(s)
-register STRING s;
+int estabf(register const char *s)
{
register FILE f;
(f = standin)->fdes = -1;
- f->fend = length(s) + (f->fnxt = s);
+ f->fend = length(s) + (f->fnxt = (char *)s);/*FIXME review */
f->flin = 1;
return (f->feof = (s == 0));
}
-push(af)
-FILE af;
+void push(FILE af)
{
register FILE f;
standin = f;
}
-pop()
+int pop(void)
{
register FILE f;
if ((f = standin)->fstak) {
- if (f->fdes >= 0) {
+ if (f->fdes >= 0)
close(f->fdes);
- }
standin = f->fstak;
return (TRUE);
- } else {
+ } else
return (FALSE);
- ;
- }
}
-chkpipe(pv)
-int *pv;
+void chkpipe(int *pv)
{
- if (pipe(pv) < 0 || pv[INPIPE] < 0 || pv[OTPIPE] < 0) {
+ if (pipe(pv) < 0 || pv[INPIPE] < 0 || pv[OTPIPE] < 0)
error(piperr);
- ;
- }
}
-chkopen(idf)
-STRING idf;
+int chkopen(const char *idf)
{
register int rc;
- if ((rc = open(idf, 0)) < 0) {
+ if ((rc = open(idf, 0)) < 0)
failed(idf, badopen);
- } else {
- return (rc);
- ;
- }
+ else
+ return rc;
}
-sh_rename(f1, f2)
-register int f1, f2;
+void sh_rename(register int f1, register int f2)
{
if (f1 != f2) {
dup2(f1, f2);
close(f1);
- if (f2 == 0) {
+ if (f2 == 0)
ioset |= 1;
- };
}
}
-create(s)
-STRING s;
+int create(const char *s)
{
register int rc;
- if ((rc = creat(s, 0666)) < 0) {
+ if ((rc = creat(s, 0666)) < 0)
failed(s, badcreate);
- } else {
- return (rc);
- ;
- }
+ else
+ return rc;
}
-tmpfil()
+int tmpfil(void)
{
itos(serial++);
movstr(numbuf, tmpnam);
- return (create(tmpout));
+ return create(tmpout);
}
/* set by trim */
BOOL nosubst;
-copy(ioparg)
-IOPTR ioparg;
+void copy(IOPTR ioparg)
{
CHAR c, *ends;
register CHAR *cline, *clinep;
if (iop = ioparg) {
copy(iop->iolst);
ends = mactrim(iop->ioname);
- if (nosubst) {
+
+ if (nosubst)
iop->iofile &= ~IODOC;
- }
+
fd = tmpfil();
iop->ioname = cpystak(tmpout);
iop->iolst = iotemp;
for (;;) {
clinep = cline;
chkpr(NL);
- while ((c =
- (nosubst ? readc() : nextc(*ends)),
- !eolchar(c))) {
+ while ((c = (nosubst ? readc() : nextc(*ends)),!eolchar(c))) {
*clinep++ = c;
}
*clinep = 0;
- if (eof || eq(cline, ends)) {
+
+ if (eof || eq(cline, ends))
break;
- }
+
*clinep++ = NL;
write(fd, cline, clinep - cline);
}
close(fd);
- ;
}
}
static CHAR quote; /* used locally */
static CHAR quoted; /* used locally */
-static getch();
-static comsubst();
-static flush();
+static int getch(char);
+static void comsubst(void);
+static void flush(int);
-
-static STRING copyto(endch)
-register CHAR endch;
+static char *copyto(char endch)
{
register CHAR c;
- while ((c = getch(endch)) != endch && c) {
+ while ((c = getch(endch)) != endch && c)
pushstak(c | quote);
- }
zerostak();
- if (c != endch) {
+
+ if (c != endch)
error(badsub);
- }
}
-static skipto(endch)
-register CHAR endch;
+static int skipto(char endch)
{
/* skip chars up to } */
- register CHAR c;
+ register char c;
while ((c = readc()) && c != endch) {
switch (c) {
break;
case DOLLAR:
- if (readc() == BRACE) {
+ if (readc() == BRACE)
skipto('}');
- ;
- }
}
- ;
}
if (c != endch) {
error(badsub);
}
}
-static getch(endch)
-CHAR endch;
+static int getch(char endch)
{
- register CHAR d;
+ register char d;
- retry:
+retry:
d = readc();
- if (!subchar(d)
- ) {
+ if (!subchar(d))
return (d);
- ;
- }
+
if (d == DOLLAR) {
register int c;
- if ((c = readc(), dolchar(c))
- ) {
+ if ((c = readc(), dolchar(c))) {
NAMPTR n = (NAMPTR) NIL;
int dolg = 0;
BOOL bra;
- register STRING argp, v;
+ register const char *argp;
+ register const char *v;
CHAR idb[2];
- STRING id = idb;
+ char *id = idb;
- if (bra = (c == BRACE)) {
+ if (bra = (c == BRACE))
c = readc();
- }
- if (letter(c)
- ) {
+
+ if (letter(c)) {
argp = (STRING) relstak();
while (alphanum(c)) {
pushstak(c);
n = lookup(absstak(argp));
setstak(argp);
v = n->namval;
- id = n->namid;
+ id = (char *)n->namid;
peekc = c | MARK;;
- } else if (digchar(c)
- ) {
+ } else if (digchar(c)) {
*id = c;
idb[1] = 0;
- if (astchar(c)
- ) {
+ if (astchar(c)) {
dolg = 1;
c = '1';
- ;
}
c -= '0';
- v = ((c == 0) ? cmdadr : (c <=
- dolc) ? dolv[c]
- : (STRING) (dolg = 0));
+ v = ((c == 0) ? (const char *)cmdadr :
+ (c <= dolc) ? dolv[c]
+ : (dolg = 0, NULL));
} else if (c == '$') {
v = pidadr;
} else if (c == '!') {
error(badsub);
} else {
goto retry;
- ;
}
c = readc();
- if (!defchar(c) && bra) {
+
+ if (!defchar(c) && bra)
error(badsub);
- ;
- }
+
argp = 0;
if (bra) {
if (c != '}') {
argp = (STRING) relstak();
- if ((v == 0) ^ (setchar(c))
- ) {
+ if ((v == 0) ^ (setchar(c)))
copyto('}');
- } else {
+ else
skipto('}');
- ;
- }
+
argp = absstak(argp);
- ;
}
} else {
peekc = c | MARK;
c = 0;
- ;
}
if (v) {
if (c != '+') {
for (;;) {
- while (c = *v++) {
- pushstak(c |
- quote);;
- }
- if (dolg == 0
- || (++dolg > dolc)
- ) {
+ while (c = *v++)
+ pushstak(c | quote);
+
+ if (dolg == 0 || (++dolg > dolc))
break;
- } else {
+ else {
v = dolv[dolg];
- pushstak(SP |
- (*id ==
- '*' ?
- quote :
- 0));
- ;
+ pushstak(SP | (*id == '*' ? quote : 0));
}
}
- ;
}
} else if (argp) {
if (c == '?') {
failed(id,
*argp ? argp : badparam);
} else if (c == '=') {
- if (n) {
+ if (n)
assign(n, argp);
- } else {
+ else
error(badsub);
- ;
- }
- ;
}
- } else if (flags & setflg) {
+ } else if (flags & setflg) {
failed(id, badparam);
- ;
}
goto retry;
} else {
peekc = c | MARK;
- ;
}
} else if (d == endch) {
return (d);
quoted++;
quote ^= QUOTE;
goto retry;
- ;
}
- return (d);
+ return d;
}
-STRING macro(as)
-STRING as;
+char *macro(char *as)
{
/* Strip "" and do $ substitution
* Leaves result on top of stack
register CHAR savq = quote;
FILEHDR fb;
- push(&fb);
+ push((void *)&fb);/*FIXME*/
estabf(as);
usestak();
quote = 0;
return (fixstak());
}
-static comsubst()
+static void comsubst(void)
{
/* command substn */
FILEBLK cb;
- register CHAR d;
+ register char d;
register STKPTR savptr = fixstak();
usestak();
- while ((d = readc()) != SQUOTE && d) {
+ while ((d = readc()) != SQUOTE && d)
pushstak(d);
- }
{
- register STRING argc;
+ register char *argc;
trim(argc = fixstak());
push(&cb);
estabf(argc);
}
tdystak(savptr);
staktop = movstr(savptr, stakbot);
- while (d = readc()) {
+
+ while (d = readc())
pushstak(d | quote);
- }
+
await(0);
+
while (stakbot != staktop) {
if ((*--staktop & STRIP) != NL) {
++staktop;
break;
- ;
- };
+ }
}
pop();
}
#define CPYSIZ 512
-subst(in, ot)
-int in, ot;
+void subst(int in, int ot)
{
- register CHAR c;
+ register char c;
FILEBLK fb;
register int count = CPYSIZ;
push(&fb);
initf(in);
/* DQUOTE used to stop it from quoting */
- while (c = (getch(DQUOTE) & STRIP)
- ) {
+ while (c = (getch(DQUOTE) & STRIP)) {
pushstak(c);
if (--count == 0) {
flush(ot);
count = CPYSIZ;
- ;
- };
+ }
}
flush(ot);
pop();
}
-static flush(ot)
+static void flush(int ot)
{
write(ot, stakbot, staktop - stakbot);
- if (flags & execpr) {
+ if (flags & execpr)
write(output, stakbot, staktop - stakbot);
- }
staktop = stakbot;
}
/* number of positional parameters */
assnum(&dolladr, dolc);
- cmdadr = dolv[0];
+ cmdadr = (char *)dolv[0];
/* set pidname */
assnum(&pidadr, getpid());
return;
alarm(0);
flags &= ~waiting;
- execute(cmd(NL, MTFLG), 0);
+ execute(cmd(NL, MTFLG), 0, NULL, NULL);
eof |= (flags & oneflg);
}
}
#define BYTESPERWORD (sizeof(char *))
typedef char CHAR;
-typedef char BOOL;
+typedef signed char BOOL;
typedef int UFD;
-typedef float REAL;
typedef void *ADDRESS;
typedef long int L_INT;
typedef unsigned POS;
POS flin;
BOOL feof;
CHAR fsiz;
- STRING fnxt;
- STRING fend;
- STRING *feval;
+ char * fnxt;
+ char * fend;
+ char * *feval;
FILE fstak;
CHAR fbuf[BUFSIZ];
};
POS flin;
BOOL feof;
CHAR fsiz;
- STRING fnxt;
- STRING fend;
- STRING *feval;
+ char * fnxt;
+ char * fend;
+ char * *feval;
FILE fstak;
CHAR _fbuf[1];
};
struct sysnod {
- STRING sysnam;
+ const char * sysnam;
int sysval;
};
struct fornod {
int fortyp;
TREPTR fortre;
- STRING fornam;
+ char * fornam;
COMPTR forlst;
};
struct swnod {
int swtyp;
- STRING swarg;
+ char * swarg;
REGPTR swlst;
};
struct ionod {
int iofile;
- STRING ioname;
+ char * ioname;
IOPTR ionxt;
IOPTR iolst;
};
{0, 0},
};
-STRING sysmsg[] = {
+/* FIXME: align with actual OS! */
+const char *sysmsg[] = {
0,
"Hangup",
0, /* Interrupt */
#include "defs.h"
-static BOOL chkid();
-static void namwalk();
+static BOOL chkid(const char *);
+static void namwalk(NAMPTR);
-NAMNOD ps2nod = { (NAMPTR) NIL, (NAMPTR) NIL, ps2name }, fngnod = {
-(NAMPTR) NIL, (NAMPTR) NIL, fngname}, pathnod = {
-(NAMPTR) NIL, (NAMPTR) NIL, pathname}, ifsnod = {
-(NAMPTR) NIL, (NAMPTR) NIL, ifsname}, ps1nod = {
-&pathnod, &ps2nod, ps1name}, homenod = {
-&fngnod, &ifsnod, homename}, mailnod = {
-&homenod, &ps1nod, mailname};
+NAMNOD ps2nod = { (NAMPTR) NIL, (NAMPTR) NIL, ps2name };
+NAMNOD fngnod = { (NAMPTR) NIL, (NAMPTR) NIL, fngname };
+NAMNOD pathnod = { (NAMPTR) NIL, (NAMPTR) NIL, pathname };
+NAMNOD ifsnod = { (NAMPTR) NIL, (NAMPTR) NIL, ifsname };
+NAMNOD ps1nod = { &pathnod, &ps2nod, ps1name };
+NAMNOD homenod = { &fngnod, &ifsnod, homename };
+NAMNOD mailnod = { &homenod, &ps1nod, mailname };
NAMPTR namep = &mailnod;
/* ======== variable and string handling ======== */
-syslook(w, syswds)
-STRING w;
-SYSTAB syswds;
+int syslook(char *w, SYSTAB syswds)
{
- register CHAR first;
- register STRING s;
+ register char first;
+ register const char *s;
register SYSPTR syscan;
syscan = syswds;
first = *w;
while (s = syscan->sysnam) {
- if (first == *s && eq(w, s)
- ) {
+ if (first == *s && eq(w, s))
return (syscan->sysval);
- ;
- }
syscan++;
- ;
}
return (0);
}
-setlist(arg, xp)
-register ARGPTR arg;
-int xp;
+void setlist(register ARGPTR arg, int xp)
{
while (arg) {
- register STRING s = mactrim(arg->argval);
+ register char *s = mactrim(arg->argval);
setname(s, xp);
arg = arg->argnxt;
if (flags & execpr) {
prs(s);
- if (arg) {
+ if (arg)
blank();
- } else {
+ else
newline();;
- }
- ;
- };
+ }
}
}
-void setname(argi, xp)
-STRING argi;
-int xp;
+void setname(char *argi, int xp)
{
- register STRING argscan = argi;
+ register char *argscan = argi;
register NAMPTR n;
- if (letter(*argscan)
- ) {
- while (alphanum(*argscan)) {
+ if (letter(*argscan)) {
+ while (alphanum(*argscan))
argscan++;
- }
if (*argscan == '=') {
*argscan = 0;
n = lookup(argi);
*argscan++ = '=';
attrib(n, xp);
- if (xp & N_ENVNAM) {
+ if (xp & N_ENVNAM)
n->namenv = n->namval = argscan;
- } else {
+ else
assign(n, argscan);
- ;
- }
return;
- ;
- };
+ }
}
failed(argi, notid);
}
-replace(a, v)
-register STRING *a;
-STRING v;
+void replace(char **a, const char *v)
{
- free(*a);
+ sh_free(*a);
*a = make(v);
}
-dfault(n, v)
-NAMPTR n;
-STRING v;
+void dfault(NAMPTR n, const char *v)
{
if (n->namval == 0) {
assign(n, v);
}
}
-assign(n, v)
-NAMPTR n;
-STRING v;
+void assign(NAMPTR n, const char *v)
{
- if (n->namflg & N_RDONLY) {
+ if (n->namflg & N_RDONLY)
failed(n->namid, wtfailed);
- } else {
- replace(&n->namval, v);
- ;
- }
+ else
+ replace((char **)&n->namval, v); /* FIXME: check safe */
}
-int readvar(names)
-STRING *names;
+int readvar(char **names)
{
FILEBLK fb;
register FILE f = &fb;
- register CHAR c;
+ register char c;
register int rc = 0;
NAMPTR n = lookup(*names++); /* done now to avoid storage mess */
STKPTR rel = (STKPTR) relstak();
push(f);
initf(dup(0));
- if (lseek(0, 0L, 1) == -1) {
+
+ if (lseek(0, 0L, 1) == -1)
f->fsiz = 1;
- ;
- }
for (;;) {
c = nextc(0);
- if ((*names && any(c, ifsnod.namval)) || eolchar(c)
- ) {
+ if ((*names && any(c, ifsnod.namval)) || eolchar(c)) {
zerostak();
assign(n, absstak(rel));
setstak(rel);
- if (*names) {
+ if (*names)
n = lookup(*names++);
- } else {
+ else
n = 0;
- ;
- }
- if (eolchar(c)
- ) {
+ if (eolchar(c))
break;
- ;
- }
} else {
pushstak(c);
- ;
}
}
while (n) {
assign(n, nullstr);
- if (*names) {
+ if (*names)
n = lookup(*names++);
- } else {
- n = 0;;
- }
- ;
+ else
+ n = 0;
}
-
- if (eof) {
+ if (eof)
rc = 1;
- }
lseek(0, (long) (f->fnxt - f->fend), 1);
pop();
- return (rc);
+ return rc;
}
-assnum(p, i)
-STRING *p;
-int i;
+void assnum(char **p, int i)
{
itos(i);
replace(p, numbuf);
}
-STRING make(v)
-STRING v;
+char *make(const char *v)
{
- register STRING p;
+ register char *p;
if (v) {
movstr(v, p = alloc(length(v)));
- return (p);
- } else {
- return (0);
- ;
- }
+ return p;
+ } else
+ return 0;
}
-NAMPTR lookup(nam)
-register STRING nam;
+NAMPTR lookup(register char *nam)
{
register NAMPTR nscan = namep;
register NAMPTR *prev;
int LR;
- if (!chkid(nam)
- ) {
+ if (!chkid(nam))
failed(nam, notid);
- ;
- }
+
while (nscan) {
- if ((LR = cf(nam, nscan->namid)) == 0) {
+ if ((LR = cf(nam, nscan->namid)) == 0)
return (nscan);
- } else if (LR < 0) {
+ else if (LR < 0)
prev = &(nscan->namlft);
- } else {
+ else
prev = &(nscan->namrgt);
- ;
- }
+
nscan = *prev;
- ;
}
/* add name node */
return (*prev = nscan);
}
-static BOOL chkid(nam)
-STRING nam;
+static BOOL chkid(const char *nam)
{
- register CHAR *cp = nam;
+ register const char *cp = nam;
- if (!letter(*cp)
- ) {
+ if (!letter(*cp))
return (FALSE);
- } else {
+ else {
while (*++cp) {
- if (!alphanum(*cp)
- ) {
+ if (!alphanum(*cp))
return (FALSE);
- ;
- };
}
- ;
}
- return (TRUE);
+ return TRUE;
}
-static void (*namfn) ();
-namscan(fn)
-void (*fn) ();
+static void (*namfn) (NAMPTR);
+
+void namscan(void (*fn) (NAMPTR))
{
namfn = fn;
namwalk(namep);
}
-static void namwalk(np)
-register NAMPTR np;
+static void namwalk(NAMPTR np)
{
if (np) {
namwalk(np->namlft);
(*namfn) (np);
namwalk(np->namrgt);
- ;
}
}
-void printnam(n)
-NAMPTR n;
+void printnam(NAMPTR n)
{
- register STRING s;
+ register const char *s;
sigchk();
if (s = n->namval) {
prc('=');
prs(s);
newline();
- ;
}
}
-static STRING staknam(n)
-register NAMPTR n;
+static char *staknam(register NAMPTR n)
{
- register STRING p;
+ register char *p;
p = movstr(n->namid, staktop);
p = movstr("=", p);
return (getstak(p + 1 - ADR(stakbot)));
}
-void exname(n)
-register NAMPTR n;
+void exname(register NAMPTR n)
{
if (n->namflg & N_EXPORT) {
- free(n->namenv);
+ sh_free((void *)n->namenv);
n->namenv = make(n->namval);
} else {
- free(n->namval);
+ sh_free((void *)n->namval);
n->namval = make(n->namenv);
- ;
}
}
-void printflg(n)
-register NAMPTR n;
+void printflg(register NAMPTR n)
{
if (n->namflg & N_EXPORT) {
prs(export);
blank();
- ;
}
if (n->namflg & N_RDONLY) {
prs(readonly);
blank();
- ;
}
- if (n->namflg & (N_EXPORT | N_RDONLY)
- ) {
+ if (n->namflg & (N_EXPORT | N_RDONLY)) {
prs(n->namid);
newline();
- ;
}
}
static int namec;
-void countnam(n)
-NAMPTR n;
+void countnam(NAMPTR n)
{
namec++;
}
-static STRING *argnam;
+static char **argnam;
-void pushnam(n)
-NAMPTR n;
+void pushnam(NAMPTR n)
{
- if (n->namval) {
+ if (n->namval)
*argnam++ = staknam(n);
- ;
- }
}
char **sh_setenv(void)
(STRING *) getstak(namec * BYTESPERWORD + BYTESPERWORD);
namscan(pushnam);
*argnam++ = 0;
- return (er);
+ return er;
}
struct namnod {
NAMPTR namlft;
NAMPTR namrgt;
- STRING namid;
- STRING namval;
- STRING namenv;
+ const char * namid;
+ const char * namval;
+ const char * namenv;
int namflg;
};
/* FIXME: errno from header */
extern int errno;
-extern STRING sysmsg[];
+/* FIXME: put into a header */
+extern const char *sysmsg[];
/* fault handling */
#define ENOMEM 12
const char *getpath(const char *s)
{
- register char *path;
+ register const char *path;
if (any('/', s)) {
if (flags & rshflg) {
failed(s, restricted);
static const char *xecmsg;
static char **xecenv;
-void execa(const char *at[])
+void execa(const char **at)
{
register const char *path;
register const char **t = at;
exitset();
}
-BOOL nosubst;
+extern BOOL nosubst; /* FIXME */
void trim(char *at)
{
size = round(asize, BYTESPERWORD);
oldstak = stakbot;
staktop = stakbot += size;
- return (oldstak);
+ return oldstak;
}
STKPTR locstak(void)
*/
if (brkend - stakbot < BRKINCR) {
setbrk(brkincr);
- if (brkincr < BRKMAX) {
+ if (brkincr < BRKMAX)
brkincr += 256;
- ;
- };
}
- return (stakbot);
+ return stakbot;
}
STKPTR savstak(void)
{
/* FIXME: check assert doesn't suck in stdio */
assert(staktop == stakbot);
- return (stakbot);
+ return stakbot;
}
-STKPTR endstak(register STRING argp)
+STKPTR endstak(register char *argp)
{ /* tidy up after `locstak' */
- register STKPTR oldstak;
+ register char *oldstak;
*argp++ = 0;
oldstak = stakbot;
- stakbot = staktop = (STKPTR) round(argp, BYTESPERWORD);
- return (oldstak);
+ stakbot = staktop = (char *) round(argp, BYTESPERWORD);
+ return oldstak;
}
-void tdystak(register STKPTR x)
+void tdystak(register char *x)
{
/* try to bring stack back to x */
- while (ADR(stakbsy) > ADR(x)
- ) {
- free(stakbsy);
+ while (ADR(stakbsy) > ADR(x)) {
+ sh_free(stakbsy);
stakbsy = stakbsy->word;
- ;
}
staktop = stakbot = max(ADR(x), ADR(stakbas));
- rmtemp((const char *)x);
+ rmtemp((void *)x); /* FIXME */
}
void stakchk(void)
{
- if ((brkend - stakbas) > BRKINCR + BRKINCR) {
+ if ((brkend - stakbas) > BRKINCR + BRKINCR)
setbrk(-BRKINCR);
- }
}
-STKPTR cpystak(STKPTR x)
+char *cpystak(const char *x)
{
- return (endstak(movstr(x, locstak())));
+ return endstak(movstr(x, locstak()));
}
/* for local use only since it hands
* out a real address for the stack top
*/
-STKPTR locstak();
+//STKPTR locstak();
/* Will allocate the item being used and return its
* address (safe now).
/* For use after `locstak' to hand back
* new stack top and then allocate item
*/
-STKPTR endstak();
+//STKPTR endstak();
/* Copy a string onto the stack and
* allocate the space.
*/
-STKPTR cpystak();
+//STKPTR cpystak();
/* Allocate given ammount of stack space */
-STKPTR getstak();
+//STKPTR getstak();
/* A chain of ptrs of stack blocks that
* have become covered by heap allocation.
* `tdystak' will return them to the heap.
*/
-BLKPTR stakbsy;
+extern BLKPTR stakbsy;
/* Base of the entire stack */
-STKPTR stakbas;
+extern STKPTR stakbas;
/* Top of entire stack */
-STKPTR brkend;
+extern STKPTR brkend;
/* Base of current item */
-STKPTR stakbot;
+extern STKPTR stakbot;
/* Top of current item */
-STKPTR staktop;
+extern STKPTR staktop;
/* Used with tdystak */
-STKPTR savstak();
+//STKPTR savstak();
#include "defs.h"
#include "sym.h"
-static readb();
+static int readb(void);
/* ======== character handling for command lines ========*/
-word()
+int word(void)
{
- register CHAR c, d;
- register CHAR *argp = locstak() + BYTESPERWORD;
+ register char c, d;
+ register char *argp = locstak() + BYTESPERWORD;
int alpha = 1;
wdnum = 0;
wdset = 0;
while ((c = nextc(0), space(c)));
- if (!eofmeta(c)
- ) {
+
+ if (!eofmeta(c)) {
do {
if (c == LITERAL) {
*argp++ = (DQUOTE);
*argp++ = (DQUOTE);
} else {
*argp++ = (c);
- if (c == '=') {
+ if (c == '=')
wdset |= alpha;
- }
- if (!alphanum(c)) {
+ if (!alphanum(c))
alpha = 0;
- }
- if (qotchar(c)
- ) {
+ if (qotchar(c)) {
d = c;
- while ((*argp++ = (c = nextc(d)))
- && c != d) {
+ while ((*argp++ = (c = nextc(d))) && c != d)
chkpr(c);
- }
- ;
- };
+ }
}
} while ((c = nextc(0), !eofmeta(c)));
+
argp = endstak(argp);
- if (!letter(((ARGPTR) argp)->argval[0])) {
+
+ if (!letter(((ARGPTR) argp)->argval[0]))
wdset = 0;
- }
peekc = c | MARK;
+
if (((ARGPTR) argp)->argval[1] == 0
&& (d = ((ARGPTR) argp)->argval[0], digit(d))
- && (c == '>' || c == '<')
- ) {
+ && (c == '>' || c == '<')) {
word();
wdnum = d - '0';
} else { /*check for reserved words */
if (reserv == FALSE
- || (wdval =
- syslook(((ARGPTR) argp)->argval,
- reserved)) == 0) {
+ || (wdval = syslook(((ARGPTR) argp)->argval, reserved)) == 0) {
wdarg = (ARGPTR) argp;
wdval = 0;
- ;
- };
+ }
}
- } else if (dipchar(c)
- ) {
- if ((d = nextc(0)) == c) {
+ } else if (dipchar(c)) {
+ if ((d = nextc(0)) == c)
wdval = c | SYMREP;
- } else {
+ else {
peekc = d | MARK;
wdval = c;
- ;
}
} else {
- if ((wdval = c) == EOF) {
+ if ((wdval = c) == EOF)
wdval = EOFSYM;
- ;
- }
- if (iopend && eolchar(c)
- ) {
+ if (iopend && eolchar(c)) {
copy(iopend);
iopend = 0;
- ;
- };
+ }
}
reserv = FALSE;
- return (wdval);
+ return wdval;
}
-nextc(quote)
-CHAR quote;
+int nextc(char quote)
{
- register CHAR c, d;
+ register char c, d;
if ((d = readc()) == ESCAPE) {
if ((c = readc()) == NL) {
chkpr(NL);
d = nextc(quote);
- } else if (quote && c != quote && !escchar(c)
- ) {
+ } else if (quote && c != quote && !escchar(c))
peekc = c | MARK;
- } else {
+ else
d = c | QUOTE;
- ;
- }
- ;
}
- return (d);
+ return d;
}
-readc()
+int readc(void)
{
- register CHAR c;
+ register char c;
register int len;
register FILE f;
- retry:
+retry:
if (peekc) {
c = peekc;
peekc = 0;
- } else if ((f = standin, f->fnxt != f->fend)
- ) {
+ } else if ((f = standin, f->fnxt != f->fend)) {
if ((c = *f->fnxt++) == 0) {
if (f->feval) {
- if (estabf(*f->feval++)
- ) {
+ if (estabf(*f->feval++))
c = EOF;
- } else {
+ else
c = SP;
- ;
- }
} else {
goto retry; /* = c=readc(); */
- ;
}
- ;
}
if (flags & readpr && standin->fstak == 0) {
prc(c);
} else {
f->fend = (f->fnxt = f->fbuf) + len;
goto retry;
- ;
}
- return (c);
+ return c;
}
-static readb()
+static int readb(void)
{
register FILE f = standin;
register int len;
/* ======== command execution ========*/
-execute(argt, execflg, pf1, pf2)
-TREPTR argt;
-int *pf1, *pf2;
+int execute(TREPTR argt, int execflg, int *pf1, int *pf2)
{
/* `stakbot' is preserved by this routine */
register TREPTR t;
if ((t = argt) && execbrk == 0) {
register int treeflgs;
int oldexit, type;
- register STRING *com;
+ register char **com;
treeflgs = t->tretyp;
type = treeflgs & COMMSK;
ARGPTR schain = gchain;
IOPTR io = t->treio;
gchain = 0;
- argn = getarg(t);
+ argn = getarg((void *)t);/*FIXME*/
com = scan(argn);
a1 = com[1];
gchain = schain;
- if ((internal = syslook(com[0], commands))
- || argn == 0) {
+ if ((internal = syslook(com[0], commands)) || argn == 0)
setlist(((COMPTR) t)->comset, 0);
- ;
- }
if (argn && (flags & noexec) == 0) { /* print command if execpr */
if (flags & execpr) {
argn = 0;
prs(execpmsg);
- while (com[argn] !=
- ENDARGS) {
+ while (com[argn] != ENDARGS) {
prs(com[argn++]);
blank();
}
newline();
- ;
}
switch (internal) {
if (a1) {
register int f;
- if ((f =
- pathopen
- (getpath(a1),
- a1)) < 0) {
- failed(a1,
- notfound);
- } else {
- execexp(0,
- f);
- ;
- }
- ;
+ if ((f = pathopen(getpath(a1), a1)) < 0)
+ failed(a1, notfound);
+ else
+ execexp(0, f);
}
break;
case SYSTIMES:
- {
- L_INT t[4];
- times(t);
- prt(t[2]);
- blank();
- prt(t[3]);
- newline();
- }
- break;
+ {
+ L_INT t[4]; /* FIXME: struct for this nowdays */
+ times((void *)t);
+ prt(t[2]);
+ blank();
+ prt(t[3]);
+ newline();
+ }
+ break;
case SYSEXIT:
- exitsh(a1 ? stoi(a1) :
- oldexit);
+ exitsh(a1 ? stoi(a1) : oldexit);
case SYSNULL:
io = 0;
break;
case SYSBREAK:
- if ((execbrk = loopcnt)
- && a1) {
- breakcnt =
- stoi(a1);
- ;
- }
+ if ((execbrk = loopcnt) && a1)
+ breakcnt = stoi(a1);
break;
case SYSTRAP:
if (a1) {
BOOL clear;
- if ((clear =
- digit(*a1)) ==
- 0) {
+ if ((clear = digit(*a1)) == 0)
++com;
- ;
- }
while (*++com) {
int i;
- if ((i =
- stoi
- (*com))
- >=
- MAXTRAP
- || i <
- MINTRAP)
- {
- failed
- (*com,
- badtrap);
- } else
- if
- (clear)
- {
- clrsig
- (i);
- } else {
- replace
- (&trapcom
- [i],
- a1);
- if (*a1) {
- getsig
- (i);
- } else {
- ignsig
- (i);
- ;
- }
- ;
+ if ((i = stoi(*com)) >= MAXTRAP || i < MINTRAP)
+ failed(*com, badtrap);
+ else if (clear)
+ clrsig(i);
+ else {
+ replace(&trapcom[i], a1);
+ if (*a1)
+ getsig(i);
+ else
+ ignsig(i);
}
- ;
}
} else { /* print out current traps */
int i;
- for (i = 0;
- i < MAXTRAP;
- i++) {
- if (trapcom
- [i]
- ) {
+ for (i = 0; i < MAXTRAP; i++) {
+ if (trapcom[i]) {
prn(i);
prs(colon);
prs(trapcom[i]);
- newline
- ();
- ;
- };
+ newline();
+ }
}
- ;
}
break;
initio(io);
ioset = 0;
io = 0;
- if (a1 == 0) {
+ if (a1 == 0)
break;
- }
case SYSLOGIN:
flags |= forked;
oldsigs();
- execa(com);
+ execa((const char **)com);
done();
case SYSCD:
- if (flags & rshflg) {
- failed(com[0],
- restricted);
- } else
- if ((a1 == 0
- && (a1 =
- homenod.
- namval) == 0)
- || chdir(a1) < 0) {
+ if (flags & rshflg)
+ failed(com[0], restricted);
+ else if ((a1 == 0 && (a1 = (char *)homenod.namval) == 0) || chdir(a1) < 0) /* FIXME */
failed(a1, baddir);
- ;
- }
break;
case SYSSHFT:
- if (dolc < 1) {
+ if (dolc < 1)
error(badshift);
- } else {
+ else {
dolv++;
dolc--;
- ;
}
assnum(&dolladr, dolc);
break;
case SYSSET:
if (a1) {
int argc;
- argc =
- options(argn,
- com);
- if (argc > 1) {
- setargs(com
- +
- argn
- -
- argc);
- ;
- }
- } else if (((COMPTR) t)->comset == 0) { /*scan name chain and print */
+ argc = options(argn, (const char **)com);
+ if (argc > 1)
+ setargs((const char **)com + argn - argc);
+ } else if (((COMPTR) t)->comset == 0)
+ /* Scan name chain and print */
namscan(printnam);
- ;
- }
break;
case SYSRDONLY:
exitval = N_RDONLY;
case SYSXPORT:
- if (exitval == 0) {
- exitval =
- N_EXPORT;;
- }
+ if (exitval == 0)
+ exitval = N_EXPORT;;
if (a1) {
- while (*++com) {
- attrib
- (lookup
- (*com),
- exitval);
- }
+ while (*++com)
+ attrib(lookup(*com), exitval);
} else {
namscan(printflg);
- ;
}
exitval = 0;
break;
case SYSEVAL:
- if (a1) {
- execexp(a1,
- &com[2]);
- ;
- }
+ if (a1)
+ execexp(a1, (UFD)&com[2]); /* FIXME */
break;
case SYSUMASK:
if (a1) {
int c, i;
i = 0;
- while ((c =
- *a1++) >=
- '0'
- && c <= '7')
- i = (i <<
- 3) +
- c -
- '0';
+ while ((c = *a1++) >= '0' && c <= '7')
+ i = (i << 3) + c - '0';
umask(i);
} else {
int i, j;
- umask(i =
- umask(0));
+ umask(i = umask(0));
prc('0');
- for (j = 6; j >= 0;
- j -= 3)
- prc(((i >>
- j) &
- 07) +
- '0');
+ for (j = 6; j >= 0; j -= 3)
+ prc(((i >> j) & 07) + '0');
newline();
}
break;
default:
- internal =
- builtin(argn, com);
+ internal = builtin(argn, com);
}
if (internal) {
- if (io) {
+ if (io)
error(illegal);
- }
chktrap();
break;
- ;
}
- } else if (t->treio == 0) {
+ } else if (t->treio == 0)
break;
- ;
- }
}
case TFORK:
- if (execflg && (treeflgs & (FAMP | FPOU)) == 0) {
+ if (execflg && (treeflgs & (FAMP | FPOU)) == 0)
parent = 0;
- } else {
+ else {
while ((parent = fork()) == -1) {
sigchk();
alarm(10);
pause();
}
- ;
}
if (parent) { /* This is the parent branch of fork; */
if (treeflgs & FPRS && flags & ttyflg) {
prn(parent);
newline();
- ;
}
- if (treeflgs & FPCL) {
+ if (treeflgs & FPCL)
closepipe(pf1);
- }
- if ((treeflgs & (FAMP | FPOU)) == 0) {
+ if ((treeflgs & (FAMP | FPOU)) == 0)
await(parent);
- } else if ((treeflgs & FAMP) == 0) {
+ else if ((treeflgs & FAMP) == 0)
post(parent);
- } else {
+ else
assnum(&pcsadr, parent);
- ;
- }
chktrap();
break;
-
-
} else { /* this is the forked branch (child) of execute */
flags |= forked;
iotemp = 0;
/* except for those `lost' by trap */
oldsigs();
if (treeflgs & FINT) {
- signal(INTR, 1);
- signal(QUIT, 1);
- ;
+ signal(INTR, SIG_IGN);
+ signal(QUIT, SIG_IGN);
}
/* pipe in or out */
if (treeflgs & FPIN) {
sh_rename(pf1[INPIPE], 0);
close(pf1[OTPIPE]);
- ;
}
if (treeflgs & FPOU) {
sh_rename(pf2[OTPIPE], 1);
close(pf2[INPIPE]);
- ;
}
/* default std input for & */
- if (treeflgs & FINT && ioset == 0) {
+ if (treeflgs & FINT && ioset == 0)
sh_rename(chkopen(devnull), 0);
- ;
- }
/* io redirection */
initio(t->treio);
- if (type != TCOM) {
- execute(((FORKPTR) t)->forktre, 1);
- } else if (com[0] != ENDARGS) {
- setlist(((COMPTR) t)->comset,
- N_EXPORT);
- execa(com);
- ;
+ if (type != TCOM)
+ execute(((FORKPTR) t)->forktre, 1, NULL, NULL);
+ else if (com[0] != ENDARGS) {
+ setlist(((COMPTR) t)->comset, N_EXPORT);
+ execa((const char **)com);
}
done();
- ;
}
case TPAR:
sh_rename(dup(2), output);
- execute(((PARPTR) t)->partre, execflg);
+ execute(((PARPTR) t)->partre, execflg, NULL, NULL);
done();
case TFIL:
- {
- int pv[2];
- chkpipe(pv);
- if (execute
- (((LSTPTR) t)->lstlef, 0, pf1,
- pv) == 0) {
- execute(((LSTPTR) t)->lstrit,
- execflg, pv, pf2);
- } else {
- closepipe(pv);
- ;
- }
- }
+ {
+ int pv[2];
+ chkpipe(pv);
+ if (execute(((LSTPTR) t)->lstlef, 0, pf1, pv) == 0)
+ execute(((LSTPTR) t)->lstrit, execflg, pv, pf2);
+ else
+ closepipe(pv);
break;
-
+ }
case TLST:
- execute(((LSTPTR) t)->lstlef, 0);
- execute(((LSTPTR) t)->lstrit, execflg);
+ execute(((LSTPTR) t)->lstlef, 0, NULL, NULL);
+ execute(((LSTPTR) t)->lstrit, execflg, NULL, NULL);
break;
case TAND:
- if (execute(((LSTPTR) t)->lstlef, 0) == 0) {
- execute(((LSTPTR) t)->lstrit, execflg);
- ;
- }
+ if (execute(((LSTPTR) t)->lstlef, 0, NULL, NULL) == 0)
+ execute(((LSTPTR) t)->lstrit, execflg, NULL, NULL);
break;
case TORF:
- if (execute(((LSTPTR) t)->lstlef, 0) != 0) {
- execute(((LSTPTR) t)->lstrit, execflg);
- ;
- }
+ if (execute(((LSTPTR) t)->lstlef, 0, NULL, NULL) != 0)
+ execute(((LSTPTR) t)->lstrit, execflg, NULL, NULL);
break;
case TFOR:
- {
- NAMPTR n = lookup(((FORPTR) t)->fornam);
- STRING *args;
- DOLPTR argsav = 0;
-
- if (((FORPTR) t)->forlst == 0) {
- args = dolv + 1;
- argsav = useargs();
- } else {
- ARGPTR schain = gchain;
- gchain = 0;
- trim((args =
- scan(getarg
- (((FORPTR) t)->
- forlst)))[0]);
- gchain = schain;
- ;
- }
- loopcnt++;
- while (*args != ENDARGS && execbrk == 0) {
- assign(n, *args++);
- execute(((FORPTR) t)->fortre, 0);
- if (execbrk < 0) {
- execbrk = 0;
- };
- }
- if (breakcnt) {
- breakcnt--;
+ {
+ NAMPTR n = lookup(((FORPTR) t)->fornam);
+ char **args;
+ DOLPTR argsav = 0;
+
+ if (((FORPTR) t)->forlst == 0) {
+ args = (char **)dolv + 1;
+ argsav = useargs();
+ } else {
+ ARGPTR schain = gchain;
+ gchain = 0;
+ trim((args = scan(getarg(((FORPTR) t)->forlst)))[0]);
+ gchain = schain;
+ }
+ loopcnt++;
+ while (*args != ENDARGS && execbrk == 0) {
+ assign(n, *args++);
+ execute(((FORPTR) t)->fortre, 0, NULL, NULL);
+ if (execbrk < 0) {
+ execbrk = 0;
}
- execbrk = breakcnt;
- loopcnt--;
- argfor = freeargs(argsav);
}
- break;
+ if (breakcnt)
+ breakcnt--;
+ execbrk = breakcnt;
+ loopcnt--;
+ argfor = freeargs(argsav);
+ break;
+ }
case TWH:
case TUN:
- {
- int i = 0;
-
- loopcnt++;
- while (execbrk == 0
- && (execute(((WHPTR) t)->whtre, 0)
- == 0) == (type == TWH)
- ) {
- i = execute(((WHPTR) t)->dotre, 0);
- if (execbrk < 0) {
- execbrk = 0;
- };
- }
- if (breakcnt) {
- breakcnt--;
- }
- execbrk = breakcnt;
- loopcnt--;
- exitval = i;
+ {
+ int i = 0;
+
+ loopcnt++;
+ while (execbrk == 0 && (execute(((WHPTR) t)->whtre, 0, NULL, NULL) == 0) == (type == TWH)) {
+ i = execute(((WHPTR) t)->dotre, 0, NULL, NULL);
+ if (execbrk < 0)
+ execbrk = 0;
}
+ if (breakcnt)
+ breakcnt--;
+
+ execbrk = breakcnt;
+ loopcnt--;
+ exitval = i;
break;
+ }
case TIF:
- if (execute(((IFPTR) t)->iftre, 0) == 0) {
- execute(((IFPTR) t)->thtre, execflg);
- } else {
- execute(((IFPTR) t)->eltre, execflg);
- ;
- }
+ if (execute(((IFPTR) t)->iftre, 0, NULL, NULL) == 0)
+ execute(((IFPTR) t)->thtre, execflg, NULL, NULL);
+ else
+ execute(((IFPTR) t)->eltre, execflg, NULL, NULL);
break;
case TSW:
- {
- register STRING r =
- mactrim(((SWPTR) t)->swarg);
- t = (TREPTR) ((SWPTR) t)->swlst;
- while (t) {
- ARGPTR rex = ((REGPTR) t)->regptr;
- while (rex) {
- register STRING s;
- if (gmatch
- (r, s =
- macro(rex->argval))
- || (trim(s), eq(r, s))
- ) {
- execute(((REGPTR)
- t)->
- regcom, 0);
- t = 0;
- break;
- } else {
- rex =
- ((ARGPTR)
- rex)->argnxt;
- ;
- }
- ;
- }
- if (t) {
- t = (TREPTR) ((REGPTR) t)->
- regnxt;
- };
+ {
+ register char *r = mactrim(((SWPTR) t)->swarg);
+ t = (TREPTR) ((SWPTR) t)->swlst;
+ while (t) {
+ ARGPTR rex = ((REGPTR) t)->regptr;
+ while (rex) {
+ register char *s;
+ if (gmatch(r, s = macro(rex->argval)) || (trim(s), eq(r, s))) {
+ execute(((REGPTR)t)->regcom, 0, NULL, NULL);
+ t = 0;
+ break;
+ } else
+ rex = ((ARGPTR)rex)->argnxt;
}
+ if (t)
+ t = (TREPTR) ((REGPTR) t)->regnxt;
}
- break;
+ }
+ break;
+
}
exitset();
- ;
}
sigchk();
}
-execexp(s, f)
-STRING s;
-UFD f;
+void execexp(char *s, UFD f)
{
FILEBLK fb;
push(&fb);
fb.feval = (STRING *) f;
} else if (f >= 0) {
initf(f);
- ;
}
- execute(cmd(NL, NLFLG | MTFLG), 0);
+ execute(cmd(NL, NLFLG | MTFLG), 0, NULL, NULL);
pop();
}
public / FUZIX.git / commitdiff