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


#define BUFSIZE ((size_t)1u << 14)


input::~input()
{
    delete [] buf;
    buf = 0;
    buf_allocated = 0;
    pos = 0;
    avail = 0;
    relative_line_number = 0;
}


input::input() :
    buf(0),
    buf_allocated(0),
    pos(0),
    avail(0),
    relative_line_number(0),
    buf_locn(__FILE__, __LINE__)
{
}


int
input::underflow(void)
{
    if (pos >= avail)
    {
        refill();
        if (avail == 0)
            return input::eof;
    }
    unsigned char c = buf[pos++];
    if (c == '\n')
        ++relative_line_number;
    return c;
}


void
input::unget(int c)
{
    if (c == input::eof)
        return;
    if (c == '\n')
        --relative_line_number;
    if (pos <= 0)
    {
        size_t nbytes = avail - pos;

        // reallocate the buffer data, but larger
        size_t new_buf_alloc = (buf_allocated ? 2 * buf_allocated : BUFSIZE);
        unsigned char *new_buf = new unsigned char [new_buf_alloc];
        size_t new_pos = new_buf_alloc - nbytes;
        assert(new_pos > 0);

        // moving the existing data to the top end
        memcpy(new_buf + new_pos, buf + pos, nbytes);

        delete [] buf;
        buf = new_buf;
        buf_allocated = new_buf_alloc;
        pos = new_pos;
        avail = new_buf_alloc;
    }

    --pos;
    buf[pos] = c;
}


void
input::refill(void)
{
    if (!buf)
    {
        buf_allocated = BUFSIZE;
        buf = new unsigned char [buf_allocated];
    }
    pos = 0;
    avail = read_inner(buf_locn, buf, buf_allocated);
    relative_line_number = 0;
}


source_location
input::get_source_location(void)
{
    if (!buf)
        refill();
    return (buf_locn + relative_line_number);
}


int
input::count_newlines(const void *data, size_t data_size)
{
    const char *cp = (const char *)data;
    const char *end = cp + data_size;
    int result = 0;
    while (cp < end)
    {
        // use memchr, it's probably been optimized
        const char *nl = (const char *)memchr(cp, '\n', end - cp);
        if (!nl)
            break;
        cp = nl + 1;
    }
    return result;
}


bool
input::read_one_line(source_location &line_locn, rcstring &line)
{
    line_locn = get_source_location();
    rcstring_accumulator acc;
    for (;;)
    {
        int c = get();
        if (c == input::eof)
        {
            if (acc.empty())
                return false;
            line = acc.mkstr();
            return true;
        }
        if (c == '\n')
        {
            line = acc.mkstr();
            return true;
        }
        acc.push_back((unsigned char)c);
    }
}


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