sys/src/cmd/pcc.c

   1 #include <u.h>
   2 #include <libc.h>
   3
   4
   5 typedef struct Objtype {
   6         char    *name;
   7         char    *cc;
   8         char    *ld;
   9         char    *o;
  10         char    *oname;
  11 } Objtype;
  12
  13 Objtype objtype[] = {
  14         {"spim",        "0c", "0l", "0", "0.out"},
  15         {"68000",       "1c", "1l", "1", "1.out"},
  16         {"68020",       "2c", "2l", "2", "2.out"},
  17         {"arm",         "5c", "5l", "5", "5.out"},
  18         {"amd64",       "6c", "6l", "6", "6.out"},
  19         {"alpha",       "7c", "7l", "7", "7.out"},
  20         {"386",         "8c", "8l", "8", "8.out"},
  21         {"power64",     "9c", "9l", "9", "9.out"},
  22         {"sparc",       "kc", "kl", "k", "k.out"},
  23         {"power",       "qc", "ql", "q", "q.out"},
  24         {"mips",        "vc", "vl", "v", "v.out"},
  25 };
  26
  27 enum {
  28         Nobjs = (sizeof objtype)/(sizeof objtype[0]),
  29         Maxlist = 500,
  30 };
  31
  32 typedef struct List {
  33         char    *strings[Maxlist];
  34         int     n;
  35 } List;
  36
  37 List    srcs, objs, cpp, cc, ld, ldargs;
  38 int     cflag, vflag, Eflag, Pflag;
  39 char    *allos = "01245678kqv";
  40
  41 void    append(List *, char *);
  42 char    *changeext(char *, char *);
  43 void    doexec(char *, List *);
  44 void    dopipe(char *, List *, char *, List *);
  45 void    fatal(char *);
  46 Objtype *findoty(void);
  47 void    printlist(List *);
  48
  49 void
  50 main(int argc, char *argv[])
  51 {
  52         Objtype *ot;
  53         char *s, *suf, *ccpath;
  54         char *oname;
  55         int i, cppn, ccn, oflag;
  56
  57         oflag = 0;
  58         ot = findoty();
  59         oname = ot->oname;
  60         append(&cpp, "cpp");
  61         append(&cpp, "-D__STDC__=1");   /* ANSI says so */
  62         append(&cpp, "-N");             /* turn off standard includes */
  63         append(&cc, ot->cc);
  64         append(&ld, ot->ld);
  65         while(argc > 0) {
  66                 ARGBEGIN {
  67                 case '+':
  68                         append(&cpp, smprint("-%c", ARGC()));
  69                         break;
  70                 case 'c':
  71                         cflag = 1;
  72                         break;
  73                 case 'l':
  74                         append(&objs, smprint("/%s/lib/ape/lib%s.a", ot->name, ARGF()));
  75                         break;
  76                 case 'o':
  77                         oflag = 1;
  78                         oname = ARGF();
  79                         if(!oname)
  80                                 fatal("no -o argument");
  81                         break;
  82                 case 'w':
  83                 case 'B':
  84                 case 'F':
  85                 case 'N':
  86                 case 'S':
  87                 case 'T':
  88                 case 'V':
  89                         append(&cc, smprint("-%c", ARGC()));
  90                         break;
  91                 case 's':
  92                         append(&cc, smprint("-s%s", ARGF()));
  93                         break;
  94                 case 'D':
  95                 case 'I':
  96                 case 'U':
  97                         append(&cpp, smprint("-%c%s", ARGC(), ARGF()));
  98                         break;
  99                 case 'v':
 100                         vflag = 1;
 101                         append(&ldargs, "-v");
 102                         break;
 103                 case 'P':
 104                         Pflag = 1;
 105                         cflag = 1;
 106                         break;
 107                 case 'E':
 108                         Eflag = 1;
 109                         cflag = 1;
 110                         break;
 111                 case 'p':
 112                         append(&ldargs, "-p");
 113                         break;
 114                 case 'a':
 115                         /* hacky look inside ARGBEGIN insides, to see if we have -aa */
 116                         if(*_args == 'a') {
 117                                 append(&cc, "-aa");
 118                                 _args++;
 119                         } else
 120                                 append(&cc, "-a");
 121                         cflag = 1;
 122                         break;
 123                 default:
 124                         fprint(2, "pcc: flag -%c ignored\n", ARGC());
 125                         break;
 126                 } ARGEND
 127                 if(argc > 0) {
 128                         s = argv[0];
 129                         suf = utfrrune(s, '.');
 130                         if(suf) {
 131                                 suf++;
 132                                 if(strcmp(suf, "c") == 0) {
 133                                         append(&srcs, s);
 134                                         append(&objs, changeext(s, ot->o));
 135                                 } else if(strcmp(suf, ot->o) == 0 ||
 136                                           strcmp(suf, "o") == 0 ||
 137                                           strcmp(suf, "a") == 0 ||
 138                                           (suf[0] == 'a' && strcmp(suf+1, ot->o) == 0)) {
 139                                         append(&objs, s);
 140                                 } else if(utfrune(allos, suf[0]) != 0) {
 141                                         fprint(2, "pcc: argument %s ignored: wrong architecture\n",
 142                                                 s);
 143                                 }
 144                         }
 145                 }
 146         }
 147         if(objs.n == 0)
 148                 fatal("no files to compile or load");
 149         ccpath = smprint("/bin/%s", ot->cc);
 150         append(&cpp, smprint("-I/%s/include/ape", ot->name));
 151         append(&cpp, "-I/sys/include/ape");
 152         cppn = cpp.n;
 153         ccn = cc.n;
 154         for(i = 0; i < srcs.n; i++) {
 155                 append(&cpp, srcs.strings[i]);
 156                 if(Pflag)
 157                         append(&cpp, changeext(objs.strings[i], "i"));
 158                 if(Eflag || Pflag)
 159                         doexec("/bin/cpp", &cpp);
 160                 else {
 161                         append(&cc, "-o");
 162                         if(oflag && cflag)
 163                                 append(&cc, oname);
 164                         else
 165                                 append(&cc, changeext(srcs.strings[i], ot->o));
 166                         dopipe("/bin/cpp", &cpp, ccpath, &cc);
 167                 }
 168                 cpp.n = cppn;
 169                 cc.n = ccn;
 170         }
 171         if(!cflag) {
 172                 append(&ld, "-o");
 173                 append(&ld, oname);
 174                 for(i = 0; i < ldargs.n; i++)
 175                         append(&ld, ldargs.strings[i]);
 176                 for(i = 0; i < objs.n; i++)
 177                         append(&ld, objs.strings[i]);
 178                 append(&ld, smprint("/%s/lib/ape/libap.a", ot->name));
 179                 doexec(smprint("/bin/%s", ot->ld), &ld);
 180                 if(objs.n == 1){
 181                         /* prevent removal of a library */
 182                         if(strstr(objs.strings[0], ".a") == 0)
 183                                 remove(objs.strings[0]);
 184                 }
 185         }
 186
 187         exits(0);
 188 }
 189
 190 void
 191 append(List *l, char *s)
 192 {
 193         if(l->n >= Maxlist-1)
 194                 fatal("too many arguments");
 195         l->strings[l->n++] = s;
 196         l->strings[l->n] = 0;
 197 }
 198
 199 void
 200 doexec(char *c, List *a)
 201 {
 202         Waitmsg *w;
 203
 204         if(vflag) {
 205                 printlist(a);
 206                 fprint(2, "\n");
 207         }
 208         switch(fork()) {
 209         case -1:
 210                 fatal("fork failed");
 211         case 0:
 212                 exec(c, a->strings);
 213                 fatal("exec failed");
 214         }
 215         w = wait();
 216         if(w == nil)
 217                 fatal("wait failed");
 218         if(w->msg[0])
 219                 fatal(smprint("%s: %s", a->strings[0], w->msg));
 220         free(w);
 221 }
 222
 223 void
 224 dopipe(char *c1, List *a1, char *c2, List *a2)
 225 {
 226         Waitmsg *w;
 227         int pid1, got;
 228         int fd[2];
 229
 230         if(vflag) {
 231                 printlist(a1);
 232                 fprint(2, " | ");
 233                 printlist(a2);
 234                 fprint(2, "\n");
 235         }
 236         if(pipe(fd) < 0)
 237                 fatal("pipe failed");
 238         switch((pid1 = fork())) {
 239         case -1:
 240                 fatal("fork failed");
 241         case 0:
 242                 dup(fd[0], 0);
 243                 close(fd[0]);
 244                 close(fd[1]);
 245                 exec(c2, a2->strings);
 246                 fatal("exec failed");
 247         }
 248         switch(fork()) {
 249         case -1:
 250                 fatal("fork failed");
 251         case 0:
 252                 close(0);
 253                 dup(fd[1], 1);
 254                 close(fd[0]);
 255                 close(fd[1]);
 256                 exec(c1, a1->strings);
 257                 fatal("exec failed");
 258         }
 259         close(fd[0]);
 260         close(fd[1]);
 261         for(got = 0; got < 2; got++) {
 262                 w = wait();
 263                 if(w == nil)
 264                         fatal("wait failed");
 265                 if(w->msg[0])
 266                         fatal(smprint("%s: %s",
 267                            (w->pid == pid1) ? a1->strings[0] : a2->strings[0], w->msg));
 268                 free(w);
 269         }
 270 }
 271
 272 Objtype *
 273 findoty(void)
 274 {
 275         char *o;
 276         Objtype *oty;
 277
 278         o = getenv("objtype");
 279         if(!o)
 280                 fatal("no $objtype in environment");
 281         for(oty = objtype; oty < &objtype[Nobjs]; oty++)
 282                 if(strcmp(o, oty->name) == 0)
 283                         return oty;
 284         fatal("unknown $objtype");
 285         return 0;                       /* shut compiler up */
 286 }
 287
 288 void
 289 fatal(char *msg)
 290 {
 291         fprint(2, "pcc: %s\n", msg);
 292         exits(msg);
 293 }
 294
 295 /* src ends in .something; return copy of basename with .ext added */
 296 char *
 297 changeext(char *src, char *ext)
 298 {
 299         char *b, *e, *ans;
 300
 301         b = utfrrune(src, '/');
 302         if(b)
 303                 b++;
 304         else
 305                 b = src;
 306         e = utfrrune(src, '.');
 307         if(!e)
 308                 return 0;
 309         *e = 0;
 310         ans = smprint("%s.%s", b, ext);
 311         *e = '.';
 312         return ans;
 313 }
 314
 315 void
 316 printlist(List *l)
 317 {
 318         int i;
 319
 320         for(i = 0; i < l->n; i++) {
 321                 fprint(2, "%s", l->strings[i]);
 322                 if(i < l->n - 1)
 323                         fprint(2, " ");
 324         }
 325 }