URL
https://opencores.org/ocsvn/eco32/eco32/trunk
Subversion Repositories eco32
Compare Revisions
- This comparison shows the changes necessary to convert path
/eco32/tags/eco32-0.26/lcc/etc
- from Rev 92 to Rev 270
- ↔ Reverse comparison
Rev 92 → Rev 270
/eco32-eos32.c
0,0 → 1,97
/* Code for ECO32 under EOS32, University of Applied Sciences Giessen */ |
|
#include <string.h> |
|
char *suffixes[] = { ".c", ".i", ".s", ".o", ".out", 0 }; |
|
char inputs[256] = ""; |
|
char *cpp[] = { |
LCCDIR "cpp", |
"-D__STDC__=1", |
"-DLANGUAGE_C", |
"-D_LANGUAGE_C", |
"-DECO32", |
"-D_ECO32", |
"-Deco32", |
"-DUNIX", |
"-D_UNIX", |
"-Dunix", |
"$1", /* preprocessor include directory */ |
"$2", /* preprocessor input file */ |
"$3", /* preprocessor output file */ |
0 |
}; |
|
char *com[] = { |
LCCDIR "rcc", |
"-target=eco32/eos32", |
"$1", /* other options handed through */ |
"$2", /* compiler input file */ |
"$3", /* compiler output file */ |
"", |
0 |
}; |
|
char *include[] = { "-I" "/usr/include", 0 }; |
|
char *as[] = { |
LCCDIR "as", |
"-o", "$3", /* assembler output file */ |
"$1", /* other options handed through */ |
"$2", /* assembler input file */ |
0 |
}; |
|
char *ld[] = { |
LCCDIR "ld", |
"-o", "$3", /* linker output file */ |
"$1", /* other options handed through */ |
"/usr/lib/c0.o", |
"$2", |
"/usr/lib/setjmp.o", |
"/usr/lib/eos32sys.o", |
"/usr/lib/eos32lib.o", |
"/usr/lib/assert.o", |
"/usr/lib/ctype.o", |
"/usr/lib/errno.o", |
"/usr/lib/math.o", |
"/usr/lib/signal.o", |
"/usr/lib/stdio.o", |
"/usr/lib/stdlib.o", |
"/usr/lib/string.o", |
"/usr/lib/time.o", |
"/usr/lib/c1.o", |
0 |
}; |
|
extern char *concat(char *, char *); |
|
int option(char *arg) { |
if (strncmp(arg, "-lccdir=", 8) == 0) { |
cpp[0] = concat(&arg[8], "/cpp"); |
include[0] = concat("-I", concat(&arg[8], "/include")); |
com[0] = concat(&arg[8], "/rcc"); |
ld[18] = concat("-L", &arg[8]); |
} else if (strcmp(arg, "-kernel") == 0) { |
ld[8] = 0; |
ld[7] = ld[5]; |
ld[6] = ld[3]; |
ld[5] = ld[2]; |
ld[4] = ld[1]; |
ld[3] = "0xC0010000"; |
ld[2] = "-rc"; |
ld[1] = "-h"; |
} else if (strcmp(arg, "-rom") == 0) { |
ld[8] = 0; |
ld[7] = ld[5]; |
ld[6] = ld[3]; |
ld[5] = ld[2]; |
ld[4] = ld[1]; |
ld[3] = "0xE0000000"; |
ld[2] = "-rc"; |
ld[1] = "-h"; |
} else |
return 0; |
return 1; |
} |
/eco32-linux.c
0,0 → 1,97
/* Code for ECO32 under Linux, University of Applied Sciences Giessen */ |
|
#include <string.h> |
|
char *suffixes[] = { ".c", ".i", ".s", ".o", ".out", 0 }; |
|
char inputs[256] = ""; |
|
char *cpp[] = { |
LCCDIR "cpp", |
"-D__STDC__=1", |
"-DLANGUAGE_C", |
"-D_LANGUAGE_C", |
"-DECO32", |
"-D_ECO32", |
"-Deco32", |
"-DUNIX", |
"-D_UNIX", |
"-Dunix", |
"$1", /* preprocessor include directory */ |
"$2", /* preprocessor input file */ |
"$3", /* preprocessor output file */ |
0 |
}; |
|
char *com[] = { |
LCCDIR "rcc", |
"-target=eco32/linux", |
"$1", /* other options handed through */ |
"$2", /* compiler input file */ |
"$3", /* compiler output file */ |
"", |
0 |
}; |
|
char *include[] = { "-I" LCCDIR "../include", 0 }; |
|
char *as[] = { |
LCCDIR "as", |
"-o", "$3", /* assembler output file */ |
"$1", /* other options handed through */ |
"$2", /* assembler input file */ |
0 |
}; |
|
char *ld[] = { |
LCCDIR "ld", |
"-o", "$3", /* linker output file */ |
"$1", /* other options handed through */ |
LCCDIR "../lib/c0.o", |
"$2", |
LCCDIR "../lib/setjmp.o", |
LCCDIR "../lib/eos32sys.o", |
LCCDIR "../lib/eos32lib.o", |
LCCDIR "../lib/assert.o", |
LCCDIR "../lib/ctype.o", |
LCCDIR "../lib/errno.o", |
LCCDIR "../lib/math.o", |
LCCDIR "../lib/signal.o", |
LCCDIR "../lib/stdio.o", |
LCCDIR "../lib/stdlib.o", |
LCCDIR "../lib/string.o", |
LCCDIR "../lib/time.o", |
LCCDIR "../lib/c1.o", |
0 |
}; |
|
extern char *concat(char *, char *); |
|
int option(char *arg) { |
if (strncmp(arg, "-lccdir=", 8) == 0) { |
cpp[0] = concat(&arg[8], "/cpp"); |
include[0] = concat("-I", concat(&arg[8], "/include")); |
com[0] = concat(&arg[8], "/rcc"); |
ld[18] = concat("-L", &arg[8]); |
} else if (strcmp(arg, "-kernel") == 0) { |
ld[8] = 0; |
ld[7] = ld[5]; |
ld[6] = ld[3]; |
ld[5] = ld[2]; |
ld[4] = ld[1]; |
ld[3] = "0xC0010000"; |
ld[2] = "-rc"; |
ld[1] = "-h"; |
} else if (strcmp(arg, "-rom") == 0) { |
ld[8] = 0; |
ld[7] = ld[5]; |
ld[6] = ld[3]; |
ld[5] = ld[2]; |
ld[4] = ld[1]; |
ld[3] = "0xE0000000"; |
ld[2] = "-rc"; |
ld[1] = "-h"; |
} else |
return 0; |
return 1; |
} |
/eco32-netbsd.c
0,0 → 1,97
/* Code for ECO32 under NetBSD, University of Applied Sciences Giessen */ |
|
#include <string.h> |
|
char *suffixes[] = { ".c", ".i", ".s", ".o", ".out", 0 }; |
|
char inputs[256] = ""; |
|
char *cpp[] = { |
LCCDIR "cpp", |
"-D__STDC__=1", |
"-DLANGUAGE_C", |
"-D_LANGUAGE_C", |
"-DECO32", |
"-D_ECO32", |
"-Deco32", |
"-DUNIX", |
"-D_UNIX", |
"-Dunix", |
"$1", /* preprocessor include directory */ |
"$2", /* preprocessor input file */ |
"$3", /* preprocessor output file */ |
0 |
}; |
|
char *com[] = { |
LCCDIR "rcc", |
"-target=eco32/netbsd", |
"$1", /* other options handed through */ |
"$2", /* compiler input file */ |
"$3", /* compiler output file */ |
"", |
0 |
}; |
|
char *include[] = { "-I" LCCDIR "../include", 0 }; |
|
char *as[] = { |
LCCDIR "as", |
"-o", "$3", /* assembler output file */ |
"$1", /* other options handed through */ |
"$2", /* assembler input file */ |
0 |
}; |
|
char *ld[] = { |
LCCDIR "ld", |
"-o", "$3", /* linker output file */ |
"$1", /* other options handed through */ |
LCCDIR "../lib/c0.o", |
"$2", |
LCCDIR "../lib/setjmp.o", |
LCCDIR "../lib/eos32sys.o", |
LCCDIR "../lib/eos32lib.o", |
LCCDIR "../lib/assert.o", |
LCCDIR "../lib/ctype.o", |
LCCDIR "../lib/errno.o", |
LCCDIR "../lib/math.o", |
LCCDIR "../lib/signal.o", |
LCCDIR "../lib/stdio.o", |
LCCDIR "../lib/stdlib.o", |
LCCDIR "../lib/string.o", |
LCCDIR "../lib/time.o", |
LCCDIR "../lib/c1.o", |
0 |
}; |
|
extern char *concat(char *, char *); |
|
int option(char *arg) { |
if (strncmp(arg, "-lccdir=", 8) == 0) { |
cpp[0] = concat(&arg[8], "/cpp"); |
include[0] = concat("-I", concat(&arg[8], "/include")); |
com[0] = concat(&arg[8], "/rcc"); |
ld[18] = concat("-L", &arg[8]); |
} else if (strcmp(arg, "-kernel") == 0) { |
ld[8] = 0; |
ld[7] = ld[5]; |
ld[6] = ld[3]; |
ld[5] = ld[2]; |
ld[4] = ld[1]; |
ld[3] = "0xC0010000"; |
ld[2] = "-rc"; |
ld[1] = "-h"; |
} else if (strcmp(arg, "-rom") == 0) { |
ld[8] = 0; |
ld[7] = ld[5]; |
ld[6] = ld[3]; |
ld[5] = ld[2]; |
ld[4] = ld[1]; |
ld[3] = "0xE0000000"; |
ld[2] = "-rc"; |
ld[1] = "-h"; |
} else |
return 0; |
return 1; |
} |
/bprint.c
0,0 → 1,214
#include "profio.c" |
#include <assert.h> |
#include <ctype.h> |
#include <stdio.h> |
#include <stdlib.h> |
#include <string.h> |
|
/* bprint [ -c | -Idir... | -f | -b | -n ] [ file... ] |
* annotate listings of files with prof.out data |
*/ |
|
static char rcsid2[] = "$Id: bprint.c,v 4.1 2002/08/28 23:12:20 drh Exp $"; |
|
#define NDIRS (sizeof dirs/sizeof dirs[0] - 1) |
#define NELEMS(a) ((int)(sizeof (a)/sizeof ((a)[0]))) |
|
char *progname; |
int number; |
char *dirs[20]; |
int fcount; |
|
void *alloc(unsigned); |
void emitdata(char *); |
void printfile(struct file *, int); |
void printfuncs(struct file *, int); |
|
void *allocate(unsigned long n, unsigned a) { return alloc(n); } |
|
void *newarray(unsigned long m, unsigned long n, unsigned a) { |
return alloc(m*n); |
} |
|
int main(int argc, char *argv[]) { |
int i; |
struct file *p; |
void (*f)(struct file *, int) = printfile; |
|
progname = argv[0]; |
if ((i = process("prof.out")) <= 0) { |
fprintf(stderr, "%s: can't %s `%s'\n", progname, |
i == 0 ? "open" : "interpret", "prof.out"); |
exit(1); |
} |
for (i = 1; i < argc && *argv[i] == '-'; i++) |
if (strcmp(argv[i], "-c") == 0) { |
emitdata("prof.out"); |
exit(0); |
} else if (strcmp(argv[i], "-b") == 0) |
f = printfile; |
else if (strcmp(argv[i], "-f") == 0) { |
fcount++; |
f = printfuncs; |
} else if (strcmp(argv[i], "-n") == 0) |
number++; |
else if (strncmp(argv[i], "-I", 2) == 0) { |
int j; |
for (j = 0; j < NDIRS && dirs[j]; j++) |
; |
if (j < NDIRS) |
dirs[j] = &argv[i][2]; |
else |
fprintf(stderr, "%s: too many -I options\n", progname); |
} else { |
fprintf(stderr, "usage: %s [ -c | -b | -n | -f | -Idir... ] [ file... ]\n", progname); |
exit(1); |
} |
for (p = filelist; p; p = p->link) |
qsort(p->counts, p->count, sizeof *p->counts, compare); |
if (i < argc) { |
int nf = i < argc - 1 ? 1 : 0; |
for ( ; i < argc; i++, nf ? nf++ : 0) |
if (p = findfile(string(argv[i]))) |
(*f)(p, nf); |
else |
fprintf(stderr, "%s: no data for `%s'\n", progname, argv[i]); |
} else { |
int nf = filelist && filelist->link ? 1 : 0; |
for (p = filelist; p; p = p->link, nf ? nf++ : 0) |
(*f)(p, nf); |
} |
return 0; |
} |
|
/* alloc - allocate n bytes or die */ |
void *alloc(unsigned n) { |
void *new = malloc(n); |
|
assert(new); |
return new; |
} |
|
/* emitdata - write prof.out data to file */ |
void emitdata(char *file) { |
FILE *fp; |
|
if (fp = fopen(file, "w")) { |
struct file *p; |
for (p = filelist; p; p = p->link) { |
int i; |
struct func *q; |
struct caller *r; |
fprintf(fp, "1\n%s\n", p->name); |
for (i = 0, q = p->funcs; q; i++, q = q->link) |
if (r = q->callers) |
for (i--; r; r = r->link) |
i++; |
fprintf(fp, "%d\n", i); |
for (q = p->funcs; q; q = q->link) |
if (q->count.count == 0 || !q->callers) |
fprintf(fp, "%s 1 %d %d %d ? ? 0 0\n", q->name, q->count.x, |
q->count.y, q->count.count); |
else |
for (r = q->callers; r; r = r->link) |
fprintf(fp, "%s 1 %d %d %d %s %s %d %d\n", q->name, q->count.x, |
q->count.y, r->count, r->name, r->file, r->x, r->y); |
fprintf(fp, "%d\n", p->count); |
for (i = 0; i < p->count; i++) |
fprintf(fp, "1 %d %d %d\n", p->counts[i].x, |
p->counts[i].y, p->counts[i].count); |
} |
fclose(fp); |
} else |
fprintf(stderr, "%s: can't create `%s'\n", progname, file); |
} |
|
/* openfile - open name for reading, searching -I directories */ |
FILE *openfile(char *name) { |
int i; |
FILE *fp; |
|
if (*name != '/') |
for (i = 0; dirs[i]; i++) { |
char buf[200]; |
sprintf(buf, "%s/%s", dirs[i], name); |
if (fp = fopen(buf, "r")) |
return fp; |
} |
return fopen(name, "r"); |
} |
|
/* printfile - print annotated listing for p */ |
void printfile(struct file *p, int nf) { |
int lineno; |
FILE *fp; |
char *s, buf[512]; |
struct count *u = p->counts, *r, *uend; |
|
if (u == 0 || p->count <= 0) |
return; |
uend = &p->counts[p->count]; |
if ((fp = openfile(p->name)) == NULL) { |
fprintf(stderr, "%s: can't open `%s'\n", progname, p->name); |
return; |
} |
if (nf) |
printf("%s%s:\n\n", nf == 1 ? "" : "\f", p->name); |
for (lineno = 1; fgets(buf, sizeof buf, fp); lineno++) { |
if (number) |
printf("%d\t", lineno); |
while (u < uend && u->y < lineno) |
u++; |
for (s = buf; *s; ) { |
char *t = s + 1; |
while (u < uend && u->y == lineno && u->x < s - buf) |
u++; |
if (isalnum(*s) || *s == '_') |
while (isalnum(*t) || *t == '_') |
t++; |
while (u < uend && u->y == lineno && u->x < t - buf) { |
printf("<%d>", u->count); |
for (r = u++; u < uend && u->x == r->x && u->y == r->y && u->count == r->count; u++) |
; |
} |
while (s < t) |
putchar(*s++); |
} |
if (*s) |
printf("%s", s); |
} |
fclose(fp); |
} |
|
/* printfuncs - summarize data for functions in p */ |
void printfuncs(struct file *p, int nf) { |
struct func *q; |
|
if (nf) |
printf("%s:\n", p->name); |
for (q = p->funcs; q; q = q->link) |
if (fcount <= 1 || q->count.count == 0 || !q->callers) |
printf("%d\t%s\n", q->count.count, q->name); |
else { |
struct caller *r; |
for (r = q->callers; r; r = r->link) |
printf("%d\t%s\tfrom %s\tin %s:%d.%d\n", r->count, q->name, r->name, |
r->file, r->y, r->x + 1); |
} |
|
} |
|
/* string - save a copy of str, if necessary */ |
char *string(const char *str) { |
static struct string { struct string *link; char str[1]; } *list; |
struct string *p; |
|
for (p = list; p; p = p->link) |
if (strcmp(p->str, str) == 0) |
return p->str; |
p = alloc(strlen(str) + sizeof *p); |
strcpy(p->str, str); |
p->link = list; |
list = p; |
return p->str; |
} |
/linux.c
0,0 → 1,61
/* x86s running Linux */ |
|
#include <string.h> |
|
static char rcsid[] = "$Id: linux.c,v 1.5 1998/09/16 20:41:09 drh Exp $"; |
|
#ifndef LCCDIR |
#define LCCDIR "/usr/local/lib/lcc/" |
#endif |
|
char *suffixes[] = { ".c", ".i", ".s", ".o", ".out", 0 }; |
char inputs[256] = ""; |
char *cpp[] = { LCCDIR "gcc/cpp", |
"-U__GNUC__", "-D_POSIX_SOURCE", "-D__STDC__=1", "-D__STRICT_ANSI__", |
"-Dunix", "-Di386", "-Dlinux", |
"-D__unix__", "-D__i386__", "-D__linux__", "-D__signed__=signed", |
"$1", "$2", "$3", 0 }; |
char *include[] = {"-I" LCCDIR "include", "-I" LCCDIR "gcc/include", "-I/usr/include", 0 }; |
char *com[] = {LCCDIR "rcc", "-target=x86/linux", "$1", "$2", "$3", 0 }; |
char *as[] = { "/usr/bin/as", "-o", "$3", "$1", "$2", 0 }; |
char *ld[] = { |
/* 0 */ "/usr/bin/ld", "-m", "elf_i386", "-dynamic-linker", |
/* 4 */ "/lib/ld-linux.so.2", "-o", "$3", |
/* 7 */ "/usr/lib/crt1.o", "/usr/lib/crti.o", |
/* 9 */ LCCDIR "/gcc/crtbegin.o", |
"$1", "$2", |
/* 12 */ "-L" LCCDIR, |
/* 13 */ "-llcc", |
/* 14 */ "-L" LCCDIR "/gcc", "-lgcc", "-lc", "-lm", |
/* 18 */ "", |
/* 19 */ LCCDIR "/gcc/crtend.o", "/usr/lib/crtn.o", |
0 }; |
|
extern char *concat(char *, char *); |
|
int option(char *arg) { |
if (strncmp(arg, "-lccdir=", 8) == 0) { |
cpp[0] = concat(&arg[8], "/gcc/cpp"); |
include[0] = concat("-I", concat(&arg[8], "/include")); |
include[1] = concat("-I", concat(&arg[8], "/gcc/include")); |
ld[9] = concat(&arg[8], "/gcc/crtbegin.o"); |
ld[12] = concat("-L", &arg[8]); |
ld[14] = concat("-L", concat(&arg[8], "/gcc")); |
ld[19] = concat(&arg[8], "/gcc/crtend.o"); |
com[0] = concat(&arg[8], "/rcc"); |
} else if (strcmp(arg, "-p") == 0 || strcmp(arg, "-pg") == 0) { |
ld[7] = "/usr/lib/gcrt1.o"; |
ld[18] = "-lgmon"; |
} else if (strcmp(arg, "-b") == 0) |
; |
else if (strcmp(arg, "-g") == 0) |
; |
else if (strncmp(arg, "-ld=", 4) == 0) |
ld[0] = &arg[4]; |
else if (strcmp(arg, "-static") == 0) { |
ld[3] = "-static"; |
ld[4] = ""; |
} else |
return 0; |
return 1; |
} |
/lcc.c
0,0 → 1,818
/* |
* lcc [ option ]... [ file | -llib ]... |
* front end for the ANSI C compiler |
*/ |
static char rcsid[] = "$Id: lcc.c,v 4.33 2001/06/28 22:19:58 drh Exp $"; |
|
#include <stdio.h> |
#include <stdarg.h> |
#include <stdlib.h> |
#include <string.h> |
#include <assert.h> |
#include <ctype.h> |
#include <signal.h> |
|
#ifndef TEMPDIR |
#define TEMPDIR "/tmp" |
#endif |
|
typedef struct list *List; |
struct list { /* circular list nodes: */ |
char *str; /* option or file name */ |
List link; /* next list element */ |
}; |
|
static void *alloc(int); |
static List append(char *,List); |
extern char *basepath(char *); |
static int callsys(char *[]); |
extern char *concat(char *, char *); |
static int compile(char *, char *); |
static void compose(char *[], List, List, List); |
static void error(char *, char *); |
static char *exists(char *); |
static char *first(char *); |
static int filename(char *, char *); |
static List find(char *, List); |
static void help(void); |
static void initinputs(void); |
static void interrupt(int); |
static void opt(char *); |
static List path2list(const char *); |
extern int main(int, char *[]); |
extern char *replace(const char *, int, int); |
static void rm(List); |
extern char *strsave(const char *); |
extern char *stringf(const char *, ...); |
extern int suffix(char *, char *[], int); |
extern char *tempname(char *); |
|
extern int access(char *, int); |
extern int getpid(void); |
|
extern char *cpp[], *include[], *com[], *as[],*ld[], inputs[], *suffixes[]; |
extern int option(char *); |
|
static int errcnt; /* number of errors */ |
static int Eflag; /* -E specified */ |
static int Sflag; /* -S specified */ |
static int cflag; /* -c specified */ |
static int verbose; /* incremented for each -v */ |
static List llist[2]; /* loader files, flags */ |
static List alist; /* assembler flags */ |
static List clist; /* compiler flags */ |
static List plist; /* preprocessor flags */ |
static List ilist; /* list of additional includes from LCCINPUTS */ |
static List rmlist; /* list of files to remove */ |
static char *outfile; /* ld output file or -[cS] object file */ |
static int ac; /* argument count */ |
static char **av; /* argument vector */ |
char *tempdir = TEMPDIR; /* directory for temporary files */ |
static char *progname; |
static List lccinputs; /* list of input directories */ |
|
main(int argc, char *argv[]) { |
int i, j, nf; |
|
progname = argv[0]; |
ac = argc + 50; |
av = alloc(ac*sizeof(char *)); |
if (signal(SIGINT, SIG_IGN) != SIG_IGN) |
signal(SIGINT, interrupt); |
if (signal(SIGTERM, SIG_IGN) != SIG_IGN) |
signal(SIGTERM, interrupt); |
#ifdef SIGHUP |
if (signal(SIGHUP, SIG_IGN) != SIG_IGN) |
signal(SIGHUP, interrupt); |
#endif |
if (getenv("TMP")) |
tempdir = getenv("TMP"); |
else if (getenv("TEMP")) |
tempdir = getenv("TEMP"); |
else if (getenv("TMPDIR")) |
tempdir = getenv("TMPDIR"); |
assert(tempdir); |
i = strlen(tempdir); |
for (; i > 0 && tempdir[i-1] == '/' || tempdir[i-1] == '\\'; i--) |
tempdir[i-1] = '\0'; |
if (argc <= 1) { |
help(); |
exit(0); |
} |
plist = append("-D__LCC__", 0); |
initinputs(); |
if (getenv("LCCDIR")) |
option(stringf("-lccdir=%s", getenv("LCCDIR"))); |
for (nf = 0, i = j = 1; i < argc; i++) { |
if (strcmp(argv[i], "-o") == 0) { |
if (++i < argc) { |
if (suffix(argv[i], suffixes, 2) >= 0) { |
error("-o would overwrite %s", argv[i]); |
exit(8); |
} |
outfile = argv[i]; |
continue; |
} else { |
error("unrecognized option `%s'", argv[i-1]); |
exit(8); |
} |
} else if (strcmp(argv[i], "-target") == 0) { |
if (argv[i+1] && *argv[i+1] != '-') |
i++; |
continue; |
} else if (*argv[i] == '-' && argv[i][1] != 'l') { |
opt(argv[i]); |
continue; |
} else if (*argv[i] != '-' && suffix(argv[i], suffixes, 3) >= 0) |
nf++; |
argv[j++] = argv[i]; |
} |
if ((cflag || Sflag) && outfile && nf != 1) { |
fprintf(stderr, "%s: -o %s ignored\n", progname, outfile); |
outfile = 0; |
} |
argv[j] = 0; |
for (i = 0; include[i]; i++) |
plist = append(include[i], plist); |
if (ilist) { |
List b = ilist; |
do { |
b = b->link; |
plist = append(b->str, plist); |
} while (b != ilist); |
} |
ilist = 0; |
for (i = 1; argv[i]; i++) |
if (strcmp(argv[i], "-l") == 0 && argv[i+1] && *argv[i+1] != '-') { /* -l file */ |
llist[1] = append(argv[i++], llist[1]); |
llist[1] = append(argv[i], llist[1]); |
} else if (*argv[i] == '-') |
opt(argv[i]); |
else { |
char *name = exists(argv[i]); |
if (name) { |
if (strcmp(name, argv[i]) != 0 |
|| nf > 1 && suffix(name, suffixes, 3) >= 0) |
fprintf(stderr, "%s:\n", name); |
filename(name, 0); |
} else |
error("can't find `%s'", argv[i]); |
} |
if (errcnt == 0 && !Eflag && !Sflag && !cflag && llist[1]) { |
compose(ld, llist[0], llist[1], |
append(outfile ? outfile : concat("a", first(suffixes[4])), 0)); |
if (callsys(av)) |
errcnt++; |
} |
rm(rmlist); |
return errcnt ? EXIT_FAILURE : EXIT_SUCCESS; |
} |
|
/* alloc - allocate n bytes or die */ |
static void *alloc(int n) { |
static char *avail, *limit; |
|
n = (n + sizeof(char *) - 1)&~(sizeof(char *) - 1); |
if (n >= limit - avail) { |
avail = malloc(n + 4*1024); |
assert(avail); |
limit = avail + n + 4*1024; |
} |
avail += n; |
return avail - n; |
} |
|
/* append - append a node with string str onto list, return new list */ |
static List append(char *str, List list) { |
List p = alloc(sizeof *p); |
|
p->str = str; |
if (list) { |
p->link = list->link; |
list->link = p; |
} else |
p->link = p; |
return p; |
} |
|
/* basepath - return base name for name, e.g. /usr/drh/foo.c => foo */ |
char *basepath(char *name) { |
char *s, *b, *t = 0; |
|
for (b = s = name; *s; s++) |
if (*s == '/' || *s == '\\') { |
b = s + 1; |
t = 0; |
} else if (*s == '.') |
t = s; |
s = strsave(b); |
if (t) |
s[t-b] = 0; |
return s; |
} |
|
#ifdef WIN32 |
#include <process.h> |
#else |
#define _P_WAIT 0 |
extern int fork(void); |
extern int wait(int *); |
extern int execv(const char *, char *[]); |
|
static int _spawnvp(int mode, const char *cmdname, const char *const argv[]) { |
int pid, n, status; |
|
switch (pid = fork()) { |
case -1: |
fprintf(stderr, "%s: no more processes\n", progname); |
return 100; |
case 0: |
execv(cmdname, (char **)argv); |
fprintf(stderr, "%s: ", progname); |
perror(cmdname); |
fflush(stdout); |
exit(100); |
} |
while ((n = wait(&status)) != pid && n != -1) |
; |
if (n == -1) |
status = -1; |
if (status&0377) { |
fprintf(stderr, "%s: fatal error in %s\n", progname, cmdname); |
status |= 0400; |
} |
return (status>>8)&0377; |
} |
#endif |
|
/* callsys - execute the command described by av[0...], return status */ |
static int callsys(char **av) { |
int i, status = 0; |
static char **argv; |
static int argc; |
|
for (i = 0; av[i] != NULL; i++) |
; |
if (i + 1 > argc) { |
argc = i + 1; |
if (argv == NULL) |
argv = malloc(argc*sizeof *argv); |
else |
argv = realloc(argv, argc*sizeof *argv); |
assert(argv); |
} |
for (i = 0; status == 0 && av[i] != NULL; ) { |
int j = 0; |
char *s; |
for ( ; av[i] != NULL && (s = strchr(av[i], '\n')) == NULL; i++) |
argv[j++] = av[i]; |
if (s != NULL) { |
if (s > av[i]) |
argv[j++] = stringf("%.*s", s - av[i], av[i]); |
if (s[1] != '\0') |
av[i] = s + 1; |
else |
i++; |
} |
argv[j] = NULL; |
if (verbose > 0) { |
int k; |
fprintf(stderr, "%s", argv[0]); |
for (k = 1; argv[k] != NULL; k++) |
fprintf(stderr, " %s", argv[k]); |
fprintf(stderr, "\n"); |
} |
if (verbose < 2) |
status = _spawnvp(_P_WAIT, argv[0], (const char * const *)argv); |
if (status == -1) { |
fprintf(stderr, "%s: ", progname); |
perror(argv[0]); |
} |
} |
return status; |
} |
|
/* concat - return concatenation of strings s1 and s2 */ |
char *concat(char *s1, char *s2) { |
int n = strlen(s1); |
char *s = alloc(n + strlen(s2) + 1); |
|
strcpy(s, s1); |
strcpy(s + n, s2); |
return s; |
} |
|
/* compile - compile src into dst, return status */ |
static int compile(char *src, char *dst) { |
compose(com, clist, append(src, 0), append(dst, 0)); |
return callsys(av); |
} |
|
/* compose - compose cmd into av substituting a, b, c for $1, $2, $3, resp. */ |
static void compose(char *cmd[], List a, List b, List c) { |
int i, j; |
List lists[3]; |
|
lists[0] = a; |
lists[1] = b; |
lists[2] = c; |
for (i = j = 0; cmd[i]; i++) { |
char *s = strchr(cmd[i], '$'); |
if (s && isdigit(s[1])) { |
int k = s[1] - '0'; |
assert(k >=1 && k <= 3); |
if (b = lists[k-1]) { |
b = b->link; |
av[j] = alloc(strlen(cmd[i]) + strlen(b->str) - 1); |
strncpy(av[j], cmd[i], s - cmd[i]); |
av[j][s-cmd[i]] = '\0'; |
strcat(av[j], b->str); |
strcat(av[j++], s + 2); |
while (b != lists[k-1]) { |
b = b->link; |
assert(j < ac); |
av[j++] = b->str; |
}; |
} |
} else if (*cmd[i]) { |
assert(j < ac); |
av[j++] = cmd[i]; |
} |
} |
av[j] = NULL; |
} |
|
/* error - issue error msg according to fmt, bump error count */ |
static void error(char *fmt, char *msg) { |
fprintf(stderr, "%s: ", progname); |
fprintf(stderr, fmt, msg); |
fprintf(stderr, "\n"); |
errcnt++; |
} |
|
/* exists - if `name' readable return its path name or return null */ |
static char *exists(char *name) { |
List b; |
|
if ( (name[0] == '/' || name[0] == '\\' || name[2] == ':') |
&& access(name, 4) == 0) |
return name; |
if (!(name[0] == '/' || name[0] == '\\' || name[2] == ':') |
&& (b = lccinputs)) |
do { |
b = b->link; |
if (b->str[0]) { |
char buf[1024]; |
sprintf(buf, "%s/%s", b->str, name); |
if (access(buf, 4) == 0) |
return strsave(buf); |
} else if (access(name, 4) == 0) |
return name; |
} while (b != lccinputs); |
if (verbose > 1) |
return name; |
return 0; |
} |
|
/* first - return first component in semicolon separated list */ |
static char *first(char *list) { |
char *s = strchr(list, ';'); |
|
if (s) { |
char buf[1024]; |
strncpy(buf, list, s-list); |
buf[s-list] = '\0'; |
return strsave(buf); |
} else |
return list; |
} |
|
/* filename - process file name argument `name', return status */ |
static int filename(char *name, char *base) { |
int status = 0; |
static char *stemp, *itemp; |
|
if (base == 0) |
base = basepath(name); |
switch (suffix(name, suffixes, 4)) { |
case 0: /* C source files */ |
compose(cpp, plist, append(name, 0), 0); |
if (Eflag) { |
status = callsys(av); |
break; |
} |
if (itemp == NULL) |
itemp = tempname(first(suffixes[1])); |
compose(cpp, plist, append(name, 0), append(itemp, 0)); |
status = callsys(av); |
if (status == 0) |
return filename(itemp, base); |
break; |
case 1: /* preprocessed source files */ |
if (Eflag) |
break; |
if (Sflag) |
status = compile(name, outfile ? outfile : concat(base, first(suffixes[2]))); |
else if ((status = compile(name, stemp?stemp:(stemp=tempname(first(suffixes[2]))))) == 0) |
return filename(stemp, base); |
break; |
case 2: /* assembly language files */ |
if (Eflag) |
break; |
if (!Sflag) { |
char *ofile; |
if (cflag && outfile) |
ofile = outfile; |
else if (cflag) |
ofile = concat(base, first(suffixes[3])); |
else |
ofile = tempname(first(suffixes[3])); |
compose(as, alist, append(name, 0), append(ofile, 0)); |
status = callsys(av); |
if (!find(ofile, llist[1])) |
llist[1] = append(ofile, llist[1]); |
} |
break; |
case 3: /* object files */ |
if (!find(name, llist[1])) |
llist[1] = append(name, llist[1]); |
break; |
default: |
if (Eflag) { |
compose(cpp, plist, append(name, 0), 0); |
status = callsys(av); |
} |
llist[1] = append(name, llist[1]); |
break; |
} |
if (status) |
errcnt++; |
return status; |
} |
|
/* find - find 1st occurrence of str in list, return list node or 0 */ |
static List find(char *str, List list) { |
List b; |
|
if (b = list) |
do { |
if (strcmp(str, b->str) == 0) |
return b; |
} while ((b = b->link) != list); |
return 0; |
} |
|
/* help - print help message */ |
static void help(void) { |
static char *msgs[] = { |
"", " [ option | file ]...\n", |
" except for -l, options are processed left-to-right before files\n", |
" unrecognized options are taken to be linker options\n", |
"-A warn about nonANSI usage; 2nd -A warns more\n", |
"-b emit expression-level profiling code; see bprint(1)\n", |
#ifdef sparc |
"-Bstatic -Bdynamic specify static or dynamic libraries\n", |
#endif |
"-Bdir/ use the compiler named `dir/rcc'\n", |
"-c compile only\n", |
"-dn set switch statement density to `n'\n", |
"-Dname -Dname=def define the preprocessor symbol `name'\n", |
"-E run only the preprocessor on the named C programs and unsuffixed files\n", |
"-g produce symbol table information for debuggers\n", |
"-help or -? print this message on standard error\n", |
"-Idir add `dir' to the beginning of the list of #include directories\n", |
"-lx search library `x'\n", |
"-M emit makefile dependencies; implies -E\n", |
"-N do not search the standard directories for #include files\n", |
"-n emit code to check for dereferencing zero pointers\n", |
"-O is ignored\n", |
"-o file leave the output in `file'\n", |
"-P print ANSI-style declarations for globals on standard error\n", |
"-p -pg emit profiling code; see prof(1) and gprof(1)\n", |
"-S compile to assembly language\n", |
"-static specify static libraries (default is dynamic)\n", |
"-dynamic specify dynamically linked libraries\n", |
"-t -tname emit function tracing calls to printf or to `name'\n", |
"-target name is ignored\n", |
"-tempdir=dir place temporary files in `dir/'", "\n" |
"-Uname undefine the preprocessor symbol `name'\n", |
"-v show commands as they are executed; 2nd -v suppresses execution\n", |
"-w suppress warnings\n", |
"-Woarg specify system-specific `arg'\n", |
"-W[pfal]arg pass `arg' to the preprocessor, compiler, assembler, or linker\n", |
0 }; |
int i; |
char *s; |
|
msgs[0] = progname; |
for (i = 0; msgs[i]; i++) { |
fprintf(stderr, "%s", msgs[i]); |
if (strncmp("-tempdir", msgs[i], 8) == 0 && tempdir) |
fprintf(stderr, "; default=%s", tempdir); |
} |
#define xx(v) if (s = getenv(#v)) fprintf(stderr, #v "=%s\n", s) |
xx(LCCINPUTS); |
xx(LCCDIR); |
#ifdef WIN32 |
xx(include); |
xx(lib); |
#endif |
#undef xx |
} |
|
/* initinputs - if LCCINPUTS or include is defined, use them to initialize various lists */ |
static void initinputs(void) { |
char *s = getenv("LCCINPUTS"); |
List list, b; |
|
if (s == 0 && (s = inputs)[0] == 0) |
s = "."; |
if (s) { |
lccinputs = path2list(s); |
if (b = lccinputs) |
do { |
b = b->link; |
if (strcmp(b->str, ".") != 0) { |
ilist = append(concat("-I", b->str), ilist); |
if (strstr(com[1], "win32") == NULL) |
llist[0] = append(concat("-L", b->str), llist[0]); |
} else |
b->str = ""; |
} while (b != lccinputs); |
} |
#ifdef WIN32 |
if (list = b = path2list(getenv("include"))) |
do { |
int n; |
b = b->link; |
n = strlen(b->str); |
if (b->str[n-1] == '\\') |
b->str[n-1] = '/'; |
ilist = append(stringf("-I\"%s\"", b->str), ilist); |
} while (b != list); |
#endif |
} |
|
/* interrupt - catch interrupt signals */ |
static void interrupt(int n) { |
rm(rmlist); |
exit(n = 100); |
} |
|
/* opt - process option in arg */ |
static void opt(char *arg) { |
switch (arg[1]) { /* multi-character options */ |
case 'W': /* -Wxarg */ |
if (arg[2] && arg[3]) |
switch (arg[2]) { |
case 'o': |
if (option(&arg[3])) |
return; |
break; |
case 'p': |
plist = append(&arg[3], plist); |
return; |
case 'f': |
if (strcmp(&arg[3], "-C") == 0 && !option("-b")) |
break; /* -C requires that -b is supported */ |
clist = append(&arg[3], clist); |
if (strcmp(&arg[3], "-unsigned_char=1") == 0) { |
plist = append("-D__CHAR_UNSIGNED__", plist); |
plist = append("-U_CHAR_IS_SIGNED", plist); |
} |
#define xx(name,k) \ |
if (strcmp(&arg[3], "-wchar_t=" #name) == 0) \ |
plist = append("-D_WCHAR_T_SIZE=" #k, plist); |
xx(unsigned_char,1) |
xx(unsigned_short,2) |
xx(unsigned_int,4) |
#undef xx |
return; |
case 'a': |
alist = append(&arg[3], alist); |
return; |
case 'l': |
llist[0] = append(&arg[3], llist[0]); |
return; |
} |
fprintf(stderr, "%s: %s ignored\n", progname, arg); |
return; |
case 'd': /* -dn -dynamic */ |
if (strcmp(arg, "-dynamic") == 0) { |
if (!option(arg)) |
fprintf(stderr, "%s: %s ignored\n", progname, arg); |
} else { |
arg[1] = 's'; |
clist = append(arg, clist); |
} |
return; |
case 't': /* -t -tname -tempdir=dir */ |
if (strncmp(arg, "-tempdir=", 9) == 0) |
tempdir = arg + 9; |
else |
clist = append(arg, clist); |
return; |
case 'p': /* -p -pg */ |
if (option(arg)) |
clist = append(arg, clist); |
else |
fprintf(stderr, "%s: %s ignored\n", progname, arg); |
return; |
case 'D': /* -Dname -Dname=def */ |
case 'U': /* -Uname */ |
case 'I': /* -Idir */ |
plist = append(arg, plist); |
return; |
case 'B': /* -Bdir -Bstatic -Bdynamic */ |
#ifdef sparc |
if (strcmp(arg, "-Bstatic") == 0 || strcmp(arg, "-Bdynamic") == 0) |
llist[1] = append(arg, llist[1]); |
else |
#endif |
{ |
static char *path; |
if (path) |
error("-B overwrites earlier option", 0); |
path = arg + 2; |
if (strstr(com[1], "win32") != NULL) |
com[0] = concat(replace(path, '/', '\\'), concat("rcc", first(suffixes[4]))); |
else |
com[0] = concat(path, "rcc"); |
if (path[0] == 0) |
error("missing directory in -B option", 0); |
} |
return; |
case 'h': |
if (strcmp(arg, "-help") == 0) { |
static int printed = 0; |
case '?': |
if (!printed) |
help(); |
printed = 1; |
return; |
} |
break; |
case 's': |
if (strcmp(arg, "-static") == 0) { |
if (!option(arg)) |
fprintf(stderr, "%s: %s ignored\n", progname, arg); |
return; |
} |
break; |
} |
if (arg[2] == 0) |
switch (arg[1]) { /* single-character options */ |
case 'S': |
Sflag++; |
return; |
case 'O': |
fprintf(stderr, "%s: %s ignored\n", progname, arg); |
return; |
case 'A': case 'n': case 'w': case 'P': |
clist = append(arg, clist); |
return; |
case 'g': case 'b': |
if (option(arg)) |
clist = append(arg[1] == 'g' ? "-g2" : arg, clist); |
else |
fprintf(stderr, "%s: %s ignored\n", progname, arg); |
return; |
case 'G': |
if (option(arg)) { |
clist = append("-g3", clist); |
llist[0] = append("-N", llist[0]); |
} else |
fprintf(stderr, "%s: %s ignored\n", progname, arg); |
return; |
case 'E': |
Eflag++; |
return; |
case 'c': |
cflag++; |
return; |
case 'M': |
Eflag++; /* -M implies -E */ |
plist = append(arg, plist); |
return; |
case 'N': |
if (strcmp(basepath(cpp[0]), "gcc-cpp") == 0) |
plist = append("-nostdinc", plist); |
include[0] = 0; |
ilist = 0; |
return; |
case 'v': |
if (verbose++ == 0) { |
if (strcmp(basepath(cpp[0]), "gcc-cpp") == 0) |
plist = append(arg, plist); |
clist = append(arg, clist); |
fprintf(stderr, "%s %s\n", progname, rcsid); |
} |
return; |
} |
if (cflag || Sflag || Eflag) |
fprintf(stderr, "%s: %s ignored\n", progname, arg); |
else |
llist[1] = append(arg, llist[1]); |
} |
|
/* path2list - convert a colon- or semicolon-separated list to a list */ |
static List path2list(const char *path) { |
List list = NULL; |
char sep = ':'; |
|
if (path == NULL) |
return NULL; |
if (strchr(path, ';')) |
sep = ';'; |
while (*path) { |
char *p, buf[512]; |
if (p = strchr(path, sep)) { |
assert(p - path < sizeof buf); |
strncpy(buf, path, p - path); |
buf[p-path] = '\0'; |
} else { |
assert(strlen(path) < sizeof buf); |
strcpy(buf, path); |
} |
if (!find(buf, list)) |
list = append(strsave(buf), list); |
if (p == 0) |
break; |
path = p + 1; |
} |
return list; |
} |
|
/* replace - copy str, then replace occurrences of from with to, return the copy */ |
char *replace(const char *str, int from, int to) { |
char *s = strsave(str), *p = s; |
|
for ( ; (p = strchr(p, from)) != NULL; p++) |
*p = to; |
return s; |
} |
|
/* rm - remove files in list */ |
static void rm(List list) { |
if (list) { |
List b = list; |
if (verbose) |
fprintf(stderr, "rm"); |
do { |
if (verbose) |
fprintf(stderr, " %s", b->str); |
if (verbose < 2) |
remove(b->str); |
} while ((b = b->link) != list); |
if (verbose) |
fprintf(stderr, "\n"); |
} |
} |
|
/* strsave - return a saved copy of string str */ |
char *strsave(const char *str) { |
return strcpy(alloc(strlen(str)+1), str); |
} |
|
/* stringf - format and return a string */ |
char *stringf(const char *fmt, ...) { |
char buf[1024]; |
va_list ap; |
int n; |
|
va_start(ap, fmt); |
n = vsprintf(buf, fmt, ap); |
va_end(ap); |
return strsave(buf); |
} |
|
/* suffix - if one of tails[0..n-1] holds a proper suffix of name, return its index */ |
int suffix(char *name, char *tails[], int n) { |
int i, len = strlen(name); |
|
for (i = 0; i < n; i++) { |
char *s = tails[i], *t; |
for ( ; t = strchr(s, ';'); s = t + 1) { |
int m = t - s; |
if (len > m && strncmp(&name[len-m], s, m) == 0) |
return i; |
} |
if (*s) { |
int m = strlen(s); |
if (len > m && strncmp(&name[len-m], s, m) == 0) |
return i; |
} |
} |
return -1; |
} |
|
/* tempname - generate a temporary file name in tempdir with given suffix */ |
char *tempname(char *suffix) { |
static int n; |
char *name = stringf("%s/lcc%d%d%s", tempdir, getpid(), n++, suffix); |
|
if (strstr(com[1], "win32") != NULL) |
name = replace(name, '/', '\\'); |
rmlist = append(name, rmlist); |
return name; |
} |
/ops.c
0,0 → 1,61
#include "c.h" |
|
/* ops [ {csilhfdxp}=n ]... |
* prints lcc dag operator set for a given set of type sizes. |
*/ |
|
static char rcsid[] = "$Id: ops.c,v 4.1 2002/08/28 23:12:20 drh Exp $"; |
|
static char list[] = { 'c', 's', 'i', 'l', 'h', 'f', 'd', 'x', 'p', 0 }; |
static int sizes[] = { 1, 2, 4, 4, 8, 4, 8, 16, 8 }; |
|
static int doop(int op, int type, const char *sz, const char *opname) { |
int count = 0; |
static int last; |
|
if (op == LOAD) |
return 0; |
if (last != 0 && last != op) |
printf("\n"); |
last = op; |
if (type == B || type == V) { |
printf(" %s=%d", opname, op + type); |
count++; |
} else { |
int i, done = 0; |
const char *s; |
for (i = 0; sz[i] != '\0' && (s = strchr(list, sz[i])) != NULL; i++) { |
int n = sizes[s-list]; |
if ((done&(1<<n)) == 0) { |
printf(" %s%d=%d", opname, n, op + type + sizeop(n)); |
count++; |
} |
done |= 1<<n; |
} |
} |
printf("\n"); |
return count; |
} |
|
int main(int argc, char *argv[]) { |
int i, count = 0; |
|
for (i = 1; i < argc; i++) { |
char c, *s; |
int n; |
if (sscanf(argv[i], "%c=%d", &c, &n) == 2 |
&& n > 0 && (s = strchr(list, c)) != NULL) |
sizes[s-list] = n; |
else { |
fprintf(stderr, "usage: %s [ {csilhfdxp}=n ]...\n", argv[0]); |
exit(EXIT_FAILURE); |
} |
} |
#define gop(x,n) |
#define op(x,t,s) count += doop(x,t,#s,#x #t); |
#include "ops.h" |
#undef gop |
#undef op |
fprintf(stderr, "%d operators\n", count); |
return EXIT_SUCCESS; |
} |
/win32.c
0,0 → 1,41
/* x86s running MS Windows NT 4.0 */ |
|
#include <string.h> |
|
static char rcsid[] = "$Id: win32.c,v 1.19 2001/07/09 18:00:13 drh Exp $"; |
|
#ifndef LCCDIR |
#define LCCDIR "\\progra~1\\lcc\\4.1\\bin\\" |
#endif |
|
char *suffixes[] = { ".c;.C", ".i;.I", ".asm;.ASM;.s;.S", ".obj;.OBJ", ".exe", 0 }; |
char inputs[256] = ""; |
char *cpp[] = { LCCDIR "cpp", "-D__STDC__=1", "-Dwin32", "-D_WIN32", "-D_M_IX86", |
"$1", "$2", "$3", 0 }; |
char *include[] = { "-I" LCCDIR "include", 0 }; |
char *com[] = { LCCDIR "rcc", "-target=x86/win32", "$1", "$2", "$3", 0 }; |
char *as[] = { "ml", "-nologo", "-c", "-Cp", "-coff", "-Fo$3", "$1", "$2", 0 }; |
char *ld[] = { "link", "-nologo", |
"", "-subsystem:console", "-entry:mainCRTStartup", |
"$2", "-OUT:$3", "$1", LCCDIR "liblcc.lib", "oldnames.lib", "libc.lib", "kernel32.lib", 0 }; |
|
extern char *concat(char *, char *); |
extern char *replace(const char *, int, int); |
|
int option(char *arg) { |
if (strncmp(arg, "-lccdir=", 8) == 0) { |
arg = replace(arg + 8, '/', '\\'); |
if (arg[strlen(arg)-1] == '\\') |
arg[strlen(arg)-1] = '\0'; |
cpp[0] = concat(arg, "\\cpp.exe"); |
include[0] = concat("-I", concat(arg, "\\include")); |
com[0] = concat(arg, "\\rcc.exe"); |
ld[8] = concat(arg, "\\liblcc.lib"); |
} else if (strcmp(arg, "-b") == 0) |
; |
else if (strncmp(arg, "-ld=", 4) == 0) |
ld[0] = &arg[4]; |
else |
return 0; |
return 1; |
} |
/gcc-solaris.c
0,0 → 1,51
/* SPARCs running Solaris 2.5.1 w/GCC tools |
at CS Dept., Princeton University */ |
|
#include <string.h> |
|
static char rcsid[] = "$Id: gcc-solaris.c,v 1.9 1997/05/27 23:03:40 drh Exp $"; |
|
#ifndef LCCDIR |
#define LCCDIR "/usr/local/lib/lcc/" |
#endif |
#ifndef GCCDIR |
#define GCCDIR "/usr/local/gnu/bin/" |
#endif |
#ifndef GCCLIB |
#define GCCLIB "/usr/local/gnu/lib/gcc-lib/sparc-sun-solaris2.5/2.7.2/" |
#endif |
|
char *suffixes[] = { ".c", ".i", ".s", ".o", ".out", 0 }; |
char inputs[256] = ""; |
char *cpp[] = { LCCDIR "cpp", |
"-D__STDC__=1", "-Dsparc", "-D__sparc__", "-Dsun", "-D__sun__", "-Dunix", |
"$1", "$2", "$3", 0 }; |
char *include[] = { "-I" LCCDIR "include", "-I/usr/local/include", |
"-I" GCCLIB "include", "-I/usr/include", 0 }; |
char *com[] = { LCCDIR "rcc", "-target=sparc/solaris", |
"$1", "$2", "$3", 0 }; |
char *as[] = { GCCDIR "as", "-f", "-o", "$3", "$1", "$2", 0 }; |
char *ld[] = { GCCDIR "ld", "-o", "$3", "$1", |
GCCLIB "crti.o", GCCLIB "crt1.o", |
GCCLIB "crtbegin.o", "$2", "", "", "-L" LCCDIR, "-llcc", |
"-L" GCCLIB, "-lgcc", "-lm", "-lc", "", |
GCCLIB "crtend.o", GCCLIB "crtn.o", 0 }; |
|
extern char *concat(char *, char *); |
|
int option(char *arg) { |
if (strncmp(arg, "-lccdir=", 8) == 0) { |
cpp[0] = concat(&arg[8], "/cpp"); |
include[0] = concat("-I", concat(&arg[8], "/include")); |
ld[10] = concat("-L", &arg[8]); |
com[0] = concat(&arg[8], "/rcc"); |
} else if (strcmp(arg, "-g") == 0) |
; |
else if (strcmp(arg, "-pg") == 0) { |
ld[8] = GCCLIB "gmon.o"; |
} else if (strcmp(arg, "-b") == 0) |
; |
else |
return 0; |
return 1; |
} |
/osf.c
0,0 → 1,54
/* DEC ALPHAs running OSF/1 V3.2A (Rev. 17) at Princeton University */ |
|
#include <string.h> |
|
static char rcsid[] = "$Id: osf.c,v 1.8 1997/05/26 22:34:10 drh Exp $"; |
|
#ifndef LCCDIR |
#define LCCDIR "/usr/local/lib/lcc/" |
#endif |
|
char *suffixes[] = { ".c", ".i", ".s", ".o", ".out", 0 }; |
char inputs[256] = ""; |
char *cpp[] = { |
LCCDIR "cpp", "-D__STDC__=1", |
"-DLANGUAGE_C", "-D__LANGUAGE_C__", |
"-D_unix", "-D__unix__", "-D_osf", "-D__osf__", "-Dunix", |
"-Dalpha", "-D_alpha", "-D__alpha", |
"-D__SYSTYPE_BSD", "-D_SYSTYPE_BSD", |
"$1", "$2", "$3", 0 }; |
char *com[] = { LCCDIR "rcc", "-target=alpha/osf", "$1", "$2", "$3", "", 0 }; |
char *include[] = { "-I" LCCDIR "include", "-I/usr/local/include", |
"-I/usr/include", 0 }; |
char *as[] = { "/bin/as", "-o", "$3", "", "$1", "-nocpp", "$2", 0 }; |
char *ld[] = { "/usr/bin/ld", "-o", "$3", "/usr/lib/cmplrs/cc/crt0.o", |
"$1", "$2", "", "", "-L" LCCDIR, "-llcc", "-lm", "-lc", 0 }; |
|
extern char *concat(char *, char *); |
extern int access(const char *, int); |
|
int option(char *arg) { |
if (strncmp(arg, "-lccdir=", 8) == 0) { |
cpp[0] = concat(&arg[8], "/cpp"); |
include[0] = concat("-I", concat(&arg[8], "/include")); |
com[0] = concat(&arg[8], "/rcc"); |
ld[8] = concat("-L", &arg[8]); |
} else if (strcmp(arg, "-g4") == 0 |
&& access("/u/drh/lib/alpha/rcc", 4) == 0 |
&& access("/u/drh/book/cdb/alpha/osf/cdbld", 4) == 0) { |
com[0] = "/u/drh/lib/alpha/rcc"; |
com[5] = "-g4"; |
ld[0] = "/u/drh/book/cdb/alpha/osf/cdbld"; |
ld[1] = "-o"; |
ld[2] = "$3"; |
ld[3] = "$1"; |
ld[4] = "$2"; |
ld[5] = 0; |
} else if (strcmp(arg, "-g") == 0) |
return 1; |
else if (strcmp(arg, "-b") == 0) |
; |
else |
return 0; |
return 1; |
} |
/irix.c
0,0 → 1,69
/* SGI big endian MIPSes running IRIX 6.2 at CS Dept., Princeton University */ |
|
#include <string.h> |
|
static char rcsid[] = "$Id: irix.c,v 1.11 2000/01/06 22:25:58 drh Exp $"; |
|
#ifndef LCCDIR |
#define LCCDIR "/usr/local/lib/lcc/" |
#endif |
#ifndef LIBDIR |
#define LIBDIR "/usr/lib/" |
#endif |
|
char *suffixes[] = { ".c", ".i", ".s", ".o", ".out", 0 }; |
char inputs[256] = ""; |
char *cpp[] = { LCCDIR "cpp", "-D__STDC__=1", |
"-DLANGUAGE_C", |
"-DMIPSEB", |
"-DSYSTYPE_SVR4", |
"-D_LONGLONG", /* some SGI header files assume this */ |
"-D_CFE", |
"-D_LANGUAGE_C", |
"-D_MIPSEB", |
"-D_MIPS_FPSET=16", |
"-D_MIPS_ISA=_MIPS_ISA_MIPS1", |
"-D_MIPS_SIM=_MIPS_SIM_ABI32", |
"-D_MIPS_SZINT=32", |
"-D_MIPS_SZLONG=32", |
"-D_MIPS_SZPTR=32", |
"-D_SGI_SOURCE", |
"-D_SVR4_SOURCE", |
"-D_SYSTYPE_SVR4", |
"-D__host_mips", |
"-D__mips=1", |
"-D__sgi", |
"-D__unix", |
"-Dhost_mips", |
"-Dmips", |
"-Dsgi", |
"-Dunix", |
"$1", "$2", "$3", 0 }; |
char *com[] = { LCCDIR "rcc", "-target=mips/irix", "$1", "$2", "$3", "", 0 }; |
char *include[] = { "-I" LCCDIR "include", "-I/usr/local/include", |
"-I/usr/include", 0 }; |
char *as[] = { "/usr/bin/as", "-32", "-o", "$3", "$1", "-nocpp", "-KPIC", "$2", 0 }; |
char *ld[] = { "/usr/bin/ld", "-require_dynamic_link", "_rld_new_interface", "-32", |
"-elf", "-_SYSTYPE_SVR4", "-Wx,-G", "0", "-g0", "-KPIC", "-dont_warn_unused", |
"-o", "$3", LIBDIR "crt1.o", "-L/usr/local/lib", |
"$1", "$2", "", "-L" LCCDIR, "-llcc", "-lc", "-lm", LIBDIR "crtn.o", 0 |
}; |
|
extern char *concat(char *, char *); |
|
int option(char *arg) { |
if (strncmp(arg, "-lccdir=", 8) == 0) { |
cpp[0] = concat(&arg[8], "/cpp"); |
include[0] = concat("-I", concat(&arg[8], "/include")); |
com[0] = concat(&arg[8], "/rcc"); |
ld[18] = concat("-L", &arg[8]); |
} else if (strcmp(arg, "-g") == 0) |
; |
else if (strcmp(arg, "-p") == 0) |
ld[13] = LIBDIR "mcrt1.o"; |
else if (strcmp(arg, "-b") == 0) |
; |
else |
return 0; |
return 1; |
} |
/solaris.c
0,0 → 1,51
/* SPARCs running Solaris 2.5.1 at CS Dept., Princeton University */ |
|
#include <string.h> |
|
static char rcsid[] = "$Id: solaris.c,v 1.10 1998/09/14 20:36:33 drh Exp $"; |
|
#ifndef LCCDIR |
#define LCCDIR "/usr/local/lib/lcc/" |
#endif |
#ifndef SUNDIR |
#define SUNDIR "/opt/SUNWspro/SC4.2/lib/" |
#endif |
|
char *suffixes[] = { ".c", ".i", ".s", ".o", ".out", 0 }; |
char inputs[256] = ""; |
char *cpp[] = { LCCDIR "cpp", |
"-D__STDC__=1", "-Dsparc", "-D__sparc__", "-Dsun", "-D__sun__", "-Dunix", |
"$1", "$2", "$3", 0 }; |
char *include[] = { "-I" LCCDIR "include", "-I/usr/local/include", |
"-I/usr/include", 0 }; |
char *com[] = { LCCDIR "rcc", "-target=sparc/solaris", |
"$1", "$2", "$3", 0 }; |
char *as[] = { "/usr/ccs/bin/as", "-Qy", "-s", "-o", "$3", "$1", "$2", 0 }; |
char *ld[] = { "/usr/ccs/bin/ld", "-o", "$3", "$1", |
SUNDIR "crti.o", SUNDIR "crt1.o", |
SUNDIR "values-xa.o", "$2", "", |
"-Y", "P," SUNDIR ":/usr/ccs/lib:/usr/lib", "-Qy", |
"-L" LCCDIR, "-llcc", "-lm", "-lc", SUNDIR "crtn.o", 0 }; |
|
extern char *concat(char *, char *); |
|
int option(char *arg) { |
if (strncmp(arg, "-lccdir=", 8) == 0) { |
cpp[0] = concat(&arg[8], "/cpp"); |
include[0] = concat("-I", concat(&arg[8], "/include")); |
ld[12] = concat("-L", &arg[8]); |
com[0] = concat(&arg[8], "/rcc"); |
} else if (strcmp(arg, "-g") == 0) |
; |
else if (strcmp(arg, "-p") == 0) { |
ld[5] = SUNDIR "mcrt1.o"; |
ld[10] = "P," SUNDIR "libp:/usr/ccs/lib/libp:/usr/lib/libp:" |
SUNDIR ":/usr/ccs/lib:/usr/lib"; |
} else if (strcmp(arg, "-b") == 0) |
; |
else if (strncmp(arg, "-ld=", 4) == 0) |
ld[0] = &arg[4]; |
else |
return 0; |
return 1; |
} |