← Back to branch summary

~ubuntu-branches/ubuntu/quantal/enigmail/quantal-security

« back to all changes in this revision

Viewing changes to mozilla/config/mkdepend/main.c

  • Committer: Package Import Robot
  • Author(s): Chris Coulson
  • Date: 2013-09-13 16:02:15 UTC
  • mfrom: (0.12.16)
  • Revision ID: package-import@ubuntu.com-20130913160215-u3g8nmwa0pdwagwc
Tags: 2:1.5.2-0ubuntu0.12.10.1
* New upstream release v1.5.2 for Thunderbird 24

* Build enigmail using a stripped down Thunderbird 17 build system, as it's
  now quite difficult to build the way we were doing previously, with the
  latest Firefox build system
* Add debian/patches/no_libxpcom.patch - Don't link against libxpcom, as it
  doesn't exist anymore (but exists in the build system)
* Add debian/patches/use_sdk.patch - Use the SDK version of xpt.py and
  friends
* Drop debian/patches/ipc-pipe_rename.diff (not needed anymore)
* Drop debian/patches/makefile_depth.diff (not needed anymore)

Show diffs side-by-side

added added

removed removed

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