lib/space.cc

Go to the documentation of this file.

//
// nis-util - NIS Administration Utilities
// Copyright (C) 2001, 2008, 2009, 2011, 2012 Peter Miller
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or (at
// your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//

#include <lib/ac/assert.h>
#include <lib/ac/ctype.h>
#include <lib/ac/stdarg.h>
#include <libexplain/fclose.h>
#include <libexplain/fopen.h>
#include <libexplain/getc.h>
#include <libexplain/output.h>
#include <libexplain/realloc.h>
#include <libexplain/strdup.h>

#include <lib/configuration.h>
#include <lib/input/file.h>
#include <lib/input/remove_hash_comments.h>
#include <lib/space.h>
#include <lib/rcstring/accumulator.h>


space::~space()
{
    close();
}


space::space(const rcstring &a_filename):
    filename(a_filename),
    non_printing_whine(false),
    token(token_eof),
    error_count(0),
    discard_comments_flag(false),
    discard_blank_lines_flag(false),
    current_line_is_blank(true),
    explained_sequence_errors(false)
{
}


void
space::open(void)
{
    if (ip)
        return;
    ip = input_file::create(filename);
    if (discard_comments_flag)
        ip = input_remove_hash_comments::create(ip);
    error_count = 0;
    non_printing_whine = false;
    current_line_is_blank = true;
}


void
space::close(void)
{
    if (error_count)
    {
        explain_output_error_and_die
        (
            "%s: found %d fatal error%s",
            filename.c_str(),
            error_count,
            (error_count == 1 ? "" : "s")
        );
    }
    ip.reset();
    error_count = 0;
    non_printing_whine = false;
    current_line_is_blank = true;
}


int
space::getch(void)
{
    open();
    for (;;)
    {
        int c = ip->get();
        if (c != '\\')
            return c;
        if (!discard_backslash_newline_flag)
            return c;
        c = ip->get();
        if (c == '\n')
            continue;
        ip->unget(c);
        return '\\';
    }
}


void
space::lex(void)
{
    open();
    static rcstring_accumulator buffer;
    buffer.clear();
    for (;;)
    {
        locn = ip->get_source_location();
        int c = getch();
        switch (c)
        {
        case input::eof:
            if (!current_line_is_blank)
                error(locn, "last line needs newline");
            token_value = rcstring();
            token = token_eof;
            return;

        case '\n':
            if (current_line_is_blank && discard_blank_lines_flag)
                continue;
            token_value = "\n";
            token = token_eoln;

            // setup for next line
            non_printing_whine = false;
            current_line_is_blank = true;
            return;

        case ' ':
        case '\t':
        case '\r':
        case '\f':
        case '\v':
            continue;

        default:
            current_line_is_blank = false;
            for (;;)
            {
                if
                (
#ifdef AMERICAN_ASCII_ONLY
                    !isprint(c) && !isspace(c)
#else
                    !c
#endif
                &&
                    !non_printing_whine
                )
                {
                    error(locn, "line contains non printing character");
                    non_printing_whine = true;
                }
                buffer.push_back((char)c);

                c = getch();
                if (c == input::eof)
                    break;
                if (isspace((unsigned char)c))
                {
                    ip->unget(c);
                    break;
                }
            }
            token_value = buffer.mkstr();
            token = token_string;
            return;
        }
    }
}


void
space::verror(const source_location &elocn, const char *fmt, va_list ap)
{
    rcstring msg = rcstring::vformat(fmt, ap);

    explain_output_error("%s: %s", elocn.get_both().c_str(), msg.c_str());

    if (!msg.ends_with("..."))
    {
        ++error_count;
        if (error_count >= 50)
        {
            explain_output_error_and_die
            (
                "%s: too many fatal errors, aborting",
                filename.c_str()
            );
        }
        if (!ip)
            exit(EXIT_FAILURE);
    }
}


void
space::error(const source_location &elocn, const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    verror(elocn, fmt, ap);
    va_end(ap);
}


void
space::warning(const source_location &locat, const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    vwarning(locat, fmt, ap);
    va_end(ap);
}


void
space::vwarning(const source_location &locat, const char *fmt, va_list ap)
{
    // We have to use up all the args, even if we don't print the message.
    rcstring msg = rcstring::vformat(fmt, ap);

    if (cfg.get_bool(SECTION_GLOBAL, ITEM_WARNING))
    {
        explain_output_error
        (
            "%s: warning: %s",
            locat.get_both().c_str(),
            msg.c_str()
        );
    }
}


bool
space::read_one_line(line_t &line)
{
    source_location dummy;
    return read_one_line(dummy, line);
}


bool
space::read_one_line(source_location &result_location, line_t &result)
{
    //
    // open the file if it isn't open already
    //
    open();

    //
    // Make sure the output is empty.
    //
    result.clear();

    //
    // Keep chewing tokens until we've read a whole line.
    //
    token = token_eoln;
    bool first = true;
    for (;;)
    {
        lex();
        switch (token)
        {
        case token_eof:
            return !result.empty();

        case token_eoln:
            if (first)
                result_location = get_location();
            return true;

        case token_string:
            if (first)
            {
                result_location = get_location();
                first = false;
            }
            result.push_back(token_value);
            break;

        default:
            error(locn, "malformed line");
            result = line_t();
            for (;;)
            {
                lex();
                if (token == token_eof)
                    break;
                if (token == token_eoln)
                    break;
            }
            first = true;
            break;
        }
    }
}


void
space::discard_blank_lines(void)
{
    discard_blank_lines_flag = true;
}


void
space::discard_comments(void)
{
    discard_comments_flag = true;
}


void
space::discard_backslash_newline(void)
{
    discard_backslash_newline_flag = true;
}


void
space::explain_sequence_errors(void)
{
    if (explained_sequence_errors)
        return;
    explained_sequence_errors = true;
    explain_output_error
    (
        "by keeping the file sorted, common typographical errors show "
        "up as ordering errors"
    );
}


// vim: set ts=8 sw=4 et :