/*      $NetBSD: input.c,v 1.21 2023/08/26 15:18:27 rillig Exp $        */

/*
 * Copyright (c) 1980, 1993
 *      The Regents of the University of California.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/cdefs.h>
#ifndef lint
#if 0
static char sccsid[] = "@(#)input.c     8.1 (Berkeley) 6/6/93";
#endif
__RCSID("$NetBSD: input.c,v 1.21 2023/08/26 15:18:27 rillig Exp $");
#endif /* not lint */

#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include "error.h"

int cur_wordc;          /* how long the current error message is */
char **cur_wordv;       /* the actual error message */

static Errorclass catchall(void);
static Errorclass cpp(void);
static Errorclass f77(void);
static Errorclass lint0(void);
static Errorclass lint1(void);
static Errorclass lint2(void);
static Errorclass lint3(void);
static Errorclass make(void);
static Errorclass mod2(void);
static Errorclass onelong(void);
static Errorclass pccccom(void);        /* Portable C Compiler C Compiler */
static Errorclass ri(void);
static Errorclass richieccom(void);     /* Richie Compiler for 11 */
static Errorclass gcc45ccom(void);      /* gcc45+ */
static Errorclass troff(void);

/*
 * Eat all of the lines in the input file, attempting to categorize
 * them by their various flavors
 */
void
eaterrors(int *r_errorc, Eptr **r_errorv)
{
        Errorclass errorclass = C_SYNC;
        char *line;
        size_t inbuflen;

    for (;;) {
        line = NULL;
        inbuflen = 0;
        if (getline(&line, &inbuflen, errorfile) == -1)
                break;
        wordvbuild(line, &cur_wordc, &cur_wordv);

        /*
         * for convenience, convert cur_wordv to be 1 based, instead
         * of 0 based.
         */
        cur_wordv -= 1;
        if (cur_wordc > 0 &&
           ((( errorclass = onelong() ) != C_UNKNOWN)
           || (( errorclass = cpp() ) != C_UNKNOWN)
           || (( errorclass = gcc45ccom() ) != C_UNKNOWN)
           || (( errorclass = pccccom() ) != C_UNKNOWN)
           || (( errorclass = richieccom() ) != C_UNKNOWN)
           || (( errorclass = lint0() ) != C_UNKNOWN)
           || (( errorclass = lint1() ) != C_UNKNOWN)
           || (( errorclass = lint2() ) != C_UNKNOWN)
           || (( errorclass = lint3() ) != C_UNKNOWN)
           || (( errorclass = make() ) != C_UNKNOWN)
           || (( errorclass = f77() ) != C_UNKNOWN)
           || ((errorclass = pi() ) != C_UNKNOWN)
           || (( errorclass = ri() )!= C_UNKNOWN)
           || (( errorclass = mod2() )!= C_UNKNOWN)
           || (( errorclass = troff() )!= C_UNKNOWN))
        ) ;
        else
                errorclass = catchall();
        if (cur_wordc > 0)
                erroradd(cur_wordc, cur_wordv+1, errorclass, C_UNKNOWN);
    }
#ifdef FULLDEBUG
    printf("%d errorentrys\n", nerrors);
#endif
    arrayify(r_errorc, r_errorv, er_head);
}

/*
 * create a new error entry, given a zero based array and count
 */
void
erroradd(int errorlength, char **errorv, Errorclass errorclass,
         Errorclass errorsubclass)
{
        Eptr newerror;
        const char *cp;

        if (errorclass == C_TRUE) {
                /* check canonicalization of the second argument*/
                for (cp = errorv[1];
                    *cp != '\0' && isdigit((unsigned char)*cp); cp++)
                        continue;
                errorclass = (*cp == '\0') ? C_TRUE : C_NONSPEC;
#ifdef FULLDEBUG
                if (errorclass != C_TRUE)
                        printf("The 2nd word, \"%s\" is not a number.\n",
                                errorv[1]);
#endif
        }
        if (errorlength > 0) {
                newerror = Calloc(1, sizeof(Edesc));
                newerror->error_language = language; /* language is global */
                newerror->error_text = errorv;
                newerror->error_lgtext = errorlength;
                if (errorclass == C_TRUE)
                        newerror->error_line = atoi(errorv[1]);
                newerror->error_e_class = errorclass;
                newerror->error_s_class = errorsubclass;
                switch (newerror->error_e_class = discardit(newerror)) {
                        case C_SYNC:            nsyncerrors++; break;
                        case C_DISCARD:         ndiscard++; break;
                        case C_NULLED:          nnulled++; break;
                        case C_NONSPEC:         nnonspec++; break;
                        case C_THISFILE:        nthisfile++; break;
                        case C_TRUE:            ntrue++; break;
                        case C_UNKNOWN:         nunknown++; break;
                        case C_IGNORE:          nignore++; break;
                }
                newerror->error_next = er_head;
                er_head = newerror;
                newerror->error_no = nerrors++;
        }       /* length > 0 */
}

static Errorclass
onelong(void)
{
        char **nwordv;

        if (cur_wordc == 1 && language != INLD) {
                /*
                 * We have either:
                 *      a) file name from cc
                 *      b) Assembler telling world that it is complaining
                 *      c) Noise from make ("Stop.")
                 *      c) Random noise
                 */
                cur_wordc = 0;
                if (strcmp(cur_wordv[1], "Stop.") == 0) {
                        language = INMAKE;
                        return C_SYNC;
                }
                if (strcmp(cur_wordv[1], "Assembler:") == 0) {
                        /* assembler always alerts us to what happened*/
                        language = INAS;
                        return C_SYNC;
                } else
                if (strcmp(cur_wordv[1], "Undefined:") == 0) {
                        /* loader complains about unknown symbols*/
                        language = INLD;
                        return C_SYNC;
                }
                if (lastchar(cur_wordv[1]) == ':') {
                        /* cc tells us what file we are in */
                        currentfilename = cur_wordv[1];
                        (void)substitute(currentfilename, ':', '\0');
                        language = INCC;
                        return C_SYNC;
                }
        } else
        if (cur_wordc == 1 && language == INLD) {
                nwordv = Calloc(4, sizeof(char *));
                nwordv[0] = Strdup("ld:");      /* XXX leaked */
                nwordv[1] = cur_wordv[1];
                nwordv[2] = Strdup("is");       /* XXX leaked */
                nwordv[3] = Strdup("undefined.");/* XXX leaked */
                cur_wordc = 4;
                cur_wordv = nwordv - 1;
                return C_NONSPEC;
        } else
        if (cur_wordc == 1) {
                return C_SYNC;
        }
        return C_UNKNOWN;
}       /* end of one long */

static Errorclass
cpp(void)
{
        /*
         * Now attempt a cpp error message match
         * Examples:
         *      ./morse.h: 23: undefined control
         *      morsesend.c: 229: MAGNIBBL: argument mismatch
         *      morsesend.c: 237: MAGNIBBL: argument mismatch
         *      test1.c: 6: undefined control
         */
        if (cur_wordc < 3)
                return C_UNKNOWN;
        if (language != INLD            /* loader errors have almost same fmt */
            && lastchar(cur_wordv[1]) == ':'
            && isdigit((unsigned char)firstchar(cur_wordv[2]))
            && lastchar(cur_wordv[2]) == ':') {
                language = INCPP;
                clob_last(cur_wordv[1], '\0');
                clob_last(cur_wordv[2], '\0');
                return C_TRUE;
        }
        return C_UNKNOWN;
}       /*end of cpp*/

static Errorclass
pccccom(void)
{
        /*
         * Now attempt a ccom error message match:
         * Examples:
         *      "morsesend.c", line 237: operands of & have incompatible types
         *      "test.c", line 7: warning: old-fashioned initialization: use =
         *      "subdir.d/foo2.h", line 1: illegal initialization
         */
        if (cur_wordc < 4)
                return C_UNKNOWN;
        if (firstchar(cur_wordv[1]) == '"'
            && lastchar(cur_wordv[1]) == ','
            && next_lastchar(cur_wordv[1]) == '"'
            && strcmp(cur_wordv[2], "line") == 0
            && isdigit((unsigned char)firstchar(cur_wordv[3]))
            && lastchar(cur_wordv[3]) == ':') {
                clob_last(cur_wordv[1], '\0');  /* drop last , */
                clob_last(cur_wordv[1], '\0');  /* drop last " */
                cur_wordv[1]++;                 /* drop first " */
                clob_last(cur_wordv[3], '\0');  /* drop : on line number */
                cur_wordv[2] = cur_wordv[1];    /* overwrite "line" */
                cur_wordv++;            /*compensate*/
                cur_wordc--;
                currentfilename = cur_wordv[1];
                language = INCC;
                return C_TRUE;
        }
        return C_UNKNOWN;
}       /* end of ccom */

/*
 * Do the error message from gcc 4.5+ which prints:
 *
 *      fprintf(stderr, "%s:%d:%d: ", filename, line, column);
 */

static Errorclass
gcc45ccom(void)
{
        char *cp, *ccp;
        char **nwordv;
        char *file;

        if (cur_wordc < 2)
                return C_UNKNOWN;

        if (lastchar(cur_wordv[1]) != ':')
                return C_UNKNOWN;

        cp = cur_wordv[1] + strlen(cur_wordv[1]) - 1;
        while (isdigit((unsigned char)*--cp))
                continue;
        if (*cp != ':')
                return C_UNKNOWN;

        ccp = cp;
        while (isdigit((unsigned char)*--cp))
                continue;
        if (*cp != ':')
                return C_UNKNOWN;

        clob_last(cur_wordv[1], '\0');  /* last : */
        *ccp = '\0';                    /* middle : */
        *cp = '\0';                     /* first : */
        file = cur_wordv[1];
#ifdef notyet
#define EHEAD 2
#else
#define EHEAD 1 /* Nothing to do with column info yet */
#endif
        nwordv = wordvsplice(EHEAD, cur_wordc, cur_wordv + 1);
        nwordv[0] = file;
        nwordv[1] = cp + 1;
#ifdef notyet
        nwordv[2] = ccp + 1;
#endif
        cur_wordc += 1;
        cur_wordv = nwordv - 1;
        language = INCC;
        currentfilename = cur_wordv[1];
        return C_TRUE;
}

/*
 * Do the error message from the Richie C Compiler for the PDP11,
 * which has this source:
 *
 *      if (filename[0])
 *              fprintf(stderr, "%s:", filename);
 *      fprintf(stderr, "%d: ", line);
 *
 */

static Errorclass
richieccom(void)
{
        char *cp;
        char **nwordv;
        char *file;

        if (cur_wordc < 2)
                return C_UNKNOWN;

        if (lastchar(cur_wordv[1]) == ':') {
                cp = cur_wordv[1] + strlen(cur_wordv[1]) - 1;
                while (isdigit((unsigned char)*--cp))
                        continue;
                if (*cp == ':') {
                        clob_last(cur_wordv[1], '\0');  /* last : */
                        *cp = '\0';                     /* first : */
                        file = cur_wordv[1];
                        nwordv = wordvsplice(1, cur_wordc, cur_wordv+1);
                        nwordv[0] = file;
                        nwordv[1] = cp + 1;
                        cur_wordc += 1;
                        cur_wordv = nwordv - 1;
                        language = INCC;
                        currentfilename = cur_wordv[1];
                        return C_TRUE;
                }
        }
        return C_UNKNOWN;
}

static Errorclass
lint0(void)
{
        char **nwordv;
        char *line, *file;

        /*
         * Attempt a match for the new lint style normal compiler
         * error messages, of the form
         *
         *      printf("%s(%d): %s\n", filename, linenumber, message);
         */
        if (cur_wordc < 2)
                return C_UNKNOWN;

        if (lastchar(cur_wordv[1]) == ':'
            && next_lastchar(cur_wordv[1]) == ')') {
                clob_last(cur_wordv[1], '\0'); /* colon */
                if (persperdexplode(cur_wordv[1], &line, &file)) {
                        nwordv = wordvsplice(1, cur_wordc, cur_wordv+1);
                        nwordv[0] = file;       /* file name */
                        nwordv[1] = line;       /* line number */
                        cur_wordc += 1;
                        cur_wordv = nwordv - 1;
                        language = INLINT;
                        return C_TRUE;
                }
                cur_wordv[1][strlen(cur_wordv[1])] = ':';
        }
        return C_UNKNOWN;
}

static Errorclass
lint1(void)
{
        char *line1 = NULL, *line2 = NULL;
        char *file1 = NULL, *file2 = NULL;
        char **nwordv1, **nwordv2;

        /*
         * Now, attempt a match for the various errors that lint
         * can complain about.
         *
         * Look first for type 1 lint errors
         */
        if (cur_wordc > 1 && strcmp(cur_wordv[cur_wordc-1], "::") == 0) {
         /*
          * %.7s, arg. %d used inconsistently %s(%d) :: %s(%d)
          * %.7s value used inconsistently %s(%d) :: %s(%d)
          * %.7s multiply declared %s(%d) :: %s(%d)
          * %.7s value declared inconsistently %s(%d) :: %s(%d)
          * %.7s function value type must be declared before use %s(%d) :: %s(%d)
          */
                language = INLINT;
                if (cur_wordc > 2
                    && persperdexplode(cur_wordv[cur_wordc], &line2, &file2)
                    && persperdexplode(cur_wordv[cur_wordc-2], &line1, &file1)) {
                        nwordv1 = wordvsplice(2, cur_wordc, cur_wordv+1);
                        nwordv2 = wordvsplice(2, cur_wordc, cur_wordv+1);
                        nwordv1[0] = file1;
                        nwordv1[1] = line1;
                        erroradd(cur_wordc+2, nwordv1, C_TRUE, C_DUPL); /* takes 0 based*/
                        nwordv2[0] = file2;
                        nwordv2[1] = line2;
                        cur_wordc = cur_wordc + 2;
                        cur_wordv = nwordv2 - 1;        /* 1 based */
                        return C_TRUE;
                }
        }
        free(file2);
        free(file1);
        free(line2);
        free(line1);
        return C_UNKNOWN;
} /* end of lint 1*/

static Errorclass
lint2(void)
{
        char *file;
        char *line;
        char **nwordv;

        /*
         * Look for type 2 lint errors
         *
         *      %.7s used( %s(%d) ), but not defined
         *      %.7s defined( %s(%d) ), but never used
         *      %.7s declared( %s(%d) ), but never used or defined
         *
         *      bufp defined( "./metric.h"(10) ), but never used
         */
        if (cur_wordc < 5)
                return C_UNKNOWN;

        if (lastchar(cur_wordv[2]) == '(' /* ')' */
            && strcmp(cur_wordv[4], "),") == 0) {
                language = INLINT;
                if (persperdexplode(cur_wordv[3], &line, &file)) {
                        nwordv = wordvsplice(2, cur_wordc, cur_wordv+1);
                        nwordv[0] = file;
                        nwordv[1] = line;
                        cur_wordc = cur_wordc + 2;
                        cur_wordv = nwordv - 1; /* 1 based */
                        return C_TRUE;
                }
        }
        return C_UNKNOWN;
} /* end of lint 2*/

#if 0 /* not const-correct */
static char *Lint31[4] = {"returns", "value", "which", "is"};
static char *Lint32[6] = {"value", "is", "used,", "but", "none", "returned"};
#else
DECL_STRINGS_4(static, Lint31,
               "returns", "value", "which", "is");
DECL_STRINGS_6(static, Lint32,
               "value", "is", "used,", "but", "none", "returned");
#endif

static Errorclass
lint3(void)
{
        if (cur_wordc < 3)
                return C_UNKNOWN;
        if (wordv_eq(cur_wordv+2, 4, Lint31)
            || wordv_eq(cur_wordv+2, 6, Lint32)) {
                language = INLINT;
                return C_NONSPEC;
        }
        return C_UNKNOWN;
}

/*
 * Special word vectors for use by F77 recognition
 */
#if 0 /* not const-correct */
static char *F77_fatal[3] = {"Compiler", "error", "line"};
static char *F77_error[3] = {"Error", "on", "line"};
static char *F77_warning[3] = {"Warning", "on", "line"};
static char *F77_no_ass[3] = {"Error.","No","assembly."};
#else
DECL_STRINGS_3(static, F77_fatal, "Compiler", "error", "line");
DECL_STRINGS_3(static, F77_error, "Error", "on", "line");
DECL_STRINGS_3(static, F77_warning, "Warning", "on", "line");
DECL_STRINGS_3(static, F77_no_ass, "Error.", "No", "assembly.");
#endif

static Errorclass
f77(void)
{
        char **nwordv;

        /*
         * look for f77 errors:
         * Error messages from /usr/src/cmd/f77/error.c, with
         * these printf formats:
         *
         *      Compiler error line %d of %s: %s
         *      Error on line %d of %s: %s
         *      Warning on line %d of %s: %s
         *      Error.  No assembly.
         */
        if (cur_wordc == 3 && wordv_eq(cur_wordv+1, 3, F77_no_ass)) {
                cur_wordc = 0;
                return C_SYNC;
        }
        if (cur_wordc < 6)
                return C_UNKNOWN;
        if (lastchar(cur_wordv[6]) == ':'
            && (
                wordv_eq(cur_wordv+1, 3, F77_fatal)
                || wordv_eq(cur_wordv+1, 3, F77_error)
                || wordv_eq(cur_wordv+1, 3, F77_warning)
               )
        ) {
                language = INF77;
                nwordv = wordvsplice(2, cur_wordc, cur_wordv+1);
                nwordv[0] = cur_wordv[6];
                clob_last(nwordv[0],'\0');
                nwordv[1] = cur_wordv[4];
                cur_wordc += 2;
                cur_wordv = nwordv - 1; /* 1 based */
                return C_TRUE;
        }
        return C_UNKNOWN;
} /* end of f77 */

#if 0 /* not const-correct */
static char *Make_Croak[3] = {"***", "Error", "code"};
static char *Make_NotRemade[5] = {"not", "remade", "because", "of", "errors"};
#else
DECL_STRINGS_3(static, Make_Croak, "***", "Error", "code");
DECL_STRINGS_5(static, Make_NotRemade,
               "not", "remade", "because", "of", "errors");
#endif

static Errorclass
make(void)
{
        if (wordv_eq(cur_wordv+1, 3, Make_Croak)) {
                language = INMAKE;
                return C_SYNC;
        }
        if (wordv_eq(cur_wordv+2, 5, Make_NotRemade)) {
                language = INMAKE;
                return C_SYNC;
        }
        return C_UNKNOWN;
}

static Errorclass
ri(void)
{
/*
 * Match an error message produced by ri; here is the
 * procedure yanked from the distributed version of ri
 * April 24, 1980.
 *
 *      serror(str, x1, x2, x3)
 *              char str[];
 *              char *x1, *x2, *x3;
 *      {
 *              extern int yylineno;
 *
 *              putc('"', stdout);
 *              fputs(srcfile, stdout);
 *              putc('"', stdout);
 *              fprintf(stdout, " %d: ", yylineno);
 *              fprintf(stdout, str, x1, x2, x3);
 *              fprintf(stdout, "\n");
 *              synerrs++;
 *      }
 */
        if (cur_wordc < 3)
                return C_UNKNOWN;
        if (firstchar(cur_wordv[1]) == '"'
            && lastchar(cur_wordv[1]) == '"'
            && lastchar(cur_wordv[2]) == ':'
            && isdigit((unsigned char)firstchar(cur_wordv[2]))) {
                clob_last(cur_wordv[1], '\0');  /* drop the last " */
                cur_wordv[1]++;                 /* skip over the first " */
                clob_last(cur_wordv[2], '\0');
                language = INRI;
                return C_TRUE;
        }
        return C_UNKNOWN;
}

static Errorclass
catchall(void)
{
        /*
         * Catches random things.
         */
        language = INUNKNOWN;
        return C_NONSPEC;
} /* end of catch all*/

static Errorclass
troff(void)
{
        /*
         * troff source error message, from eqn, bib, tbl...
         * Just like pcc ccom, except uses `'
         */
        if (cur_wordc < 4)
                return C_UNKNOWN;

        if (firstchar(cur_wordv[1]) == '`'
            && lastchar(cur_wordv[1]) == ','
            && next_lastchar(cur_wordv[1]) == '\''
            && strcmp(cur_wordv[2], "line") == 0
            && isdigit((unsigned char)firstchar(cur_wordv[3]))
            && lastchar(cur_wordv[3]) == ':') {
                clob_last(cur_wordv[1], '\0');  /* drop last , */
                clob_last(cur_wordv[1], '\0');  /* drop last " */
                cur_wordv[1]++;                 /* drop first " */
                clob_last(cur_wordv[3], '\0');  /* drop : on line number */
                cur_wordv[2] = cur_wordv[1];    /* overwrite "line" */
                cur_wordv++;                    /*compensate*/
                currentfilename = cur_wordv[1];
                language = INTROFF;
                return C_TRUE;
        }
        return C_UNKNOWN;
}

static Errorclass
mod2(void)
{
        /*
         * for decwrl modula2 compiler (powell)
         */
        if (cur_wordc < 5)
                return C_UNKNOWN;
        if ((strcmp(cur_wordv[1], "!!!") == 0           /* early version */
             || strcmp(cur_wordv[1], "File") == 0)      /* later version */
            && lastchar(cur_wordv[2]) == ','            /* file name */
            && strcmp(cur_wordv[3], "line") == 0
            && isdigit((unsigned char)firstchar(cur_wordv[4]))  /* line number */
            && lastchar(cur_wordv[4]) == ':'    /* line number */
        ) {
                clob_last(cur_wordv[2], '\0');  /* drop last , on file name */
                clob_last(cur_wordv[4], '\0');  /* drop last : on line number */
                cur_wordv[3] = cur_wordv[2];    /* file name on top of "line" */
                cur_wordv += 2;
                cur_wordc -= 2;
                currentfilename = cur_wordv[1];
                language = INMOD2;
                return C_TRUE;
        }
        return C_UNKNOWN;
}