← Back to branch summary

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

« back to all changes in this revision

Viewing changes to 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:
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
 
}