/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*      Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T     */
/*        All Rights Reserved   */

/* Copyright (c) 1982 Regents of the University of California */

/*
 *    unifdef - remove ifdef'ed lines
 */

#include <stdio.h>
#include <ctype.h>
#include <locale.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>

FILE *input;
#ifndef YES
#define YES 1
#define NO  0
#endif

char *progname;
char *filename;
char text;              /* -t option in effect: this is a text file */
char lnblank;           /* -l option in effect: blank deleted lines */
char complement;        /* -c option in effect: complement the operation */
#define MAXSYMS 100
char true[MAXSYMS];
char ignore[MAXSYMS];
char *sym[MAXSYMS];
signed char insym[MAXSYMS];
#define KWSIZE 8
char buf[KWSIZE];
char nsyms;
char incomment;
#define QUOTE1 0
#define QUOTE2 1
char inquote[2];
int exitstat;

static char *skipcomment(char *cp);
static char *skipquote(char *cp, int type);
static char *nextsym(char *p);
static int doif(int thissym, int inif, int prevreject, int depth);
static void pfile(void);
static int getlin(char *line, int maxline, FILE *inp, int expandtabs);
static void prname(void);
static void flushline(int keep);
static int checkline(int *cursym);
static int error(int err, int line, int depth);
static void putlin(char *line, FILE *fio);

static void
usage(void)
{
        (void) fprintf(stderr, gettext(
            "Usage: %s [-l] [-t] [-c] [[-Dsym] [-Usym] [-idsym] "
            "[-iusym]]... [file]\n"
            "    At least one arg from [-D -U -id -iu] is required\n"),
            progname);
        exit(2);
}

int
main(int argc, char **argv)
{
        char **curarg;
        char *cp;
        char *cp1;
        char ignorethis;

        (void) setlocale(LC_ALL, "");

#if !defined(TEXT_DOMAIN)
#define TEXT_DOMAIN "SYS_TEST"
#endif
        (void) textdomain(TEXT_DOMAIN);

        progname = argv[0][0] ? argv[0] : "unifdef";

        for (curarg = &argv[1]; --argc > 0; curarg++) {
                if (*(cp1 = cp = *curarg) != '-')
                        break;
                if (*++cp1 == 'i') {
                        ignorethis = YES;
                        cp1++;
                } else
                        ignorethis = NO;
                if ((*cp1 == 'D' || *cp1 == 'U') &&
                    cp1[1] != '\0') {
                        if (nsyms >= MAXSYMS) {
                                prname();
                                (void) fprintf(stderr,
                                    gettext("too many symbols.\n"));
                                exit(2);
                        }
                        ignore[nsyms] = ignorethis;
                        true[nsyms] = *cp1 == 'D' ? YES : NO;
                        sym[nsyms++] = &cp1[1];
                } else if (ignorethis)
                        goto unrec;
                else if (strcmp(&cp[1], "t") == 0)
                        text = YES;
                else if (strcmp(&cp[1], "l") == 0)
                        lnblank = YES;
                else if (strcmp(&cp[1], "c") == 0)
                        complement = YES;
                else {
unrec:
                        prname();
                        (void) fprintf(stderr,
                            gettext("unrecognized option: %s\n"), cp);
                        usage();
                }
        }
        if (nsyms == 0) {
                usage();
        }

        if (argc > 1) {
                prname();
                (void) fprintf(stderr, gettext("can only do one file.\n"));
        } else if (argc == 1) {
                filename = *curarg;
                if ((input = fopen(filename, "r")) != NULL) {
                        pfile();
                        (void) fclose(input);
                } else {
                        prname();
                        perror(*curarg);
                }
        } else {
                filename = "[stdin]";
                input = stdin;
                pfile();
        }

        (void) fflush(stdout);
        return (exitstat);
}

/* types of input lines: */
#define PLAIN   0   /* ordinary line */
#define TRUE    1   /* a true  #ifdef of a symbol known to us */
#define FALSE   2   /* a false #ifdef of a symbol known to us */
#define OTHER   3   /* an #ifdef of a symbol not known to us */
#define ELSE    4   /* #else */
#define ENDIF   5   /* #endif */
#define LEOF    6   /* end of file */

/* should be int declaration, was char */
int reject;    /* 0 or 1: pass thru; 1 or 2: ignore comments */
int linenum;    /* current line number */
int stqcline;   /* start of current comment or quote */

char *errs[] = {
#define NO_ERR          0
                        "",
#define END_ERR         1
                        "",
#define ELSE_ERR        2
                        "Inappropriate else",
#define ENDIF_ERR       3
                        "Inappropriate endif",
#define IEOF_ERR        4
                        "Premature EOF in ifdef",
#define CEOF_ERR        5
                        "Premature EOF in comment",
#define Q1EOF_ERR       6
                        "Premature EOF in quoted character",
#define Q2EOF_ERR       7
                        "Premature EOF in quoted string"
};

static void
pfile(void)
{
        reject = 0;
        (void) doif(-1, NO, reject, 0);
}

static int
doif(
    int thissym,        /* index of the symbol who was last ifdef'ed */
    int inif,           /* YES or NO we are inside an ifdef */
    int prevreject,     /* previous value of reject */
    int depth           /* depth of ifdef's */
)
{
        int lineval;
        int thisreject;
        int doret;      /* tmp return value of doif */
        int cursym;     /* index of the symbol returned by checkline */
        int stline;     /* line number when called this time */
        int err;

        stline = linenum;
        for (;;) {
                switch (lineval = checkline(&cursym)) {
                case PLAIN:
                        flushline(YES);
                        break;

                case TRUE:
                case FALSE:
                        thisreject = reject;
                        if (lineval == TRUE)
                                insym[cursym] = 1;
                        else {
                                if (reject < 2)
                                        reject = ignore[cursym] ? 1 : 2;
                                insym[cursym] = -1;
                        }
                        if (ignore[cursym])
                                flushline(YES);
                        else {
                                exitstat = 0;
                                flushline(NO);
                        }
                        if ((doret = doif(cursym, YES,
                            thisreject, depth + 1)) != NO_ERR)
                                return (error(doret, stline, depth));
                        break;

                case OTHER:
                        flushline(YES);
                        if ((doret = doif(-1, YES,
                            reject, depth + 1)) != NO_ERR)
                                return (error(doret, stline, depth));
                        break;

                case ELSE:
                        if (inif != 1)
                                return (error(ELSE_ERR, linenum, depth));
                        inif = 2;
                        if (thissym >= 0) {
                                if ((insym[thissym] = -insym[thissym]) < 0)
                                        reject = ignore[thissym] ? 1 : 2;
                                else
                                        reject = prevreject;
                                if (!ignore[thissym]) {
                                        flushline(NO);
                                        break;
                                }
                        }
                        flushline(YES);
                        break;

                case ENDIF:
                        if (inif == 0)
                                return (error(ENDIF_ERR, linenum, depth));
                        if (thissym >= 0) {
                                insym[thissym] = 0;
                                reject = prevreject;
                                if (!ignore[thissym]) {
                                        flushline(NO);
                                        return (NO_ERR);
                                }
                        }
                        flushline(YES);
                        return (NO_ERR);

                case LEOF:
                        err = incomment
                            ? CEOF_ERR
                            : inquote[QUOTE1]
                            ? Q1EOF_ERR
                            : inquote[QUOTE2]
                            ? Q2EOF_ERR
                            : NO_ERR;
                        if (inif) {
                                if (err != NO_ERR)
                                        (void) error(err, stqcline, depth);
                                return (error(IEOF_ERR, stline, depth));
                        } else if (err != NO_ERR)
                                return (error(err, stqcline, depth));
                        else
                                return (NO_ERR);
                }
        }
}

#define endsym(c) (!isalpha(c) && !isdigit(c) && c != '_')

#define MAXLINE 256
char tline[MAXLINE];

static int
checkline(int *cursym)
{
        char *cp;
        char *symp;
        char chr;
        char *scp;
        int retval;
        int symind;
        char keyword[KWSIZE];

        linenum++;
        if (getlin(tline, sizeof (tline), input, NO) == EOF)
                return (LEOF);

        retval = PLAIN;
        if (*(cp = tline) != '#' || incomment ||
            inquote[QUOTE1] || inquote[QUOTE2])
                goto eol;

        cp = skipcomment(++cp);
        symp = keyword;
        while (!endsym (*cp)) {
                *symp = *cp++;
                if (++symp >= &keyword[KWSIZE])
                        goto eol;
        }
        *symp = '\0';

        if (strcmp(keyword, "ifdef") == 0) {
                retval = YES;
                goto ifdef;
        } else if (strcmp(keyword, "if") == 0) {
                cp = skipcomment(++cp);
                if (strcmp(nextsym(cp), "defined") == 0) {
                        cp += strlen("defined") + 1;
                        /* skip to identifier */
                        while (endsym(*cp))
                                ++cp;
                        retval = YES;
                        goto ifdef;
                } else {
                        retval = OTHER;
                        goto eol;
                }
        } else if (strcmp(keyword, "ifndef") == 0) {
                retval = NO;
ifdef:
                scp = cp = skipcomment(cp);
                if (incomment) {
                        retval = PLAIN;
                        goto eol;
                }
                symind = 0;
                for (;;) {
                        if (insym[symind] == 0) {
                                for (symp = sym[symind], cp = scp;
                                *symp && *cp == *symp; cp++, symp++) {
                                        /* NULL */
                                }
                                chr = *cp;
                                if (*symp == '\0' && endsym(chr)) {
                                        *cursym = symind;
                                        retval = (retval ^ true[symind]) ?
                                            FALSE : TRUE;
                                        break;
                                }
                        }
                        if (++symind >= nsyms) {
                                retval = OTHER;
                                break;
                        }
                }
        } else if (strcmp(keyword, "else") == 0)
                retval = ELSE;
        else if (strcmp(keyword, "endif") == 0)
                retval = ENDIF;

eol:
        if (!text && !reject)
                while (*cp) {
                        if (incomment)
                                cp = skipcomment(cp);
                        else if (inquote[QUOTE1])
                                cp = skipquote(cp, QUOTE1);
                        else if (inquote[QUOTE2])
                                cp = skipquote(cp, QUOTE2);
                        else if (*cp == '/' && cp[1] == '*')
                                cp = skipcomment(cp);
                        else if (*cp == '\'')
                                cp = skipquote(cp, QUOTE1);
                        else if (*cp == '"')
                                cp = skipquote(cp, QUOTE2);
                        else
                                cp++;
                }
        return (retval);
}

/*
 * Skip over comments and stop at the next character
 *  position that is not whitespace.
 */
static char *
skipcomment(char *cp)
{
        if (incomment)
                goto inside;
        for (;;) {
                while (*cp == ' ' || *cp == '\t')
                        cp++;
                if (text)
                        return (cp);
                if (cp[0] != '/' || cp[1] != '*')
                        return (cp);
                cp += 2;
                if (!incomment) {
                        incomment = YES;
                        stqcline = linenum;
                }
inside:
                for (;;) {
                        for (; *cp != '*'; cp++)
                                if (*cp == '\0')
                                        return (cp);
                        if (*++cp == '/')
                                break;
                }
                incomment = NO;
                cp++;
        }
}

/*
 * Skip over a quoted string or character and stop at the next charaacter
 *  position that is not whitespace.
 */
static char *
skipquote(char *cp, int type)
{
        char qchar;

        qchar = type == QUOTE1 ? '\'' : '"';

        if (inquote[type])
                goto inside;
        for (;;) {
                if (*cp != qchar)
                        return (cp);
                cp++;
                if (!inquote[type]) {
                        inquote[type] = YES;
                        stqcline = linenum;
                }
inside:
                for (; ; cp++) {
                        if (*cp == qchar)
                                break;
                        if (*cp == '\0' || *cp == '\\' && *++cp == '\0')
                                return (cp);
                }
                inquote[type] = NO;
                cp++;
        }
}

/*
 *   special getlin - treats form-feed as an end-of-line
 *                    and expands tabs if asked for
 */
static int
getlin(char *line, int maxline, FILE *inp, int expandtabs)
{
        int tmp;
        int num;
        int chr;
#ifdef FFSPECIAL
        static char havechar = NO;  /* have leftover char from last time */
        static char svchar;
#endif

        num = 0;
#ifdef FFSPECIAL
        if (havechar) {
                havechar = NO;
                chr = svchar;
                goto ent;
        }
#endif
        while (num + 8 < maxline) {   /* leave room for tab */
                chr = getc(inp);
                if (isprint(chr)) {
#ifdef FFSPECIAL
ent:
#endif
                        *line++ = chr;
                        num++;
                } else
                        switch (chr) {
                        case EOF:
                                return (EOF);

                        case '\t':
                                if (expandtabs) {
                                        num += tmp = 8 - (num & 7);
                                        do
                                                *line++ = ' ';
                                        while (--tmp);
                                        break;
                                }
                                /* FALLTHROUGH */
                        default:
                                *line++ = chr;
                                num++;
                                break;

                        case '\n':
                                *line = '\n';
                                num++;
                                goto end;

#ifdef FFSPECIAL
                        case '\f':
                                if (++num == 1)
                                        *line = '\f';
                                else {
                                        *line = '\n';
                                        havechar = YES;
                                        svchar = chr;
                                }
                                goto end;
#endif
                        }
        }
end:
        *++line = '\0';
        return (num);
}

static void
flushline(int keep)
{
        if ((keep && reject < 2) ^ complement)
                putlin(tline, stdout);
        else if (lnblank)
                putlin("\n", stdout);
}

/*
 *  putlin - for tools
 */
static void
putlin(char *line, FILE *fio)
{
        char chr;

        while (chr = *line++)
                (void) putc(chr, fio);
}

static void
prname(void)
{
        (void) fprintf(stderr, "%s: ", progname);
}


static int
error(int err, int line, int depth)
{
        if (err == END_ERR)
                return (err);

        prname();

#ifndef TESTING
        (void) fprintf(stderr, gettext("Error in %s line %d: %s.\n"),
            filename, line, gettext(errs[err]));
#endif

#ifdef TESTING
        (void) fprintf(stderr, gettext("Error in %s line %d: %s. "),
            filename, line, errs[err]);
        (void) fprintf(stderr, gettext("ifdef depth: %d\n"), depth);
#endif

        exitstat = 1;
        return (depth > 1 ? IEOF_ERR : END_ERR);
}

/* return the next token in the line buffer */
char *
nextsym(char *p)
{
        char *key;
        int i = KWSIZE;

        key = buf;
        while (!endsym(*p) && --i)
                *key++ = *p++;
        *key = '\0';

        return (buf);
}