exit(1);
}
-char *prefix(char *begin, char *full)
+const char *prefix(const char *begin, const char *full)
{
int c;
while (c = *begin++) {
return (full);
}
-int makeutime(char *pp)
+int makeutime(const char *pp)
{
register int val;
- register char *p;
+ register const char *p;
/* p points to a user time */
p = pp;
/* first of all, what's today */
time_t tm;
int found = -1;
- char **ps;
+ const char **ps;
struct tm *detail;
struct monstr *pt;
}
}
-int main(int argc, char *argv[])
+int main(int argc, const char *argv[])
{
register int c;
char pwbuf[100];
char *page[PL];
char lbuff[LINELN], *line;
+char fbuff[BUFSIZ];
int bflag, xflag, fflag;
int half;
int cp, lp;
int ll, llh, mustwr;
int pcp = 0;
-char *pgmname;
+const char *pgmname;
void outc(char c)
int i;
int greek;
register int c;
- char fbuff[BUFSIZ];
setbuf(stdout, fbuff);
pgmname = argv[0];
for (i = 1; i < argc; i++) {
- register char *p;
+ register const char *p;
if (*argv[i] != '-') {
fprintf(stderr, "%s: bad option %s\n",
pgmname, argv[i]);
FILE *ib1;
FILE *ib2;
+char lb1[LB], lb2[LB];
FILE *openfil(const char *s)
int main(int argc, const char *argv[])
{
int l;
- char lb1[LB], lb2[LB];
if (argc > 1) {
if (*argv[1] == '-' && argv[1][1] != 0) {
void init(void)
{
- register i, c;
+ register int i, c;
register char *cp;
register char *ocp;
register int n;
long seed;
strncpy(buf, pw, 8);
+ /* Overwrites the argv array so that the password doesn't show up in the
+ * process listing. */
while (*pw)
*pw++ = '\0';
buf[8] = buf[0];
t2[t1[i]&MASK] = i;
}
-int main(int argc, const char *argv[])
+int main(int argc, char *argv[])
{
int i, n1, n2;
#define EMPTYS if(stkerr != 0){printf("stack empty\n"); return(1);}
#define EMPTYSR(x) if(stkerr !=0){printf("stack empty\n");pushp(x);return(1);}
#define error(p) {printf(p); continue; }
-#define errorrt(p) {printf(p); return(1); }
+#define errorrt(p) {printf(p); return NULL; }
struct blk {
char *rd;
void sdump(char *s1, struct blk *hptr);
struct blk *copy(struct blk *hptr, int size);
struct blk *salloc(int size);
-int log2(long n);
+int intlog2(long n);
void load(void);
int cond(char c);
int command(void);
void pushp(struct blk *p);
void onintr(int sig);
void init(int argc, char *argv[]);
-struct blk *exp(struct blk *base, struct blk *ex);
-struct blk *sqrt(struct blk *p);
+struct blk *expr(struct blk *base, struct blk *ex);
+struct blk *squareroot(struct blk *p);
struct blk *removr(struct blk *p, int n);
int dscale(void);
struct blk *scalint(struct blk *p);
int fw, fw1, ll;
void (*outdit) (struct blk *, int);
int logo;
-int log10;
+int intlog10;
int count;
char *pp;
char *dummy;
savk = k;
}
arg1 = add0(p, n);
- arg2 = sqrt(arg1);
+ arg2 = squareroot(arg1);
sputc(arg2, savk);
pushp(arg2);
continue;
error("exp too big\n");
}
savk = sunputc(arg2);
- p = exp(arg2, arg1);
+ p = expr(arg2, arg1);
release(arg2);
rewind(arg1);
c = sgetc(arg1);
l = l * 100 + sbackc(q);
}
}
- logo = log2(l);
+ logo = intlog2(l);
obase = l;
release(basptr);
if (sign == 1)
p = salloc(0);
if (length(ddivr) == 0) {
pushp(ddivr);
+ /* BUG: this returns NULL, which will cause a crash later */
errorrt("divide by 0\n");
}
divsign = remsign = 0;
if (sfbeg(dr) == 1 || (sfbeg(dr) == 0 && sbackc(dr) == 0)) {
sputc(dr, skr);
pushp(dr);
+ /* BUG: this returns NULL, which will cause a crash later */
errorrt("divide by 0\n");
}
c = k - skd + skr;
return (r);
}
-struct blk *sqrt(struct blk *p)
+struct blk *squareroot(struct blk *p)
{
struct blk *t;
struct blk *r, *q, *s;
return (r);
}
-struct blk *exp(struct blk *base, struct blk *ex)
+struct blk *expr(struct blk *base, struct blk *ex)
{
register struct blk *r, *e, *p;
struct blk *e1, *t, *cp;
basptr = salloc(1);
sputc(basptr, 10);
obase = 10;
- log10 = log2(10L);
+ intlog10 = intlog2(10L);
ll = 70;
fw = 1;
fw1 = 0;
return;
}
create(strptr);
- dig = log10 * sc;
+ dig = intlog10 * sc;
dout = ((dig / 10) + dig) / logo;
dec = getdec(p, sc);
p = removc(p, sc);
t = add0(p, n);
q = salloc(1);
sputc(q, n);
- s = exp(inbas, q);
+ s = expr(inbas, q);
release(q);
q = div(t, s);
release(t);
return;
}
-int log2(long n)
+int intlog2(long n)
{
register int i;
void redef(struct blk *p)
{
- register offset;
+ register int offset;
register char *newp;
if ((int) p->beg & 01) {
void flsh(void)
{
- register c;
+ register int c;
if(obc) {
if(obc == obs)
fprintf(stderr,"bad arg: %s\n", string);
exit(0);
}
- if(conv == null && cflag&(LCASE|UCASE))
+ /* BUG: (void*) cast here is for a cc65 bug */
+ if(conv == (void*)null && cflag&(LCASE|UCASE))
conv = cnull;
if (ifile)
ibf = open(ifile, 0);
}
if (bs) {
ibs = obs = bs;
- if (conv == null)
+ /* BUG: (void*) cast here is for a cc65 bug */
+ if (conv == (void*)null)
fflag++;
}
if(ibs == 0 || obs == 0) {
int argc;
-char **argv;
+const char **argv;
char fname[50];
FILE *files[15];
int main(int ac, const char *av[])
{
register int i;
- register char *p;
+ register const char *p;
static char onechar[2] = "X";
argc = ac - 1;
-/* UNIX V7 source code: see /COPYRIGHT or www.tuhs.org for details. */
+const /* UNIX V7 source code: see /COPYRIGHT or www.tuhs.org for details. */
/* ANSIfied for FUZIX */
/* diff - differential file comparison
int anychange = 0;
char *empty = "";
int bflag;
+char buf[512];
char *tempfile; /*used when comparing against std input */
char *dummy; /*used in resetting storage search ptr */
done();
}
-void mesg(char *s, char *t)
+void mesg(const char *s, const char *t)
{
fprintf(stderr, "diff: %s%s\n", s, t);
}
int skipline(int f)
{
- register i;
+ register int i;
for (i = 1; getc(input[f]) != '\n'; i++);
return (i);
}
void filename(char **pa1, char **pa2)
{
register char *a1, *b1, *a2;
- char buf[512];
struct stat stbuf;
int i, f;
a1 = *pa1;
{
long sum;
register unsigned shift;
- register space;
- register t;
+ register int space;
+ register int t;
sum = 1;
space = 0;
if (!bflag)
return ((short) low(sum) + (short) high(sum));
}
-void prepare(int i, char *arg)
+void prepare(int i, const char *arg)
{
register struct line *p;
- register j, h;
+ register int j, h;
if ((input[i] = fopen(arg, "r")) == NULL) {
mesg("cannot open ", arg);
done();
void prune(void)
{
- register i, j;
+ register int i, j;
for (pref = 0; pref < len[0] && pref < len[1] &&
file[0][pref + 1].value == file[1][pref + 1].value; pref++);
for (suff = 0; suff < len[0] - pref && suff < len[1] - pref &&
to confounding by hashing (which result in "jackpot")
2. collect random access indexes to the two files */
-void check(const char *argv[])
+void check(char *argv[])
{
register int i, j;
int jackpot;
prints(".\n");
}
-void output(const char *argv[])
+void output(char *argv[])
{
int m;
register int i0, i1, j1;
change(1, 0, 1, len[1]);
}
-int main(int argc, const char *argv[])
+int main(int argc, char *argv[])
{
register int k;
- const char **args;
+ char **args;
args = argv;
if (argc > 3 && *argv[1] == '-') {
bflag = 1;
break;
case 'h':
- execv("/usr/lib/diffh", args);
+ execv("/usr/lib/diffh", (const char**)args);
mesg("cannot find diffh", empty);
done();
}
struct diff d23[NC];
struct diff de[NC];
char line[256];
+char block[512];
FILE *fp[3];
int linct[3] = { 0, 0, 0 };
void repos(int nchar)
{
- register i;
+ register int i;
for (i = 0; i < 2; i++)
fseek(fp[i], (long) -nchar, 1);
}
int getline(FILE * b)
{
- register i, c;
+ register int i, c;
for (i = 0; i < sizeof(line) - 1; i++) {
c = getc(b);
if (c == EOF)
/* regurgitate */
void edscript(int n)
{
- register j, k;
- char block[512];
+ register int j, k;
for (n = n; n > 0; n--) {
prange(&de[n].old);
fseek(fp[2], (long) de[n].new.from, 0);
int easysynch(void)
{
int i, j;
- register k, m;
+ register int k, m;
char *s0, *s1;
for (i = j = 1; i < RANGE && j < RANGE; i++, j++) {
s0 = getl(0, n0 + i);
#define F1 0
#define F2 1
#define NFLD 20 /* max field per line */
-#define comp() cmp(ppi[F1][j1],ppi[F2][j2])
+#define comp() cmp(ppi[F1][jf1],ppi[F2][jf2])
FILE *f[2];
char buf[2][BUFSIZ]; /*input lines */
char *ppi[2][NFLD]; /* pointers to fields in lines */
char *s1,*s2;
-int j1 = 1; /* join of this field of file 1 */
-int j2 = 1; /* join of this field of file 2 */
+int jf1 = 1; /* join of this field of file 1 */
+int jf2 = 1; /* join of this field of file 2 */
int olist[2*NFLD]; /* output these fields */
int olistf[2*NFLD]; /* from these files */
int no; /* number of entries in olist */
const char *temp;
if (no <= 0) { /* default case */
- printf("%s", on1? ppi[F1][j1]: ppi[F2][j2]);
+ printf("%s", on1? ppi[F1][jf1]: ppi[F2][jf2]);
for (i = 0; i < on1; i++)
- if (i != j1)
+ if (i != jf1)
printf("%c%s", sep1, ppi[F1][i]);
for (i = 0; i < on2; i++)
- if (i != j2)
+ if (i != jf2)
printf("%c%s", sep1, ppi[F2][i]);
printf("\n");
} else {
break;
case 'j':
if (argv[1][2] == '1')
- j1 = atoi(argv[2]);
+ jf1 = atoi(argv[2]);
else if (argv[1][2] == '2')
- j2 = atoi(argv[2]);
+ jf2 = atoi(argv[2]);
else
- j1 = j2 = atoi(argv[2]);
+ jf1 = jf2 = atoi(argv[2]);
argc--;
argv++;
break;
for (i = 0; i < no; i++)
olist[i]--; /* 0 origin */
if (argc != 3)
- errx(1, "usage: join [-j1 x -j2 y] [-o list] file1 file2");
- j1--;
- j2--; /* everyone else believes in 0 origin */
- s1 = ppi[F1][j1];
- s2 = ppi[F2][j2];
+ errx(1, "usage: join [-jf1 x -jf2 y] [-o list] file1 file2");
+ jf1--;
+ jf2--; /* everyone else believes in 0 origin */
+ s1 = ppi[F1][jf1];
+ s2 = ppi[F2][jf2];
if (argv[1][0] == '-')
f[F1] = stdin;
else if ((f[F1] = fopen(argv[1], "r")) == NULL)
return(c);
}
-pgetc(int i)
+int pgetc(int i)
{
register int c;
void print(char *fp, char **argp)
{
struct stat sbuf;
- register sncol;
+ register int sncol;
register const char *sheader;
register char *cbuf;
char linebuf[150], *cp;
char *getline(void)
{
- register c;
+ register int c;
register char *linep;
char *endlinep;
void getsort(void)
{
- register c;
+ register int c;
register char *tilde, *linep, *ref;
char *p1a, *p1b, *p2a, *p2b, *p3a, *p3b, *p4a, *p4b;
int w;
int main(int argc, char *argv[])
{
- register i, c;
+ register int i, c;
input = stdin;
do {
if (argc > 1) {
int main(int argc, const char *argv[])
{
- register i, c, f;
+ register int i, c, f;
int iflg = 0;
for(i=1; i<argc; i++)
/* FIXME: su - and other semantics of later su versions */
-int main(int argc, char *argv[])
+int main(int argc, const char *argv[])
{
- register const char **p;
+ register char **p;
const char *nptr;
char *password;
int badsw = 0;
int main(int argc, const char *argv[])
{
register unsigned sum;
- register i, c;
+ register int i, c;
register FILE *f;
register long nbytes;
int errflg = 0;
}
if (ferror(f)) {
errflg++;
+ /* BUG: cast here is to work around a cc65 bug */
fprintf(stderr, "sum: read error on %s\n",
- argc > 1 ? argv[i] : "-");
+ argc > 1 ? argv[i] : (const char*)"-");
}
printf("%05u%6ld", sum, (nbytes + BUFSIZ - 1) / BUFSIZ);
if (argc > 2)
exit(255);
}
-int length(char *s)
-{
- char *es = s;
- while (*es++);
- return (es - s - 1);
-}
-
-char *nxtarg(int mt)
+const char *nxtarg(int mt)
{
if (ap >= ac) {
if (mt) {
return (av[ap++]);
}
-int tio(char *a, int f)
+int tio(const char *a, int f)
{
/* FIXME: should use stat and parse permissions */
f = open(a, f);
return (0);
}
-int ftype(char *f)
+int ftype(const char *f)
{
struct stat statb;
return (FIL);
}
-int fsizep(char *f)
+int fsizep(const char *f)
{
struct stat statb;
if (stat(f, &statb) < 0)
int e3(void)
{
int p1;
- register char *a;
- char *p2;
+ register const char *a;
+ const char *p2;
int int1, int2;
- extern int exp(void);
+ extern int expr(void);
a = nxtarg(0);
if (EQ(a, "(")) {
- p1 = exp();
+ p1 = expr();
if (!EQ(nxtarg(0), ")"))
synbad(") expected", "");
return (p1);
return (!EQ(nxtarg(0), a));
if (EQ(a, "-l")) {
- int1 = length(p2);
+ int1 = strlen(p2);
p2 = nxtarg(0);
} else {
int1 = atoi(a);
return (p1);
}
-int exp(void)
+int expr(void)
{
int p1;
p1 = e1();
if (EQ(nxtarg(1), "-o"))
- return (p1 | exp());
+ return (p1 | expr());
ap--;
return (p1);
}
argv[ac] = 0;
if (ac <= 1)
exit(1);
- exit(exp()? 0 : 1);
+ exit(expr()? 0 : 1);
}
void printt(const char *s, long a)
{
char digit[9];
- register i;
+ register int i;
char c;
int nonzero;
{
struct tms buffer, obuffer;
int status;
- register p;
+ register int p;
time_t before, after;
if (argc <= 1)
/* turn a string into a node pointer
*/
-struct nodelist *index(const char *s)
+struct nodelist *stringindex(const char *s)
{
register struct nodelist *i;
register const char *t;
break;
if (x != 2)
error("odd data", empty);
- i = index(precedes);
- j = index(follows);
+ i = stringindex(precedes);
+ j = stringindex(follows);
if (i == j || present(i, j))
continue;
t = (struct predlist *) malloc(sizeof(struct predlist));
#define USERS 50
char mesg[3000];
+char buf[BUFSIZ];
int msize;
struct utmp utmp[USERS];
void sendmes(char *tty)
{
- register i;
- char t[50], buf[BUFSIZ];
+ register int i;
+ char t[50];
FILE *f;
i = fork();
int main(int argc, const char *argv[])
{
- register i;
+ register int i;
register struct utmp *p;
FILE *f;
void delete(int sig)
{
- if (rights + wrongs == 0.) {
+ if (rights + wrongs == 0) {
printf("\n");
exit(0);
}
{
/* pick and return one at random from the n choices in a */
/* The last one is moved to replace the one chosen */
- register j, t;
+ register int j, t;
if (n <= 0)
error("null choice");
/* uses the random number generator `rand' in the C library */
/* assumes that `srand' has already been called */
- register i;
+ register int i;
for (i = 0; i < DECK; ++i)
deck[i] = (i % 13) + 1; /* seed the deck */
int empty(HAND h)
{
- register i;
+ register int i;
for (i = 1; i <= CTYPE; ++i) {
if (h[i] != 0 && h[i] != 4)
void stats(void)
{
- register i, ct, b;
+ register int i, ct, b;
if (proflag)
printf("Pro level\n");
void phand(HAND h)
{
- register i, j;
+ register int i, j;
j = 0;
continue;
}
if (h[i]) {
- register k;
+ register int k;
k = h[i];
while (k--)
printf("%s ", cname[i]);
void instruct(void)
{
- register char **cpp;
+ register const char **cpp;
printf("\n");
void score(void)
{
- register my, your, i;
+ register int my, your, i;
my = your = 0;
int guess(void)
{
/* get the guess from the tty and return it... */
- register g, go;
+ register int g, go;
go = 0;
int myguess(void)
{
- register i, lg, t;
+ register int i, lg, t;
if (empty(myhand))
return (NOMORE);
{
/* hand hs has made a guess, g, directed towards ht */
/* v on indicates that the guess was made by the machine */
- register d;
+ register int d;
const char *sp, *tp;
sp = tp = "I";
for (;;) {
- register g;
+ register int g;
/* you make repeated guesses */
first[1] = ((uint32_t) t) >> 16;
srand((first[1] * first[0]) ^ first[1]);
}
- return ((rand() / 32768.0) * n);
+ return (((long)rand() / 32768L) * n);
}
int rin(void)
{
- register n, c;
+ register int n, c;
n = 0;
c = getchar();
return (n);
}
-int near(struct room *ap, int ahaz)
+int isnear(struct room *ap, int ahaz)
{
register struct room *p;
- register haz, i;
+ register int haz, i;
p = ap;
haz = ahaz;
int tunnel(int i)
{
register struct room *p;
- register n, j;
+ register int n, j;
int c;
c = 20;
goto loop;
}
for (i = 0; i < NTUNN; i++)
- if (near(&room[p->tunn[i]], WUMP))
+ if (isnear(&room[p->tunn[i]], WUMP))
goto nearwump;
- if (near(p, WUMP)) {
+ if (isnear(p, WUMP)) {
nearwump:
printf("I smell a wumpus\n");
}
- if (near(p, BAT))
+ if (isnear(p, BAT))
printf("Bats nearby\n");
- if (near(p, PIT))
+ if (isnear(p, PIT))
printf("I feel a draft\n");
printf("There are tunnels to");
for (i = 0; i < NTUNN; i++)
#include <stdlib.h>\r
#include <string.h>\r
#include <stdio.h>\r
+#include <errno.h>
\r
/* Find file in pathes:\r
* 1. /name or ./name or ../name is already qualified names\r
{
return execve(_findPath(pathP), &arg0, environ);
}
-#endif
\ No newline at end of file
+#else
+int execl(const char *pathP, const char *arg0, ...) \r
+{
+ /* BUG: this should be ENOSYS, but Fuzix doesn't have that yet */
+ errno = EINVAL;
+ return -1;
+}
+\r
+int execlp(const char *pathP, const char *arg0, ...) \r
+{
+ /* BUG: this should be ENOSYS, but Fuzix doesn't have that yet */
+ errno = EINVAL;
+ return -1;
+}
+#endif
public / FUZIX.git / commitdiff