lib/colon.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/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 <lib/colon.h>
#include <lib/configuration.h>
#include <lib/input/file.h>
#include <lib/input/remove_hash_comments.h>
#include <lib/rcstring/accumulator.h>


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


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


void
colon::open(void)
{
    if (ip)
        return;
    ip = input_file::create(filename);
    if (discard_comments_flag)
        ip = input_remove_hash_comments::create(ip);
    error_count = 0;
}


void
colon::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;
}


source_location
colon::get_source_location(void)
    const
{
    if (!ip)
        return source_location("file has been closed", 666);
    return ip->get_source_location();
}


void
colon::lex(void)
{
    rcstring_accumulator acc;
    for (;;)
    {
        token_locn = get_source_location();
        int c = ip->get();
        switch (c)
        {
        case input::eof:
            token = token_eof;
            return;

        case '\n':
            non_printing_whine = 0;
            token = token_eoln;
            return;

        case ':':
            token = token_colon;
            return;

        default:
            for (;;)
            {
                if
                (
#ifdef AMERICAN_ASCII_ONLY
                    !isprint(c) && !isspace(c)
#else
                    !c
#endif
                &&
                    !non_printing_whine
                )
                {
                    error(token_locn, "line contains non printing character");
                }
                acc.push_back((unsigned char)c);

                c = ip->get();
                if (c == input::eof)
                    break;
                if (c == '\n' || c == ':')
                {
                    ip->unget(c);
                    break;
                }
            }
            token_value = acc.mkstr();
            token = token_string;
            return;
        }
    }
}


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


void
colon::verror(const source_location &locn, const char *fmt, va_list ap)
{
    rcstring msg = rcstring::vformat(fmt, ap);
    explain_output_error("%s: %s", locn.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()
            );
        }
    }
}


void
colon::pedantic_error(const source_location &locn, const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    vpedantic_error(locn, fmt, ap);
    va_end(ap);
}


void
colon::vpedantic_error(const source_location &locn, const char *fmt, va_list ap)
{
    if (cfg.get_bool(SECTION_GLOBAL, "pedantic"))
        verror(locn, fmt, ap);
    else
        vwarning(locn, fmt, ap);
}


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


void
colon::vwarning(const source_location &locn, const char *fmt, va_list ap)
{
    // For maximum portability, always "use up" the arguments, even if
    // we don't issue the warning.
    rcstring msg = rcstring::vformat(fmt, ap);

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


bool
colon::read_one_line(source_location &line_locn, line_t &line)
{
    //
    // open the file if it isn't open already
    //
    open();

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

    //
    // Keep chewing tokens until we've read a whole line.
    //
    token = token_eoln;
    for (;;)
    {
        token_ty prev = token;
        lex();
        switch (token)
        {
        case token_eof:
            if (prev == token_colon)
                line.push_back(rcstring(""));
            if (line.size() > 0)
            {
                error(token_locn, "last line needs newline");
                return true;
            }
            return false;

        case token_eoln:
            if (prev == token_colon)
            {
                if (line.empty())
                    line_locn = token_locn;
                line.push_back(rcstring());
            }
            if (line.empty() && discard_blank_lines_flag)
                continue;
            return true;

        case token_colon:
            if (prev != token_string)
            {
                if (line.empty())
                    line_locn = token_locn;
                line.push_back(rcstring());
            }
            break;

        case token_string:
            if (line.empty())
                line_locn = token_locn;
            line.push_back(token_value);
            break;

        default:
            error(token_locn, "malformed line");
            for (;;)
            {
                lex();
                if (token == token_eof)
                    return false;
                if (token == token_eoln)
                    break;
            }
            break;
        }
    }
}


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


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


void
colon::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 :