← Back to branch summary

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

« back to all changes in this revision

Viewing changes to mozilla/config/mkdepend/parse.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/parse.c
 
1
/* $Xorg: parse.c,v 1.6 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
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/parse.c,v 1.12 2002/02/26 05:09:10 tsi Exp $ */
 
28
 
 
29
#include "def.h"
 
30
 
 
31
extern char     *directives[];
 
32
extern struct inclist   inclist[ MAXFILES ],
 
33
                        *inclistnext,
 
34
                        maininclist;
 
35
extern char     *includedirs[ ],
 
36
                **includedirsnext;
 
37
 
 
38
static int deftype (char *line, struct filepointer *filep,
 
39
                    struct inclist *file_red, struct inclist *file,
 
40
                    int parse_it);
 
41
static int zero_value(char *filename, char *exp, struct filepointer *filep,
 
42
                    struct inclist *file_red);
 
43
static int merge2defines(struct inclist *file1, struct inclist *file2);
 
44
 
 
45
static int
 
46
gobble(struct filepointer *filep, struct inclist *file,
 
47
       struct inclist *file_red)
 
48
{
 
49
        char    *line;
 
50
        int     type;
 
51
 
 
52
        while ((line = getnextline(filep))) {
 
53
                switch(type = deftype(line, filep, file_red, file, FALSE)) {
 
54
                case IF:
 
55
                case IFFALSE:
 
56
                case IFGUESSFALSE:
 
57
                case IFDEF:
 
58
                case IFNDEF:
 
59
                        type = gobble(filep, file, file_red);
 
60
                        while ((type == ELIF) || (type == ELIFFALSE) ||
 
61
                               (type == ELIFGUESSFALSE))
 
62
                            type = gobble(filep, file, file_red);
 
63
                        if (type == ELSE)
 
64
                                (void)gobble(filep, file, file_red);
 
65
                        break;
 
66
                case ELSE:
 
67
                case ENDIF:
 
68
                        debug(0,("%s, line %d: #%s\n",
 
69
                                file->i_file, filep->f_line,
 
70
                                directives[type]));
 
71
                        return(type);
 
72
                case DEFINE:
 
73
                case UNDEF:
 
74
                case INCLUDE:
 
75
                case INCLUDEDOT:
 
76
                case PRAGMA:
 
77
                case ERROR:
 
78
                case IDENT:
 
79
                case SCCS:
 
80
                case EJECT:
 
81
                case WARNING:
 
82
                case INCLUDENEXT:
 
83
                case INCLUDENEXTDOT:
 
84
                        break;
 
85
                case ELIF:
 
86
                case ELIFFALSE:
 
87
                case ELIFGUESSFALSE:
 
88
                        return(type);
 
89
                case -1:
 
90
                        warning("%s", file_red->i_file);
 
91
                        if (file_red != file)
 
92
                                warning1(" (reading %s)", file->i_file);
 
93
                        warning1(", line %d: unknown directive == \"%s\"\n",
 
94
                                filep->f_line, line);
 
95
                        break;
 
96
                }
 
97
        }
 
98
        return(-1);
 
99
}
 
100
 
 
101
/*
 
102
 * Decide what type of # directive this line is.
 
103
 */
 
104
static int 
 
105
deftype (char *line, struct filepointer *filep, 
 
106
             struct inclist *file_red, struct inclist *file, int parse_it)
 
107
{
 
108
        register char   *p;
 
109
        char    *directive, savechar, *q;
 
110
        register int    ret;
 
111
 
 
112
        /*
 
113
         * Parse the directive...
 
114
         */
 
115
        directive=line+1;
 
116
        while (*directive == ' ' || *directive == '\t')
 
117
                directive++;
 
118
 
 
119
        p = directive;
 
120
        while ((*p == '_') || (*p >= 'a' && *p <= 'z'))
 
121
                p++;
 
122
        savechar = *p;
 
123
        *p = '\0';
 
124
        ret = match(directive, directives);
 
125
        *p = savechar;
 
126
 
 
127
        /* If we don't recognize this compiler directive or we happen to just
 
128
         * be gobbling up text while waiting for an #endif or #elif or #else
 
129
         * in the case of an #elif we must check the zero_value and return an
 
130
         * ELIF or an ELIFFALSE.
 
131
         */
 
132
 
 
133
        if (ret == ELIF && !parse_it)
 
134
        {
 
135
            while (*p == ' ' || *p == '\t')
 
136
                p++;
 
137
            /*
 
138
             * parse an expression.
 
139
             */
 
140
            debug(0,("%s, line %d: #elif %s ",
 
141
                   file->i_file, filep->f_line, p));
 
142
            ret = zero_value(file->i_file, p, filep, file_red);
 
143
            if (ret != IF)
 
144
            {
 
145
                debug(0,("false...\n"));
 
146
                if (ret == IFFALSE)
 
147
                    return(ELIFFALSE);
 
148
                else
 
149
                    return(ELIFGUESSFALSE);
 
150
            }
 
151
            else
 
152
            {
 
153
                debug(0,("true...\n"));
 
154
                return(ELIF);
 
155
            }
 
156
        }
 
157
 
 
158
        if (ret < 0 || ! parse_it)
 
159
                return(ret);
 
160
 
 
161
        /*
 
162
         * now decide how to parse the directive, and do it.
 
163
         */
 
164
        while (*p == ' ' || *p == '\t')
 
165
                p++;
 
166
        q = p + strlen(p);
 
167
        do {
 
168
                q--;
 
169
        } while (*q == ' ' || *q == '\t');
 
170
        q[1] = '\0';
 
171
        switch (ret) {
 
172
        case IF:
 
173
                /*
 
174
                 * parse an expression.
 
175
                 */
 
176
                ret = zero_value(file->i_file, p, filep, file_red);
 
177
                debug(0,("%s, line %d: %s #if %s\n",
 
178
                         file->i_file, filep->f_line, ret?"false":"true", p));
 
179
                break;
 
180
        case IFDEF:
 
181
        case IFNDEF:
 
182
                debug(0,("%s, line %d: #%s %s\n",
 
183
                        file->i_file, filep->f_line, directives[ret], p));
 
184
        case UNDEF:
 
185
                /*
 
186
                 * separate the name of a single symbol.
 
187
                 */
 
188
                while (isalnum(*p) || *p == '_')
 
189
                        *line++ = *p++;
 
190
                *line = '\0';
 
191
                break;
 
192
        case INCLUDE:
 
193
        case INCLUDENEXT:
 
194
                debug(2,("%s, line %d: #include%s %s\n",
 
195
                        file->i_file, filep->f_line,
 
196
                        (ret == INCLUDE) ? "" : "_next", p));
 
197
 
 
198
                /* Support ANSI macro substitution */
 
199
                while (1) {
 
200
                        struct symtab **sym;
 
201
 
 
202
                        if (!*p || *p == '"' || *p == '<')
 
203
                                break;
 
204
 
 
205
                        sym = isdefined(p, file_red, NULL);
 
206
                        if (!sym)
 
207
                                break;
 
208
 
 
209
                        p = (*sym)->s_value;
 
210
                        debug(3,("%s : #includes SYMBOL %s = %s\n",
 
211
                               file->i_incstring,
 
212
                               (*sym) -> s_name,
 
213
                               (*sym) -> s_value));
 
214
                        /* mark file as having included a 'soft include' */
 
215
                        file->i_flags |= INCLUDED_SYM; 
 
216
                }
 
217
 
 
218
                /*
 
219
                 * Separate the name of the include file.
 
220
                 */
 
221
                while (*p && *p != '"' && *p != '<')
 
222
                        p++;
 
223
                if (! *p)
 
224
                        return(-2);
 
225
                if (*p++ == '"') {
 
226
                        if (ret == INCLUDE)
 
227
                                ret = INCLUDEDOT;
 
228
                        else
 
229
                                ret = INCLUDENEXTDOT;
 
230
                        while (*p && *p != '"')
 
231
                                *line++ = *p++;
 
232
                } else
 
233
                        while (*p && *p != '>')
 
234
                                *line++ = *p++;
 
235
                *line = '\0';
 
236
                break;
 
237
        case DEFINE:
 
238
                /*
 
239
                 * copy the definition back to the beginning of the line.
 
240
                 */
 
241
                strcpy (line, p);
 
242
                break;
 
243
        case ELSE:
 
244
        case ENDIF:
 
245
        case ELIF:
 
246
        case PRAGMA:
 
247
        case ERROR:
 
248
        case IDENT:
 
249
        case SCCS:
 
250
        case EJECT:
 
251
        case WARNING:
 
252
                debug(0,("%s, line %d: #%s\n",
 
253
                        file->i_file, filep->f_line, directives[ret]));
 
254
                /*
 
255
                 * nothing to do.
 
256
                 */
 
257
                break;
 
258
        }
 
259
        return(ret);
 
260
}
 
261
 
 
262
struct symtab **
 
263
fdefined(char *symbol, struct inclist *file, struct inclist **srcfile)
 
264
{
 
265
        struct inclist  **ip;
 
266
        struct symtab   **val;
 
267
        int     i;
 
268
        static int      recurse_lvl = 0;
 
269
 
 
270
        if (file->i_flags & DEFCHECKED)
 
271
                return(NULL);
 
272
        debug(2,("Looking for %s in %s\n", symbol, file->i_file));
 
273
        file->i_flags |= DEFCHECKED;
 
274
        if ((val = slookup(symbol, file)))
 
275
                debug(1,("%s defined in %s as %s\n",
 
276
                         symbol, file->i_file, (*val)->s_value));
 
277
        if (val == NULL && file->i_list)
 
278
        {
 
279
                for (ip = file->i_list, i=0; i < file->i_listlen; i++, ip++)
 
280
                        if (file->i_merged[i]==FALSE) {
 
281
                                val = fdefined(symbol, *ip, srcfile);
 
282
                                file->i_merged[i]=merge2defines(file,*ip);
 
283
                                if (val!=NULL) break;
 
284
                        }
 
285
        }
 
286
        else if (val != NULL && srcfile != NULL) *srcfile = file;
 
287
        recurse_lvl--;
 
288
        file->i_flags &= ~DEFCHECKED;
 
289
 
 
290
        return(val);
 
291
}
 
292
 
 
293
struct symtab **
 
294
isdefined(char *symbol, struct inclist *file, struct inclist **srcfile)
 
295
{
 
296
        struct symtab   **val;
 
297
 
 
298
        if ((val = slookup(symbol, &maininclist))) {
 
299
                debug(1,("%s defined on command line\n", symbol));
 
300
                if (srcfile != NULL) *srcfile = &maininclist;
 
301
                return(val);
 
302
        }
 
303
        if ((val = fdefined(symbol, file, srcfile)))
 
304
                return(val);
 
305
        debug(1,("%s not defined in %s\n", symbol, file->i_file));
 
306
        return(NULL);
 
307
}
 
308
 
 
309
/*
 
310
 * Return type based on if the #if expression evaluates to 0
 
311
 */
 
312
static int
 
313
zero_value(char *filename,
 
314
           char *exp,
 
315
           struct filepointer *filep,
 
316
           struct inclist *file_red)
 
317
{
 
318
        if (cppsetup(filename, exp, filep, file_red))
 
319
            return(IFFALSE);
 
320
        else
 
321
            return(IF);
 
322
}
 
323
 
 
324
void
 
325
define2(char *name, char *val, struct inclist *file)
 
326
{
 
327
    int first, last, below;
 
328
    register struct symtab **sp = NULL, **dest;
 
329
    struct symtab *stab;
 
330
 
 
331
    /* Make space if it's needed */
 
332
    if (file->i_defs == NULL)
 
333
    {
 
334
        file->i_defs = (struct symtab **)
 
335
                        malloc(sizeof (struct symtab*) * SYMTABINC);
 
336
        file->i_ndefs = 0;
 
337
    }
 
338
    else if (!(file->i_ndefs % SYMTABINC))
 
339
        file->i_defs = (struct symtab **)
 
340
                        realloc(file->i_defs,
 
341
                           sizeof(struct symtab*)*(file->i_ndefs+SYMTABINC));
 
342
 
 
343
    if (file->i_defs == NULL)
 
344
        fatalerr("malloc()/realloc() failure in insert_defn()\n");
 
345
 
 
346
    below = first = 0;
 
347
    last = file->i_ndefs - 1;
 
348
    while (last >= first)
 
349
    {
 
350
        /* Fast inline binary search */
 
351
        register char *s1;
 
352
        register char *s2;
 
353
        register int middle = (first + last) / 2;
 
354
 
 
355
        /* Fast inline strchr() */
 
356
        s1 = name;
 
357
        s2 = file->i_defs[middle]->s_name;
 
358
        while (*s1++ == *s2++)
 
359
            if (s2[-1] == '\0') break;
 
360
 
 
361
        /* If exact match, set sp and break */
 
362
        if (*--s1 == *--s2) 
 
363
        {
 
364
            sp = file->i_defs + middle;
 
365
            break;
 
366
        }
 
367
 
 
368
        /* If name > i_defs[middle] ... */
 
369
        if (*s1 > *s2) 
 
370
        {
 
371
            below = first;
 
372
            first = middle + 1;
 
373
        }
 
374
        /* else ... */
 
375
        else
 
376
        {
 
377
            below = last = middle - 1;
 
378
        }
 
379
    }
 
380
 
 
381
    /* Search is done.  If we found an exact match to the symbol name,
 
382
       just replace its s_value */
 
383
    if (sp != NULL)
 
384
    {
 
385
        debug(1,("redefining %s from %s to %s in file %s\n",
 
386
                name, (*sp)->s_value, val, file->i_file));
 
387
        free((*sp)->s_value);
 
388
        (*sp)->s_value = copy(val);
 
389
        return;
 
390
    }
 
391
 
 
392
    sp = file->i_defs + file->i_ndefs++;
 
393
    dest = file->i_defs + below + 1;
 
394
    while (sp > dest)
 
395
    {
 
396
        *sp = sp[-1];
 
397
        sp--;
 
398
    }
 
399
    stab = (struct symtab *) malloc(sizeof (struct symtab));
 
400
    if (stab == NULL)
 
401
        fatalerr("malloc()/realloc() failure in insert_defn()\n");
 
402
 
 
403
    debug(1,("defining %s to %s in file %s\n", name, val, file->i_file));
 
404
    stab->s_name = copy(name);
 
405
    stab->s_value = copy(val);
 
406
    *sp = stab;
 
407
}
 
408
 
 
409
void
 
410
define(char *def, struct inclist *file)
 
411
{
 
412
    char *val;
 
413
 
 
414
    /* Separate symbol name and its value */
 
415
    val = def;
 
416
    while (isalnum(*val) || *val == '_')
 
417
        val++;
 
418
    if (*val)
 
419
        *val++ = '\0';
 
420
    while (*val == ' ' || *val == '\t')
 
421
        val++;
 
422
 
 
423
    if (!*val)
 
424
        val = "1";
 
425
    define2(def, val, file);
 
426
}
 
427
 
 
428
struct symtab **
 
429
slookup(char *symbol, struct inclist *file)
 
430
{
 
431
        register int first = 0;
 
432
        register int last = file->i_ndefs - 1;
 
433
 
 
434
        if (file) while (last >= first)
 
435
        {
 
436
            /* Fast inline binary search */
 
437
            register char *s1;
 
438
            register char *s2;
 
439
            register int middle = (first + last) / 2;
 
440
 
 
441
            /* Fast inline strchr() */
 
442
            s1 = symbol;
 
443
            s2 = file->i_defs[middle]->s_name;
 
444
            while (*s1++ == *s2++)
 
445
                if (s2[-1] == '\0') break;
 
446
 
 
447
            /* If exact match, we're done */
 
448
            if (*--s1 == *--s2) 
 
449
            {
 
450
                return file->i_defs + middle;
 
451
            }
 
452
 
 
453
            /* If symbol > i_defs[middle] ... */
 
454
            if (*s1 > *s2) 
 
455
            {
 
456
                first = middle + 1;
 
457
            }
 
458
            /* else ... */
 
459
            else
 
460
            {
 
461
                last = middle - 1;
 
462
            }
 
463
        }
 
464
        return(NULL);
 
465
}
 
466
 
 
467
static int 
 
468
merge2defines(struct inclist *file1, struct inclist *file2)
 
469
{
 
470
        int i;
 
471
 
 
472
        if ((file1==NULL) || (file2==NULL) ||
 
473
            !(file2->i_flags & FINISHED))
 
474
                return 0;
 
475
 
 
476
        for (i=0; i < file2->i_listlen; i++)
 
477
                if (file2->i_merged[i]==FALSE)
 
478
                        return 0;
 
479
 
 
480
        {
 
481
                int first1 = 0;
 
482
                int last1 = file1->i_ndefs - 1;
 
483
 
 
484
                int first2 = 0;
 
485
                int last2 = file2->i_ndefs - 1;
 
486
 
 
487
                int first=0;
 
488
                struct symtab** i_defs = NULL;
 
489
                int deflen=file1->i_ndefs+file2->i_ndefs;
 
490
 
 
491
                debug(2,("merging %s into %s\n",
 
492
                        file2->i_file, file1->i_file));
 
493
 
 
494
                if (deflen>0)
 
495
                { 
 
496
                        /* make sure deflen % SYMTABINC == 0 is still true */
 
497
                        deflen += (SYMTABINC - deflen % SYMTABINC) % SYMTABINC;
 
498
                        i_defs=(struct symtab**)
 
499
                            malloc(deflen*sizeof(struct symtab*));
 
500
                        if (i_defs==NULL) return 0;
 
501
                }
 
502
 
 
503
                while ((last1 >= first1) && (last2 >= first2))
 
504
                {
 
505
                        char *s1=file1->i_defs[first1]->s_name;
 
506
                        char *s2=file2->i_defs[first2]->s_name;
 
507
 
 
508
                        if (strcmp(s1,s2) < 0)
 
509
                                i_defs[first++]=file1->i_defs[first1++];
 
510
                        else if (strcmp(s1,s2) > 0)
 
511
                                i_defs[first++]=file2->i_defs[first2++];
 
512
                        else /* equal */
 
513
                        {
 
514
                                i_defs[first++]=file2->i_defs[first2++];
 
515
                                first1++;
 
516
                        }
 
517
                }
 
518
                while (last1 >= first1)
 
519
                {
 
520
                        i_defs[first++]=file1->i_defs[first1++];
 
521
                }
 
522
                while (last2 >= first2)
 
523
                {
 
524
                        i_defs[first++]=file2->i_defs[first2++];
 
525
                }
 
526
 
 
527
                if (file1->i_defs) free(file1->i_defs);
 
528
                file1->i_defs=i_defs;
 
529
                file1->i_ndefs=first;
 
530
                
 
531
                return 1;
 
532
        }
 
533
}
 
534
 
 
535
void
 
536
undefine(char *symbol, struct inclist *file)
 
537
{
 
538
        register struct symtab **ptr;
 
539
        struct inclist *srcfile;
 
540
        while ((ptr = isdefined(symbol, file, &srcfile)) != NULL)
 
541
        {
 
542
            srcfile->i_ndefs--;
 
543
            for (; ptr < srcfile->i_defs + srcfile->i_ndefs; ptr++)
 
544
                *ptr = ptr[1];
 
545
        }
 
546
}
 
547
 
 
548
int
 
549
find_includes(struct filepointer *filep, struct inclist *file, 
 
550
              struct inclist *file_red, int recursion, boolean failOK)
 
551
{
 
552
        struct inclist  *inclistp;
 
553
        char            **includedirsp;
 
554
        register char   *line;
 
555
        register int    type;
 
556
        boolean recfailOK;
 
557
 
 
558
        while ((line = getnextline(filep))) {
 
559
                switch(type = deftype(line, filep, file_red, file, TRUE)) {
 
560
                case IF:
 
561
                doif:
 
562
                        type = find_includes(filep, file,
 
563
                                file_red, recursion+1, failOK);
 
564
                        while ((type == ELIF) || (type == ELIFFALSE) ||
 
565
                               (type == ELIFGUESSFALSE))
 
566
                                type = gobble(filep, file, file_red);
 
567
                        if (type == ELSE)
 
568
                                gobble(filep, file, file_red);
 
569
                        break;
 
570
                case IFFALSE:
 
571
                case IFGUESSFALSE:
 
572
                    doiffalse:
 
573
                        if (type == IFGUESSFALSE || type == ELIFGUESSFALSE)
 
574
                            recfailOK = TRUE;
 
575
                        else
 
576
                            recfailOK = failOK;
 
577
                        type = gobble(filep, file, file_red);
 
578
                        if (type == ELSE)
 
579
                            find_includes(filep, file,
 
580
                                          file_red, recursion+1, recfailOK);
 
581
                        else
 
582
                        if (type == ELIF)
 
583
                            goto doif;
 
584
                        else
 
585
                        if ((type == ELIFFALSE) || (type == ELIFGUESSFALSE))
 
586
                            goto doiffalse;
 
587
                        break;
 
588
                case IFDEF:
 
589
                case IFNDEF:
 
590
                        if ((type == IFDEF && isdefined(line, file_red, NULL))
 
591
                         || (type == IFNDEF && !isdefined(line, file_red, NULL))) {
 
592
                                debug(1,(type == IFNDEF ?
 
593
                                    "line %d: %s !def'd in %s via %s%s\n" : "",
 
594
                                    filep->f_line, line,
 
595
                                    file->i_file, file_red->i_file, ": doit"));
 
596
                                type = find_includes(filep, file,
 
597
                                        file_red, recursion+1, failOK);
 
598
                                while (type == ELIF || type == ELIFFALSE || type == ELIFGUESSFALSE)
 
599
                                        type = gobble(filep, file, file_red);
 
600
                                if (type == ELSE)
 
601
                                        gobble(filep, file, file_red);
 
602
                        }
 
603
                        else {
 
604
                                debug(1,(type == IFDEF ?
 
605
                                    "line %d: %s !def'd in %s via %s%s\n" : "",
 
606
                                    filep->f_line, line,
 
607
                                    file->i_file, file_red->i_file, ": gobble"));
 
608
                                type = gobble(filep, file, file_red);
 
609
                                if (type == ELSE)
 
610
                                        find_includes(filep, file,
 
611
                                                file_red, recursion+1, failOK);
 
612
                                else if (type == ELIF)
 
613
                                        goto doif;
 
614
                                else if (type == ELIFFALSE || type == ELIFGUESSFALSE)
 
615
                                        goto doiffalse;
 
616
                        }
 
617
                        break;
 
618
                case ELSE:
 
619
                case ELIFFALSE:
 
620
                case ELIFGUESSFALSE:
 
621
                case ELIF:
 
622
                        if (!recursion)
 
623
                                gobble(filep, file, file_red);
 
624
                case ENDIF:
 
625
                        if (recursion)
 
626
                                return(type);
 
627
                case DEFINE:
 
628
                        define(line, file);
 
629
                        break;
 
630
                case UNDEF:
 
631
                        if (!*line) {
 
632
                            warning("%s", file_red->i_file);
 
633
                            if (file_red != file)
 
634
                                warning1(" (reading %s)", file->i_file);
 
635
                            warning1(", line %d: incomplete undef == \"%s\"\n",
 
636
                                filep->f_line, line);
 
637
                            break;
 
638
                        }
 
639
                        undefine(line, file_red);
 
640
                        break;
 
641
                case INCLUDE:
 
642
                case INCLUDEDOT:
 
643
                case INCLUDENEXT:
 
644
                case INCLUDENEXTDOT:
 
645
                        inclistp = inclistnext;
 
646
                        includedirsp = includedirsnext;
 
647
                        debug(2,("%s, reading %s, includes %s\n",
 
648
                                file_red->i_file, file->i_file, line));
 
649
                        add_include(filep, file, file_red, line, type, failOK);
 
650
                        inclistnext = inclistp;
 
651
                        includedirsnext = includedirsp;
 
652
                        break;
 
653
                case ERROR:
 
654
                case WARNING:
 
655
                        warning("%s", file_red->i_file);
 
656
                        if (file_red != file)
 
657
                                warning1(" (reading %s)", file->i_file);
 
658
                        warning1(", line %d: %s\n",
 
659
                                 filep->f_line, line);
 
660
                        break;
 
661
                    
 
662
                case PRAGMA:
 
663
                case IDENT:
 
664
                case SCCS:
 
665
                case EJECT:
 
666
                        break;
 
667
                case -1:
 
668
                        warning("%s", file_red->i_file);
 
669
                        if (file_red != file)
 
670
                            warning1(" (reading %s)", file->i_file);
 
671
                        warning1(", line %d: unknown directive == \"%s\"\n",
 
672
                                 filep->f_line, line);
 
673
                        break;
 
674
                case -2:
 
675
                        warning("%s", file_red->i_file);
 
676
                        if (file_red != file)
 
677
                            warning1(" (reading %s)", file->i_file);
 
678
                        warning1(", line %d: incomplete include == \"%s\"\n",
 
679
                                 filep->f_line, line);
 
680
                        break;
 
681
                }
 
682
        }
 
683
        file->i_flags |= FINISHED;
 
684
        debug(2,("finished with %s\n", file->i_file));
 
685
        return(-1);
 
686
}