← Back to branch summary

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

« back to all changes in this revision

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