lib/lexer/source.cc

Go to the documentation of this file.

//
// canola - canon canola 1614p emulator
// Copyright (C) 2011 Peter Miller
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License, version 3, as
// published by the Free Software Foundation.
//
// 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/config.h>
#include <libexplain/fopen.h>
#include <libexplain/fclose.h>
#include <libexplain/getc.h>

#include <lib/calculator.h>
#include <lib/lexer.h>
#include <lib/std_string_printf.h>


lexer::source::~source()
{
    close();
}


lexer::source::source(const std::string &a_filename, calculator &a_subject) :
    filename(a_filename),
    subject(a_subject),
    fp(0),
    line_number(1),
    prev_was_newline(false),
    position(0)
{
    std::string fn = lexer::include_search_path.find(filename);
    fp = fopen(fn.c_str(), "r");
    if (!fp)
        subject.on_error("%s", explain_fopen(fn.c_str(), "r"));

    // Use the actual file name for error messages, and also opcode locations.
    filename = fn;
}


lexer::source::pointer
lexer::source::create(const std::string &a_filename, calculator &a_subject)
{
    return pointer(new source(a_filename, a_subject));
}


void
lexer::source::close(void)
{
    if (fp)
    {
        if (fclose(fp))
            subject.on_error("%s", explain_fclose(fp));
        fp = 0;
    }
}


int
lexer::source::getch(void)
{
    if (prev_was_newline)
    {
        ++line_number;
        prev_was_newline = false;
    }
    if (!pushback.empty())
    {
        int c = pushback.back();
        pushback.pop_back();
        ++position;
        prev_was_newline = (c == '\n');
        return c;
    }
    if (!fp)
        return EOF;
    int c = getc(fp);
    if (c == EOF)
    {
        if (ferror(fp))
            subject.on_error("%s", explain_getc(fp));
        close();
    }
    else
        ++position;
    prev_was_newline = (c == '\n');
    return c;
}


void
lexer::source::ungetch(int c)
{
    if (c == '\n')
        prev_was_newline = false;
    if (c != EOF)
    {
        pushback.push_back(c);
        --position;
        assert(position >= 0);
    }
}


void
lexer::source::set_line_number(int n)
{
    assert(n > 0);
    line_number = n;
}


void
lexer::source::error(const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    error_v(fmt, ap);
    va_end(ap);
}


void
lexer::source::error_v(const char *fmt, va_list ap)
{
    std::string text = std_string_printf_v(fmt, ap);
    subject.on_error("%s: %d: %s", filename.c_str(), line_number, text.c_str());
    close();
}


location::pointer
lexer::source::get_location(void)
    const
{
    assert(position >= 0);
    return location::create(filename, line_number, position, 0);
}