soltools/mkdepend/main.c

   1 /* $XConsortium: main.c,v 1.84 94/11/30 16:10:44 kaleb Exp $ */
   2 /* $XFree86: xc/config/makedepend/main.c,v 3.4 1995/07/15 14:53:49 dawes Exp $ */
   3 /*
   4
   5 Copyright (c) 1993, 1994  X Consortium
   6
   7 Permission is hereby granted, free of charge, to any person obtaining a copy
   8 of this software and associated documentation files (the "Software"), to deal
   9 in the Software without restriction, including without limitation the rights
  10 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  11 copies of the Software, and to permit persons to whom the Software is
  12 furnished to do so, subject to the following conditions:
  13
  14 The above copyright notice and this permission notice shall be included in
  15 all copies or substantial portions of the Software.
  16
  17 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  20 X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23
  24 Except as contained in this notice, the name of the X Consortium shall not be
  25 used in advertising or otherwise to promote the sale, use or other dealings
  26 in this Software without prior written authorization from the X Consortium.
  27
  28 */
  29
  30 #if defined(FREEBSD) || defined(MACOSX)
  31 #include <sys/types.h>
  32 #include <sys/stat.h>
  33 #endif
  34
  35 #ifdef _MSC_VER     /* Define ssize_t */
  36
  37 #if !defined(_W64)
  38 #if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && _MSC_VER >= 1300
  39 #define _W64 __w64
  40 #else
  41 #define _W64
  42 #endif
  43 #endif
  44
  45 #ifdef  _WIN64
  46 typedef __int64    ssize_t;
  47 #else
  48 typedef _W64 int   ssize_t;
  49 #endif
  50
  51 #endif
  52
  53 #include "def.h"
  54 #include <string.h>
  55 #ifdef hpux
  56 #define sigvec sigvector
  57 #endif /* hpux */
  58
  59 #ifdef X_POSIX_C_SOURCE
  60 #define _POSIX_C_SOURCE X_POSIX_C_SOURCE
  61 #include <signal.h>
  62 #undef _POSIX_C_SOURCE
  63 #else
  64 #if defined(X_NOT_POSIX) || defined(_POSIX_SOURCE)
  65 #include <signal.h>
  66 #else
  67 #define _POSIX_SOURCE
  68 #include <signal.h>
  69 #undef _POSIX_SOURCE
  70 #endif
  71 #endif
  72
  73 #include <stdarg.h>
  74
  75 #ifdef MINIX
  76 #define USE_CHMOD   1
  77 #endif
  78
  79 #ifdef DEBUG
  80 int _debugmask;
  81 #endif
  82
  83 char *ProgramName;
  84
  85 #define OBJSUFFIX ".obj"
  86 #define INCLUDEDIR "."
  87
  88 char    *directives[] = {
  89     "if",
  90     "ifdef",
  91     "ifndef",
  92     "else",
  93     "endif",
  94     "define",
  95     "undef",
  96     "include",
  97     "line",
  98     "pragma",
  99     "error",
 100     "ident",
 101     "sccs",
 102     "elif",
 103     "eject",
 104     NULL
 105 };
 106
 107 #define MAKEDEPEND
 108 #include "imakemdep.h"  /* from config sources */
 109 #undef MAKEDEPEND
 110
 111 /*******   function declarations ********/
 112 /*******   added by -Wall project *******/
 113 void redirect(char * line, char * makefile );
 114
 115 struct  inclist inclist[ MAXFILES ],
 116         *inclistp = inclist;
 117
 118 struct symhash *maininclist = NULL;
 119
 120 char    *filelist[ MAXFILES ];
 121 char    *includedirs[ MAXDIRS + 1 ];
 122 char    *notdotdot[ MAXDIRS ];
 123 char    *objprefix = "";
 124 char    *objsuffix = OBJSUFFIX;
 125 char    *startat = "# DO NOT DELETE";
 126 int width = 78;
 127 boolean append = FALSE;
 128 boolean printed = FALSE;
 129 boolean verbose = FALSE;
 130 boolean show_where_not = FALSE;
 131 boolean warn_multiple = FALSE;  /* Warn on multiple includes of same file */
 132
 133 static
 134 #ifdef SIGNALRETURNSINT
 135 int
 136 #else
 137 void
 138 #endif
 139 catch (sig)
 140     int sig;
 141 {
 142     fflush (stdout);
 143     fatalerr ("got signal %d\n", sig);
 144 }
 145
 146 #if defined(USG) || (defined(i386) && defined(SYSV)) || defined(WIN32) || defined(OS2) || defined(Lynx_22)
 147 #define USGISH
 148 #endif
 149
 150 #ifndef USGISH
 151 #ifndef _POSIX_SOURCE
 152 #define sigaction sigvec
 153 #define sa_handler sv_handler
 154 #define sa_mask sv_mask
 155 #define sa_flags sv_flags
 156 #endif
 157 struct sigaction sig_act;
 158 #endif /* USGISH */
 159
 160 boolean native_win_slashes = FALSE;
 161
 162 int main(argc, argv)
 163     int argc;
 164     char    **argv;
 165 {
 166     register char   **fp = filelist;
 167     register char   **incp = includedirs;
 168     register char   *p;
 169     register struct inclist *ip;
 170     char    *makefile = NULL;
 171     struct filepointer  *filecontent;
 172     struct pair *psymp = predefs;
 173     char *endmarker = NULL;
 174     char *defincdir = NULL;
 175     struct IncludesCollection* incCollection;
 176
 177     ProgramName = argv[0];
 178
 179     while (psymp->p_name)
 180     {
 181         hash_define(psymp->p_name, psymp->p_value, &maininclist);
 182         psymp++;
 183     }
 184     if (argc == 2 && argv[1][0] == '@') {
 185         struct stat ast;
 186         int afd;
 187         char *args;
 188         char **nargv;
 189         int nargc;
 190         char quotechar = '\0';
 191
 192         nargc = 1;
 193         if ((afd = open(argv[1]+1, O_RDONLY)) < 0)
 194         fatalerr("cannot open \"%s\"\n", argv[1]+1);
 195         fstat(afd, &ast);
 196         args = (char *)malloc(ast.st_size + 1);
 197         if ((ast.st_size = read(afd, args, (size_t) ast.st_size)) < 0)
 198         fatalerr("failed to read %s\n", argv[1]+1);
 199         args[ast.st_size] = '\0';
 200         close(afd);
 201         for (p = args; *p; p++) {
 202         if (quotechar) {
 203             if (quotechar == '\\' ||
 204             (*p == quotechar && p[-1] != '\\'))
 205             quotechar = '\0';
 206             continue;
 207         }
 208         switch (*p) {
 209         case '\\':
 210         case '"':
 211         case '\'':
 212             quotechar = *p;
 213             break;
 214         case ' ':
 215         case '\n':
 216             *p = '\0';
 217             if (p > args && p[-1])
 218             nargc++;
 219             break;
 220         }
 221         }
 222         if (p[-1])
 223         nargc++;
 224         nargv = (char **)malloc(nargc * sizeof(char *));
 225         nargv[0] = argv[0];
 226         argc = 1;
 227         for (p = args; argc < nargc; p += strlen(p) + 1)
 228         if (*p) nargv[argc++] = p;
 229         argv = nargv;
 230     }
 231     for(argc--, argv++; argc; argc--, argv++) {
 232             /* if looking for endmarker then check before parsing */
 233         if (endmarker && strcmp (endmarker, *argv) == 0) {
 234             endmarker = NULL;
 235             continue;
 236         }
 237         if (**argv != '-') {
 238             /* treat +thing as an option for C++ */
 239             if (endmarker && **argv == '+')
 240                 continue;
 241             *fp++ = argv[0];
 242             continue;
 243         }
 244         switch(argv[0][1]) {
 245         case '-':
 246             endmarker = &argv[0][2];
 247             if (endmarker[0] == '\0') endmarker = "--";
 248             break;
 249         case 'D':
 250             if (argv[0][2] == '\0') {
 251                 argv++;
 252                 argc--;
 253             }
 254             for (p=argv[0] + 2; *p ; p++)
 255                 if (*p == '=') {
 256                     *p = ' ';
 257                     break;
 258                 }
 259             define(argv[0] + 2, &maininclist);
 260             break;
 261         case 'I':
 262             if (incp >= includedirs + MAXDIRS)
 263                 fatalerr("Too many -I flags.\n");
 264             *incp++ = argv[0]+2;
 265             if (**(incp-1) == '\0') {
 266                 *(incp-1) = *(++argv);
 267                 argc--;
 268             }
 269             break;
 270         case 'Y':
 271             defincdir = argv[0]+2;
 272             break;
 273         /* do not use if endmarker processing */
 274         case 'a':
 275             if (endmarker) break;
 276             append = TRUE;
 277             break;
 278         case 'w':
 279             if (endmarker) break;
 280             if (argv[0][2] == '\0') {
 281                 argv++;
 282                 argc--;
 283                 width = atoi(argv[0]);
 284             } else
 285                 width = atoi(argv[0]+2);
 286             break;
 287         case 'n':
 288             // Use "-n" switch to generate dependencies with windows-native slash style
 289             native_win_slashes = TRUE;
 290             break;
 291         case 'o':
 292             if (endmarker) break;
 293             if (argv[0][2] == '\0') {
 294                 argv++;
 295                 argc--;
 296                 objsuffix = argv[0];
 297             } else
 298                 objsuffix = argv[0]+2;
 299             break;
 300         case 'p':
 301             if (endmarker) break;
 302             if (argv[0][2] == '\0') {
 303                 argv++;
 304                 argc--;
 305                 objprefix = argv[0];
 306             } else
 307                 objprefix = argv[0]+2;
 308             break;
 309         case 'v':
 310             if (endmarker) break;
 311             verbose = TRUE;
 312 #ifdef DEBUG
 313             if (argv[0][2])
 314                 _debugmask = atoi(argv[0]+2);
 315 #endif
 316             break;
 317         case 's':
 318             if (endmarker) break;
 319             startat = argv[0]+2;
 320             if (*startat == '\0') {
 321                 startat = *(++argv);
 322                 argc--;
 323             }
 324             if (*startat != '#')
 325                 fatalerr("-s flag's value should start %s\n",
 326                     "with '#'.");
 327             break;
 328         case 'f':
 329             if (endmarker) break;
 330             makefile = argv[0]+2;
 331             if (*makefile == '\0') {
 332                 makefile = *(++argv);
 333                 argc--;
 334             }
 335             break;
 336
 337         case 'm':
 338             warn_multiple = TRUE;
 339             break;
 340
 341         /* Ignore -O, -g so we can just pass ${CFLAGS} to
 342            makedepend
 343          */
 344         case 'O':
 345         case 'g':
 346             break;
 347         default:
 348             if (endmarker) break;
 349     /*      fatalerr("unknown opt = %s\n", argv[0]); */
 350             warning("ignoring option %s\n", argv[0]);
 351         }
 352     }
 353
 354     convert_slashes(objprefix);
 355     objprefix = append_slash(objprefix);
 356
 357     if (!defincdir) {
 358 #ifdef PREINCDIR
 359         if (incp >= includedirs + MAXDIRS)
 360         fatalerr("Too many -I flags.\n");
 361         *incp++ = PREINCDIR;
 362 #endif
 363         if (incp >= includedirs + MAXDIRS)
 364         fatalerr("Too many -I flags.\n");
 365         *incp++ = INCLUDEDIR;
 366 #ifdef POSTINCDIR
 367         if (incp >= includedirs + MAXDIRS)
 368         fatalerr("Too many -I flags.\n");
 369         *incp++ = POSTINCDIR;
 370 #endif
 371     } else if (*defincdir) {
 372         if (incp >= includedirs + MAXDIRS)
 373         fatalerr("Too many -I flags.\n");
 374         *incp++ = defincdir;
 375     }
 376
 377     redirect(startat, makefile);
 378
 379     /*
 380      * catch signals.
 381      */
 382 #ifdef USGISH
 383 /*  should really reset SIGINT to SIG_IGN if it was.  */
 384 #ifdef SIGHUP
 385     signal (SIGHUP, catch);
 386 #endif
 387     signal (SIGINT, catch);
 388 #ifdef SIGQUIT
 389     signal (SIGQUIT, catch);
 390 #endif
 391     signal (SIGILL, catch);
 392 #ifdef SIGBUS
 393     signal (SIGBUS, catch);
 394 #endif
 395     signal (SIGSEGV, catch);
 396 #ifdef SIGSYS
 397     signal (SIGSYS, catch);
 398 #endif
 399     signal (SIGFPE, catch);
 400 #else
 401     sig_act.sa_handler = catch;
 402 #ifdef _POSIX_SOURCE
 403     sigemptyset(&sig_act.sa_mask);
 404     sigaddset(&sig_act.sa_mask, SIGINT);
 405     sigaddset(&sig_act.sa_mask, SIGQUIT);
 406 #ifdef SIGBUS
 407     sigaddset(&sig_act.sa_mask, SIGBUS);
 408 #endif
 409     sigaddset(&sig_act.sa_mask, SIGILL);
 410     sigaddset(&sig_act.sa_mask, SIGSEGV);
 411     sigaddset(&sig_act.sa_mask, SIGHUP);
 412     sigaddset(&sig_act.sa_mask, SIGPIPE);
 413 #ifdef SIGSYS
 414     sigaddset(&sig_act.sa_mask, SIGSYS);
 415 #endif
 416 #else
 417     sig_act.sa_mask = ((1<<(SIGINT -1))
 418                |(1<<(SIGQUIT-1))
 419 #ifdef SIGBUS
 420                |(1<<(SIGBUS-1))
 421 #endif
 422                |(1<<(SIGILL-1))
 423                |(1<<(SIGSEGV-1))
 424                |(1<<(SIGHUP-1))
 425                |(1<<(SIGPIPE-1))
 426 #ifdef SIGSYS
 427                |(1<<(SIGSYS-1))
 428 #endif
 429                );
 430 #endif /* _POSIX_SOURCE */
 431     sig_act.sa_flags = 0;
 432     sigaction(SIGHUP, &sig_act, (struct sigaction *)0);
 433     sigaction(SIGINT, &sig_act, (struct sigaction *)0);
 434     sigaction(SIGQUIT, &sig_act, (struct sigaction *)0);
 435     sigaction(SIGILL, &sig_act, (struct sigaction *)0);
 436 #ifdef SIGBUS
 437     sigaction(SIGBUS, &sig_act, (struct sigaction *)0);
 438 #endif
 439     sigaction(SIGSEGV, &sig_act, (struct sigaction *)0);
 440 #ifdef SIGSYS
 441     sigaction(SIGSYS, &sig_act, (struct sigaction *)0);
 442 #endif
 443 #endif /* USGISH */
 444
 445     /*
 446      * now peruse through the list of files.
 447      */
 448     incCollection = create_IncludesCollection();
 449
 450     for(fp=filelist; *fp; fp++) {
 451         struct symhash *includes;
 452         filecontent = getfile(*fp);
 453         ip = newinclude(*fp, (char *)NULL);
 454
 455         includes = hash_copy( maininclist );
 456         find_includes(filecontent, ip, ip, 0, FALSE, incCollection, includes);
 457         hash_free( includes );
 458
 459         freefile(filecontent);
 460         recursive_pr_include(ip, ip->i_file, base_name(*fp));
 461         inc_clean();
 462     }
 463     if (printed)
 464         printf("\n");
 465
 466     delete_IncludesCollection(incCollection);
 467
 468     exit(0);
 469 }
 470
 471 struct filepointer *getfile(file)
 472     char    *file;
 473 {
 474     register int    fd;
 475     struct filepointer  *content;
 476     struct stat st;
 477     off_t       size_backup;
 478     ssize_t     bytes_read;
 479     size_t      malloc_size;
 480
 481     content = (struct filepointer *)malloc(sizeof(struct filepointer));
 482     if ((fd = open(file, O_RDONLY)) < 0) {
 483         warning("makedepend:  Cannot open file \"%s\"\n", file);
 484         content->f_p = content->f_base = content->f_end = (char *)malloc(1);
 485         *content->f_p = '\0';
 486         return(content);
 487     }
 488     fstat(fd, &st);
 489
 490     size_backup = st.st_size;
 491     malloc_size = size_backup;
 492     /* Since off_t is larger than size_t, need to test for
 493      * truncation.
 494      */
 495     if ( (off_t)malloc_size != size_backup )
 496     {
 497         close( fd );
 498         warning("makedepend:  File \"%s\" size larger than can fit in size_t.  Cannot allocate memory for contents.\n", file);
 499         content->f_p = content->f_base = content->f_end = (char *)malloc(1);
 500         *content->f_p = '\0';
 501         return(content);
 502     }
 503
 504     content->f_base = (char *)malloc(malloc_size+1);
 505     if (content->f_base == NULL)
 506         fatalerr("makedepend:  Cannot allocate memory to process file \"%s\"\n", file);
 507     if ((bytes_read = read(fd, content->f_base, malloc_size)) < 0)
 508         if ( st.st_mode & S_IFREG )
 509             fatalerr("makedepend:  Failed to read file \"%s\"\n", file);
 510
 511     close(fd);
 512     content->f_len = bytes_read+1;
 513     content->f_p = content->f_base;
 514     content->f_end = content->f_base + bytes_read;
 515     *content->f_end = '\0';
 516     content->f_line = 0;
 517     return(content);
 518 }
 519
 520 void freefile(fp)
 521     struct filepointer  *fp;
 522 {
 523     free(fp->f_base);
 524     free(fp);
 525 }
 526
 527 char *copy(str)
 528     register char   *str;
 529 {
 530     register char   *p = (char *)malloc(strlen(str) + 1);
 531
 532     strcpy(p, str);
 533     return(p);
 534 }
 535
 536 int match(str, list)
 537     register char   *str, **list;
 538 {
 539     register int    i;
 540
 541     for (i=0; *list; i++, list++)
 542         if (strcmp(str, *list) == 0)
 543             return(i);
 544     return(-1);
 545 }
 546
 547 /*
 548  * Get the next line.  We only return lines beginning with '#' since that
 549  * is all this program is ever interested in.
 550  */
 551 char *get_line(filep)
 552     register struct filepointer *filep;
 553 {
 554     register char   *p, /* walking pointer */
 555             *eof,   /* end of file pointer */
 556             *bol;   /* beginning of line pointer */
 557     register int    lineno; /* line number */
 558
 559     p = filep->f_p;
 560     eof = filep->f_end;
 561     if (p >= eof)
 562         return((char *)NULL);
 563     lineno = filep->f_line;
 564
 565     for(bol = p--; ++p < eof; ) {
 566         if (*p == '/' && *(p+1) == '*') { /* consume comments */
 567             *p++ = ' ', *p++ = ' ';
 568             while (*p) {
 569                 if (*p == '*' && *(p+1) == '/') {
 570                     *p++ = ' ', *p = ' ';
 571                     break;
 572                 }
 573                 else if (*p == '\n')
 574                     lineno++;
 575                 *p++ = ' ';
 576             }
 577             continue;
 578         }
 579         else if (*p == '/' && *(p+1) == '/') { /* consume comments */
 580             *p++ = ' ', *p++ = ' ';
 581             while (*p && *p != '\n')
 582                 *p++ = ' ';
 583             if ( *p == '\n' )
 584                 p--;
 585             lineno++;
 586             continue;
 587         }
 588         else if (*p == '\\') {
 589             if (*(p+1) == '\n') {
 590                 *p = ' ';
 591                 *(p+1) = ' ';
 592                 lineno++;
 593             }
 594         }
 595         else if (*p == '\n') {
 596             lineno++;
 597             if (*bol == '#') {
 598                 register char *cp;
 599
 600                 *p++ = '\0';
 601                 /* punt lines with just # (yacc generated) */
 602                 for (cp = bol+1;
 603                      *cp && (*cp == ' ' || *cp == '\t'); cp++);
 604                 if (*cp) goto done;
 605             }
 606             bol = p+1;
 607         }
 608     }
 609     if (*bol != '#')
 610         bol = NULL;
 611 done:
 612     filep->f_p = p;
 613     filep->f_line = lineno;
 614     return(bol);
 615 }
 616
 617 /*
 618  * Strip the file name down to what we want to see in the Makefile.
 619  * It will have objprefix and objsuffix around it.
 620  */
 621 char *base_name(file)
 622     register char   *file;
 623 {
 624     register char   *p;
 625
 626     file = copy(file);
 627     for(p=file+strlen(file); p>file && *p != '.'; p--) ;
 628
 629     if (*p == '.')
 630         *p = '\0';
 631
 632     while (p > file) {
 633         if ( *p == '/' ||  *p == '\\') {
 634             file = p + 1;
 635             break;
 636         };
 637         p--;
 638     };
 639     return(file);
 640 }
 641
 642 #if defined(USG) && !defined(CRAY) && !defined(SVR4)
 643 int rename (from, to)
 644     char *from, *to;
 645 {
 646     (void) unlink (to);
 647     if (link (from, to) == 0) {
 648     unlink (from);
 649     return 0;
 650     } else {
 651     return -1;
 652     }
 653 }
 654 #endif /* USGISH */
 655
 656 void redirect(line, makefile)
 657     char    *line,
 658         *makefile;
 659 {
 660     struct stat st;
 661     FILE    *fdin, *fdout;
 662     char    backup[ BUFSIZ ],
 663         buf[ BUFSIZ ];
 664     boolean found = FALSE;
 665     int len;
 666
 667     /*
 668      * if makefile is "-" then let it pour onto stdout.
 669      */
 670     if (makefile && *makefile == '-' && *(makefile+1) == '\0')
 671         return;
 672
 673     /*
 674      * use a default makefile is not specified.
 675      */
 676     if (!makefile) {
 677         if (stat("Makefile", &st) == 0)
 678             makefile = "Makefile";
 679         else if (stat("makefile", &st) == 0)
 680             makefile = "makefile";
 681         else
 682             fatalerr("[mM]akefile is not present\n");
 683     }
 684     else
 685         stat(makefile, &st);
 686     if ((fdin = fopen(makefile, "r")) == NULL)
 687         fatalerr("cannot open \"%s\"\n", makefile);
 688     sprintf(backup, "%s.bak", makefile);
 689     unlink(backup);
 690 #if defined(WIN32) || defined(OS2)
 691     fclose(fdin);
 692 #endif
 693     if (rename(makefile, backup) < 0)
 694         fatalerr("cannot rename %s to %s\n", makefile, backup);
 695 #if defined(WIN32) || defined(OS2)
 696     if ((fdin = fopen(backup, "r")) == NULL)
 697         fatalerr("cannot open \"%s\"\n", backup);
 698 #endif
 699     if ((fdout = freopen(makefile, "w", stdout)) == NULL)
 700         fatalerr("cannot open \"%s\"\n", backup);
 701     len = strlen(line);
 702     while (!found && fgets(buf, BUFSIZ, fdin)) {
 703         if (*buf == '#' && strncmp(line, buf, len) == 0)
 704             found = TRUE;
 705         fputs(buf, fdout);
 706     }
 707     if (!found) {
 708         if (verbose)
 709         warning("Adding new delimiting line \"%s\" and dependencies...\n",
 710             line);
 711         puts(line); /* same as fputs(fdout); but with newline */
 712     } else if (append) {
 713         while (fgets(buf, BUFSIZ, fdin)) {
 714         fputs(buf, fdout);
 715         }
 716     }
 717     fflush(fdout);
 718 #if defined(USGISH) || defined(_SEQUENT_) || defined(USE_CHMOD)
 719     chmod(makefile, st.st_mode);
 720 #else
 721     fchmod(fileno(fdout), st.st_mode);
 722 #endif /* USGISH */
 723     fclose(fdin);
 724 }
 725
 726 void fatalerr(char *msg, ...)
 727 {
 728     va_list args;
 729     fprintf(stderr, "%s: error:  ", ProgramName);
 730     va_start(args, msg);
 731     vfprintf(stderr, msg, args);
 732     va_end(args);
 733     exit (1);
 734 }
 735
 736 void warning(char *msg, ...)
 737 {
 738 #ifdef DEBUG_MKDEPEND
 739     va_list args;
 740     fprintf(stderr, "%s: warning:  ", ProgramName);
 741     va_start(args, msg);
 742     vfprintf(stderr, msg, args);
 743     va_end(args);
 744 #else
 745     (void)msg;
 746 #endif /* DEBUG_MKDEPEND */
 747 }
 748
 749 void warning1(char *msg, ...)
 750 {
 751 #ifdef DEBUG_MKDEPEND
 752     va_list args;
 753     va_start(args, msg);
 754     vfprintf(stderr, msg, args);
 755     va_end(args);
 756 #else
 757     (void)msg;
 758 #endif /* DEBUG_MKDEPEND */
 759 }
 760
 761 void convert_slashes(path)
 762     char* path;
 763 {
 764 #if defined (WNT) || defined(OS2)
 765     /*
 766      * Convert backslashes to slashes
 767      */
 768     char *ptr;
 769     if (native_win_slashes) {
 770         for (ptr = (char*)path; *ptr; ++ptr)
 771             if (*ptr == '/')
 772                 *ptr = '\\';
 773     } else {
 774         for (ptr = (char*)path; *ptr; ++ptr)
 775             if (*ptr == '\\')
 776                 *ptr = '/';
 777     };
 778 #else
 779     (void)path;
 780 #endif
 781 }
 782
 783 char* append_slash(path)
 784     char* path;
 785 {
 786     char *new_string;
 787     if ((path[strlen(path) - 1] == '/') || (path[strlen(path) - 1] == '\\')) {
 788         new_string = path;
 789     } else {
 790         new_string = (char*)malloc(sizeof(char) * (strlen(path) + 2));
 791         strcpy(new_string, path);
 792         if (native_win_slashes)
 793             strcat(new_string, "\\");
 794         else
 795             strcat(new_string, "/");
 796     };
 797     return new_string;
 798 }
 799