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