/*-
 * Copyright (c) 2010 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by David A. Holland.
 *
 * 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. 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 FOUNDATION 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 <stdio.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>

#include "utils.h"
#include "mode.h"
#include "place.h"
#include "output.h"

static int outputfd = -1;
static bool incomment = false;
static char *linebuf;
static size_t linebufpos, linebufmax;
static struct place linebufplace;

static
void
output_open(void)
{
        if (mode.output_file == NULL) {
                outputfd = STDOUT_FILENO;
        } else {
                outputfd = open(mode.output_file, O_WRONLY|O_CREAT|O_TRUNC,
                                0664);
                if (outputfd < 0) {
                        complain(NULL, "%s: %s",
                                 mode.output_file, strerror(errno));
                        die();
                }
        }
}

static
void
dowrite(const char *buf, size_t len)
{
        size_t done;
        ssize_t result;
        static unsigned write_errors = 0;

        if (!mode.do_output) {
                return;
        }

        if (outputfd < 0) {
                output_open();
        }

        done = 0;
        while (done < len) {
                result = write(outputfd, buf+done, len-done);
                if (result == -1) {
                        complain(NULL, "%s: write: %s",
                                 mode.output_file, strerror(errno));
                        complain_failed();
                        write_errors++;
                        if (write_errors > 5) {
                                complain(NULL, "%s: giving up",
                                         mode.output_file);
                                die();
                        }
                        /* XXX is this really a good idea? */
                        sleep(1);
                }
                done += (size_t)result;
        }
}


static
void
filter_output(const char *buf, size_t len)
{
        size_t pos, start;
        bool inesc = false;
        bool inquote = false;
        char quote = '\0';

        start = 0;
        for (pos = 0; pos < len - 1; pos++) {
                if (!inquote && buf[pos] == '/' && buf[pos+1] == '*') {
                        if (!incomment) {
                                if (pos > start) {
                                        dowrite(buf + start, pos - start);
                                }
                                start = pos;
                                pos += 2;
                                incomment = true;
                                /* cancel out the loop's pos++ */
                                pos--;
                                continue;
                        }
                } else if (buf[pos] == '*' && buf[pos+1] == '/') {
                        if (incomment) {
                                pos += 2;
                                if (mode.output_retain_comments) {
                                        dowrite(buf + start, pos - start);
                                }
                                start = pos;
                                incomment = false;
                                /* cancel out the loop's pos++ */
                                pos--;
                                continue;
                        }
                }

                if (incomment) {
                        /* nothing */
                } else if (inesc) {
                        inesc = false;
                } else if (buf[pos] == '\\') {
                        inesc = true;
                } else if (!inquote && (buf[pos] == '"' || buf[pos] == '\'')) {
                        inquote = true;
                        quote = buf[pos];
                } else if (inquote && buf[pos] == quote) {
                        inquote = false;
                }
        }
        pos++;

        if (pos > start) {
                if (!incomment || mode.output_retain_comments) {
                        dowrite(buf + start, pos - start);
                }
        }
}

void
output(const struct place *p, const char *buf, size_t len)
{
        size_t oldmax;

        if (linebufpos + len > linebufmax) {
                oldmax = linebufmax;
                if (linebufmax == 0) {
                        linebufmax = 64;
                }
                while (linebufpos + len > linebufmax) {
                        linebufmax *= 2;
                }
                linebuf = dorealloc(linebuf, oldmax, linebufmax);
        }
        if (linebufpos == 0) {
                if (!place_samefile(&linebufplace, p)) {
                        if (mode.output_cheaplinenumbers) {
                                char str[256];

                                snprintf(str, sizeof(str), "# %u \"%s\"\n",
                                         p->line, place_getname(p));
                                dowrite(str, strlen(str));
                        }
                }
                linebufplace = *p;
        }
        memcpy(linebuf + linebufpos, buf, len);
        linebufpos += len;

        if (len == 1 && buf[0] == '\n') {
                filter_output(linebuf, linebufpos);
                linebufpos = 0;
        }
}

void
output_eof(void)
{
        if (mode.output_file != NULL && outputfd >= 0) {
                close(outputfd);
        }
        outputfd = -1;
}