lib/input/remove_hash_comments.cc

Go to the documentation of this file.

//
// nis-util - NIS Administration Utilities
// Copyright (C) 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/string.h>

#include <lib/input/remove_hash_comments.h>


input_remove_hash_comments::~input_remove_hash_comments()
{
}


input_remove_hash_comments::input_remove_hash_comments(
    const input::pointer &a_deeper
) :
    deeper(a_deeper),
    state(state_start_of_line)
{
}


input_remove_hash_comments::pointer
input_remove_hash_comments::create(const input::pointer &a_deeper)
{
    return pointer(new input_remove_hash_comments(a_deeper));
}


size_t
input_remove_hash_comments::read_inner(source_location &data_locn, void *vdata,
    size_t data_size)
{
    data_locn = deeper->get_source_location();
    unsigned char *data = (unsigned char *)vdata;
    unsigned char *cp = data;
    unsigned char *end = data + data_size;
    while (cp < end)
    {
        int ic = deeper->get();
        if (ic == input::eof)
            break;
        unsigned char c = ic;
        switch (state)
        {
        case state_start_of_line:
            switch (c)
            {
            case ' ':
            case '\t':
                whitespace.clear();
                whitespace.push_back(c);
                state = state_white_space;
                break;

            case '\n':
                *cp++ = '\n';
                state = state_start_of_line;
                goto end_of_line;

            case '#':
                state = state_discarding;
                break;

            default:
                *cp++ = c;
                state = state_content;
                break;
            }
            break;

        case state_discarding:
            if (c == '\n')
            {
                *cp++ = '\n';
                state = state_start_of_line;
                goto end_of_line;
            }
            break;

        case state_white_space:
            switch (c)
            {
            case ' ':
            case '\t':
                whitespace.push_back(c);
                state = state_white_space;
                break;

            case '\n':
                *cp++ = '\n';
                state = state_start_of_line;
                goto end_of_line;

            case '#':
                whitespace.clear();
                state = state_discarding;
                break;

            default:
                // what if whitespace doesn't fit?
                // (the "or equal" is because we need room for 'c' as well)
                if (cp + whitespace.size() >= end)
                {
                    deeper->unget(c);
                    size_t nbytes = end - cp;
                    assert(nbytes <= whitespace.size());
                    memcpy(cp, whitespace.get_data(), nbytes);
                    cp += nbytes;
                    whitespace.pop_front(nbytes);
                    state = state_white_space;
                }
                else
                {
                    memcpy(cp, whitespace.get_data(), whitespace.size());
                    cp += whitespace.size();
                    whitespace.clear();
                    *cp++ = c;
                    state = state_content;
                }
                break;
            }
            break;

        case state_content:
            switch (c)
            {
            case ' ':
            case '\t':
                whitespace.clear();
                whitespace.push_back(c);
                state = state_white_space;
                break;

            case '\n':
                *cp++ = c;
                state = state_start_of_line;
                goto end_of_line;

            case '#':
                // Note: a@b#c does not contain the start of a comment
            default:
                *cp++ = c;
                state = state_content;
                break;
            }
            break;
        }
    }
    end_of_line:
    return (cp - data);
}


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