git.chise.org Git - chise/xemacs-chise.git.1/blob - lib-src/ellcc.c

   1 /* ellcc.c - front-end for compiling Emacs modules
   2 Copyright (C) 1998, 1999 J. Kean Johnston.
   3
   4 This file is part of XEmacs.
   5
   6 XEmacs is free software; you can redistribute it and/or modify it
   7 under the terms of the GNU General Public License as published by the
   8 Free Software Foundation; either version 2, or (at your option) any
   9 later version.
  10
  11 XEmacs is distributed in the hope that it will be useful, but WITHOUT
  12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with XEmacs; see the file COPYING.  If not, write to
  18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.
  20
  21 Author: J. Kean Johnston (jkj@sco.com).
  22 Please mail bugs and suggestions to the XEmacs maintainer.
  23 */
  24
  25 /*
  26 Here's the scoop. We would really like this to be a shell script, but
  27 the various Windows platforms don't have reliable scripting that suits
  28 our needs. We don't want to rely on perl or some other such language
  29 so we have to roll our own executable to act as a front-end for the
  30 compiler.
  31
  32 This program is used to invoke the compiler, the linker and to generate
  33 the module specific documentation and initialization code.  We assume we
  34 are in 'compile' mode unless we encounter an argument which tells us
  35 that we're not.  We take all arguments and pass them on directly to the
  36 compiler, except for a few which are specific to this program:
  37
  38   --mode=VALUE      This sets the program mode. VALUE can be one of
  39                     compile, link, init or verbose.
  40   --mod-name=NAME   Sets the module name to the string NAME.
  41   --mod-title=TITLE Sets the module title to the string TITLE.
  42   --mod-version=VER Sets the module version to the string VER.
  43
  44 The idea is that Makefiles will use ellcc as the compiler for making
  45 dynamic Emacs modules, and life should be as simple as:
  46
  47   make CC=ellcc LD='ellcc --mode=link'
  48
  49 The only additional requirement is an entry in the Makefile to produce
  50 the module initialization file, which will usually be something along
  51 the lines of:
  52
  53   modinit.c: $(SRCS)
  54              ellcc --mode=init --mod-name=\"$(MODNAME)\" \
  55                --mod-title=\"$(MODTITLE)\" --mod-version=\"$(MODVERSION)\" \
  56                -o $@ $(SRCS)
  57
  58 See the samples for more details.
  59 */
  60
  61 #include <config.h>
  62 #include <stdio.h>
  63 #include <stdlib.h>
  64 #include <stddef.h>
  65 #include <string.h>
  66 #include <ctype.h>
  67 #include <errno.h>
  68 #include <sys/types.h>
  69
  70 #ifdef HAVE_UNISTD_H
  71 # include <unistd.h>
  72 #endif /* HAVE_UNISTD_H */
  73
  74 #define EMODULES_GATHER_VERSION
  75
  76 #include <emodules.h>
  77 #include <ellcc.h> /* Generated files must be included using <...> */
  78
  79 #define DEBUG
  80
  81 #ifndef HAVE_SHLIB
  82 int
  83 main (int argc, char *argv[])
  84 {
  85   fprintf (stderr, "Dynamic modules not supported on this platform\n");
  86   return EXIT_FAILURE;
  87 }
  88 #else
  89
  90 /*
  91  * Try to figure out the commands we need to use to create shared objects,
  92  * and how to compile for PIC mode.
  93  */
  94
  95 /*
  96  *      xnew, xrnew -- allocate, reallocate storage
  97  *
  98  * SYNOPSIS:    Type *xnew (int n, Type);
  99  *              Type *xrnew (OldPointer, int n, Type);
 100  */
 101 #ifdef chkmalloc
 102 # include "chkmalloc.h"
 103 # define xnew(n,Type)     ((Type *) trace_malloc (__FILE__, __LINE__, \
 104                                                   (n) * sizeof (Type)))
 105 # define xrnew(op,n,Type) ((Type *) trace_realloc (__FILE__, __LINE__, \
 106                                                    (op), (n) * sizeof (Type)))
 107 #else
 108 # define xnew(n,Type)     ((Type *) xmalloc ((n) * sizeof (Type)))
 109 # define xrnew(op,n,Type) ((Type *) xrealloc ((op), (n) * sizeof (Type)))
 110 #endif
 111 static void *xmalloc (size_t);
 112 static void fatal (char *, char *);
 113 static void add_to_argv (const char *);
 114 static void do_compile_mode (void);
 115 static void do_link_mode (void);
 116 static void do_init_mode (void);
 117
 118 #define SSTR(S) ((S)?(S):"")
 119
 120 #define ELLCC_COMPILE_MODE      0
 121 #define ELLCC_LINK_MODE         1
 122 #define ELLCC_INIT_MODE         2
 123
 124 static int ellcc_mode = ELLCC_COMPILE_MODE;
 125 static char *progname;
 126 static char *mod_name = NULL;
 127 static char *mod_version = NULL;
 128 static char *mod_title = NULL;
 129 static char *mod_output = NULL;
 130 static int verbose = 0;
 131 static char **exec_argv;
 132 static int exec_argc = 1;
 133 static int *exec_args;
 134 static int real_argc = 0;
 135 static int prog_argc;
 136 static char **prog_argv;
 137
 138 /*
 139  * We allow the user to over-ride things in the environment
 140  */
 141 char *ellcc, *ellld, *ellcflags, *ellldflags, *ellpicflags, *elldllflags;
 142 #define OVERENV(STR,EVAR,DFLT) \
 143   STR = getenv(EVAR); \
 144   if ((STR) == (char *)0) \
 145     STR = DFLT
 146
 147 int
 148 main (int argc, char *argv[])
 149 {
 150   char *tmp;
 151   int i, done_mode = 0;
 152
 153   prog_argc = argc;
 154   prog_argv = argv;
 155
 156 #if defined(WIN32_NATIVE)
 157   tmp = strrchr (argv[0], '\\');
 158   if (tmp != (char *)0)
 159     tmp++;
 160 #elif !defined (VMS)
 161   tmp = strrchr (argv[0], '/');
 162   if (tmp != (char *)0)
 163     tmp++;
 164 #else
 165   tmp = argv[0];
 166 #endif
 167
 168   if (tmp != (char *)0)
 169     progname = tmp;
 170   else
 171     progname = argv[0];
 172
 173   tmp = &progname[strlen(progname)-2];
 174   if (strcmp (tmp, "cc") == 0)
 175     ellcc_mode = ELLCC_COMPILE_MODE;
 176   else if (strcmp (tmp, "ld") == 0)
 177     ellcc_mode = ELLCC_LINK_MODE;
 178   else if (strcmp (tmp, "it") == 0)
 179     ellcc_mode = ELLCC_INIT_MODE;
 180
 181   exec_argv = xnew(argc + 20, char *);
 182   exec_args = xnew(argc, int);
 183   for (i = 0; i < argc; i++)
 184     exec_args[i] = -1;
 185
 186   if (argc < 2)
 187     fatal ("too few arguments", (char *)0);
 188
 189   exec_args[0] = 0;
 190
 191   for (i = 1; i < argc; i++)
 192     {
 193       if (strncmp (argv[i], "--mode=", 7) == 0)
 194         {
 195           char *modeopt = argv[i] + 7;
 196
 197           if (done_mode && strcmp (modeopt, "verbose"))
 198             fatal ("more than one mode specified", (char *) 0);
 199           if (strcmp (modeopt, "link") == 0)
 200             {
 201               done_mode++;
 202               ellcc_mode = ELLCC_LINK_MODE;
 203             }
 204           else if (strcmp (modeopt, "compile") == 0)
 205             {
 206               done_mode++;
 207               ellcc_mode = ELLCC_COMPILE_MODE;
 208             }
 209           else if (strcmp (modeopt, "init") == 0)
 210             {
 211               done_mode++;
 212               ellcc_mode = ELLCC_INIT_MODE;
 213             }
 214           else if (strcmp (modeopt, "verbose") == 0)
 215             verbose += 1;
 216         }
 217       else if (strcmp (argv[i], "--mod-location") == 0)
 218         {
 219           printf ("%s\n", ELLCC_MODDIR);
 220           return 0;
 221         }
 222       else if (strcmp (argv[i], "--mod-site-location") == 0)
 223         {
 224           printf ("%s\n", ELLCC_SITEMODS);
 225           return 0;
 226         }
 227       else if (strcmp (argv[i], "--mod-archdir") == 0)
 228         {
 229           printf ("%s\n", ELLCC_ARCHDIR);
 230           return 0;
 231         }
 232       else if (strcmp (argv[i], "--mod-config") == 0)
 233         {
 234           printf ("%s\n", ELLCC_CONFIG);
 235           return 0;
 236         }
 237       else if (strncmp (argv[i], "--mod-name=", 11) == 0)
 238         mod_name = argv[i] + 11;
 239       else if (strncmp (argv[i], "--mod-title=", 12) == 0)
 240         mod_title = argv[i] + 12;
 241       else if (strncmp (argv[i], "--mod-version=", 14) == 0)
 242         mod_version = argv[i] + 14;
 243       else if (strncmp (argv[i], "--mod-output=", 13) == 0)
 244         mod_output = argv[i] + 13;
 245       else
 246         {
 247           exec_args[exec_argc] = i;
 248           exec_argc++;
 249         }
 250     }
 251
 252   if (ellcc_mode == ELLCC_LINK_MODE && mod_output == (char *)0)
 253     fatal ("must specify --mod-output when linking", (char *)0);
 254   if (ellcc_mode == ELLCC_INIT_MODE && mod_output == (char *)0)
 255     fatal ("must specify --mod-output when creating init file", (char *)0);
 256   if (ellcc_mode == ELLCC_INIT_MODE && mod_name == (char *)0)
 257     fatal ("must specify --mod-name when creating init file", (char *)0);
 258
 259   /*
 260    * We now have the list of arguments to pass to the compiler or
 261    * linker (or to process for doc files). We can do the real work
 262    * now.
 263    */
 264   if (verbose)
 265     printf ("ellcc driver version %s for EMODULES version %s (%ld)\n",
 266             ELLCC_EMACS_VER, EMODULES_VERSION, EMODULES_REVISION);
 267 #ifdef DEBUG
 268   if (verbose >= 2)
 269     {
 270       printf ("              mode = %d (%s)\n", ellcc_mode,
 271               ellcc_mode == ELLCC_COMPILE_MODE ? "compile" :
 272               ellcc_mode == ELLCC_LINK_MODE ? "link" : "init");
 273       printf ("       module_name = \"%s\"\n", SSTR(mod_name));
 274       printf ("      module_title = \"%s\"\n", SSTR(mod_title));
 275       printf ("    module_version = \"%s\"\n", SSTR(mod_version));
 276
 277       printf ("                CC = %s\n", ELLCC_CC);
 278       printf ("            CFLAGS = %s\n", ELLCC_CFLAGS);
 279       printf ("      CC PIC flags = %s\n", ELLCC_DLL_CFLAGS);
 280       printf ("                LD = %s\n", ELLCC_DLL_LD);
 281       printf ("           LDFLAGS = %s\n", ELLCC_DLL_LDFLAGS);
 282       printf ("      architecture = %s\n", ELLCC_CONFIG);
 283       printf (" Include directory = %s/include\n", ELLCC_ARCHDIR);
 284       printf ("\n");
 285     }
 286 #endif
 287
 288   if (exec_argc < 2)
 289     fatal ("too few arguments", (char *) 0);
 290
 291   /*
 292    * Get the over-rides from the environment
 293    */
 294   OVERENV(ellcc, "ELLCC", ELLCC_CC);
 295   OVERENV(ellld, "ELLLD", ELLCC_DLL_LD);
 296   OVERENV(ellcflags, "ELLCFLAGS", ELLCC_CFLAGS);
 297   OVERENV(ellldflags, "ELLLDFLAGS", ELLCC_LDFLAGS);
 298   OVERENV(elldllflags, "ELLDLLFLAGS", ELLCC_DLL_LDFLAGS);
 299   OVERENV(ellpicflags, "ELLPICFLAGS", ELLCC_DLL_CFLAGS);
 300
 301   if (ellcc_mode == ELLCC_COMPILE_MODE)
 302     do_compile_mode();
 303   else if (ellcc_mode == ELLCC_LINK_MODE)
 304     do_link_mode();
 305   else
 306     do_init_mode();
 307
 308   /*
 309    * The arguments to pass on to the desired program have now been set
 310    * up and we can run the program.
 311    */
 312   if (verbose)
 313     {
 314       for (i = 0; i < real_argc; i++)
 315         printf ("%s ", exec_argv[i]);
 316       printf ("\n");
 317       fflush (stdout);
 318     }
 319   exec_argv[real_argc] = (char *)0; /* Terminate argument list */
 320
 321   i = execvp (exec_argv[0], exec_argv);
 322   if (verbose)
 323     printf ("%s exited with status %d\n", exec_argv[0], i);
 324   return i;
 325 }
 326
 327 /* Like malloc but get fatal error if memory is exhausted.  */
 328 static void *
 329 xmalloc (size_t size)
 330 {
 331   void *result = malloc (size);
 332   if (result == NULL)
 333     fatal ("virtual memory exhausted", (char *)0);
 334   return result;
 335 }
 336
 337 /* Print error message and exit.  */
 338 static void
 339 fatal (char *s1, char *s2)
 340 {
 341   fprintf (stderr, "%s: ", progname);
 342   fprintf (stderr, s1, s2);
 343   fprintf (stderr, "\n");
 344   exit (EXIT_FAILURE);
 345 }
 346
 347 /*
 348  * Add a string to the argument vector list that will be passed on down
 349  * to the compiler or linker. We need to split individual words into
 350  * arguments, taking quoting into account. This can get ugly.
 351  */
 352 static void
 353 add_to_argv (const char *str)
 354 {
 355   int sm = 0;
 356   const char *s = (const char *)0;
 357
 358   if ((str == (const char *)0) || (str[0] == '\0'))
 359     return;
 360
 361   while (*str)
 362     {
 363       switch (sm)
 364         {
 365         case 0: /* Start of case - string leading whitespace */
 366           if (isspace ((unsigned char) *str))
 367             str++;
 368           else
 369             {
 370               sm = 1; /* Change state to non-whitespace */
 371               s = str; /* Mark the start of THIS argument */
 372             }
 373           break;
 374
 375         case 1: /* Non-whitespace character. Mark the start */
 376           if (isspace ((unsigned char) *str))
 377             {
 378               /* Reached the end of the argument. Add it. */
 379               int l = str-s;
 380               exec_argv[real_argc] = xnew (l+2, char);
 381               strncpy (exec_argv[real_argc], s, l);
 382               exec_argv[real_argc][l] = '\0';
 383               real_argc++;
 384               sm = 0; /* Back to start state */
 385               s = (const char *)0;
 386               break;
 387             }
 388           else if (*str == '\\')
 389             {
 390               sm = 2; /* Escaped character */
 391               str++;
 392               break;
 393             }
 394           else if (*str == '\'')
 395             {
 396               /* Start of quoted string (single quotes) */
 397               sm = 3;
 398             }
 399           else if (*str == '"')
 400             {
 401               /* Start of quoted string (double quotes) */
 402               sm = 4;
 403             }
 404           else
 405             {
 406               /* This was just a normal character. Advance the pointer. */
 407               str++;
 408             }
 409           break;
 410
 411         case 2: /* Escaped character */
 412           str++; /* Preserve the quoted character */
 413           sm = 1; /* Go back to gathering state */
 414           break;
 415
 416         case 3: /* Inside single quoted string */
 417           if (*str == '\'')
 418             sm = 1;
 419           str++;
 420           break;
 421
 422         case 4: /* inside double quoted string */
 423           if (*str == '"')
 424             sm = 1;
 425           str++;
 426           break;
 427         }
 428     }
 429
 430   if (s != (const char *)0)
 431     {
 432       int l = str-s;
 433       exec_argv[real_argc] = xnew (l+2, char);
 434       strncpy (exec_argv[real_argc], s, l);
 435       exec_argv[real_argc][l] = '\0';
 436       real_argc++;
 437       s = (const char *)0;
 438     }
 439 }
 440
 441 /*
 442  * For compile mode, things are pretty straight forward. All we need to do
 443  * is build up the argument vector and exec() it. We must just make sure
 444  * that we get all of the required arguments in place.
 445  */
 446 static void
 447 do_compile_mode (void)
 448 {
 449   int i;
 450   char ts[4096]; /* Plenty big enough */
 451
 452   add_to_argv (ellcc);
 453   add_to_argv (ellcflags);
 454   add_to_argv (ellpicflags);
 455   add_to_argv ("-DPIC");
 456   add_to_argv ("-DEMACS_MODULE");
 457 #ifdef XEMACS
 458   add_to_argv ("-DXEMACS_MODULE"); /* Cover both cases */
 459   add_to_argv ("-Dxemacs");
 460 #endif
 461   add_to_argv ("-Demacs");
 462   sprintf (ts, "-I%s/include", ELLCC_ARCHDIR);
 463   add_to_argv (ts);
 464   add_to_argv (ELLCC_CF_ALL);
 465   for (i = 1; i < exec_argc; i++)
 466     exec_argv[real_argc++] = strdup (prog_argv[exec_args[i]]);
 467 }
 468
 469 /*
 470  * For link mode, things are a little bit more complicated. We need to
 471  * insert the linker commands first, replace any occurrence of ELLSONAME
 472  * with the desired output file name, insert the output arguments, then
 473  * all of the provided arguments, then the final post arguments. Once
 474  * all of this has been done, the argument vector is ready to run.
 475  */
 476 static void
 477 do_link_mode (void)
 478 {
 479   int i,x;
 480   char *t, ts[4096]; /* Plenty big enough */
 481
 482   add_to_argv (ellld);
 483   add_to_argv (ellldflags);
 484   add_to_argv (elldllflags);
 485   add_to_argv (ELLCC_DLL_LDO);
 486   add_to_argv (mod_output);
 487   for (i = 1; i < exec_argc; i++)
 488     exec_argv[real_argc++] = strdup (prog_argv[exec_args[i]]);
 489   add_to_argv (ELLCC_DLL_POST);
 490
 491   /*
 492    * Now go through each argument and replace ELLSONAME with mod_output.
 493    */
 494   for (i = 0; i < real_argc; i++)
 495     {
 496       x = 0;
 497       ts[0] = '\0';
 498
 499       t = exec_argv[i];
 500       while (*t)
 501         {
 502           if (*t == 'E')
 503             {
 504               if (strncmp (t, "ELLSONAME", 9) == 0)
 505                 {
 506                   strcat (ts, mod_output);
 507                   t += 8;
 508                   x += strlen (mod_output);
 509                 }
 510               else
 511                 {
 512                   ts[x] = *t;
 513                   x++;
 514                   ts[x] = '\0';
 515                 }
 516             }
 517           else
 518             {
 519               ts[x] = *t;
 520               x++;
 521               ts[x] = '\0';
 522             }
 523           t++;
 524         }
 525       free (exec_argv[i]);
 526       exec_argv[i] = strdup (ts);
 527     }
 528 }
 529
 530 /*
 531  * In init mode, things are a bit easier. We assume that the only things
 532  * passed on the command line are the names of source files which the
 533  * make-doc program will be processing. We prepare the output file with
 534  * the header information first, as make-doc will append to the file by
 535  * special dispensation.
 536  */
 537 static void
 538 do_init_mode (void)
 539 {
 540   int i;
 541   char ts[4096]; /* Plenty big enough */
 542   char *mdocprog;
 543   FILE *mout = fopen (mod_output, "w");
 544
 545   if (mout == (FILE *)0)
 546     fatal ("failed to open output file", mod_output);
 547   fprintf (mout, "/* DO NOT EDIT - AUTOMATICALLY GENERATED */\n\n");
 548   fprintf (mout, "#include <emodules.h>\n\n");
 549   fprintf (mout, "const long emodule_compiler = %ld;\n", EMODULES_REVISION);
 550   fprintf (mout, "const char *emodule_name = \"%s\";\n", SSTR(mod_name));
 551   fprintf (mout, "const char *emodule_version = \"%s\";\n", SSTR(mod_version));
 552   fprintf (mout, "const char *emodule_title = \"%s\";\n", SSTR(mod_title));
 553   fprintf (mout, "\n\n");
 554   fprintf (mout, "void docs_of_%s()\n", SSTR(mod_name));
 555   fclose (mout);
 556
 557   sprintf (ts, "%s/make-docfile", ELLCC_ARCHDIR);
 558   OVERENV(mdocprog, "ELLMAKEDOC", ts);
 559   add_to_argv (mdocprog);
 560   sprintf (ts, "-E %s", mod_output);
 561   add_to_argv (ts);
 562   for (i = 1; i < exec_argc; i++)
 563     exec_argv[real_argc++] = strdup (prog_argv[exec_args[i]]);
 564 }
 565
 566 #endif /* HAVE_SHLIB */
 567