lib/lexer.cc

Go to the documentation of this file.

//
// canola - canon canola 1614p emulator
// Copyright (C) 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, 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/ac/string.h>
#include <map>

#include <lib/calculator.h>
#include <lib/lexer.h>
#include <lib/lexer/functor/method_bool.h>
#include <lib/lexer/functor/opcode.h>
#include <lib/lexer/functor/program_mode.h>
#include <lib/sizeof.h>
#include <lib/unicode.h>


search_path lexer::include_search_path("program-card-package", true);


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


lexer::lexer(const std::string &filename, calculator &a_subject) :
    subject(a_subject),
    test_mode(false),
    ok(true)
{
    src.push_back(source::create(filename, subject));
}


void
lexer::close(void)
{
    src.clear();
}


void
lexer::open_include_file(const std::string &filename)
{
    src.push_back(source::create(filename, subject));
    card_properties_active = false;
}


int
lexer::getch(void)
{
    for (;;)
    {
        if (src.empty())
            return EOF;
        int c = src.back()->getch();
        if (c != EOF)
            return c;
        src.pop_back();
        card_properties_active = false;
    }
}


void
lexer::ungetch(int c)
{
    if (!src.empty())
        src.back()->ungetch(c);
}


bool
lexer::next_is(char want)
{
    int c = getch();
    if (c == EOF)
        return false;
    if (c == want)
        return true;
    ungetch(c);
    return false;
}


bool
lexer::next_is(const char *want)
{
    const char *cp = want;
    for (;;)
    {
        int want_c = (unsigned char)*cp;
        if (!want_c)
            return true;
        int c = getch();
        if (c != want_c)
        {
            ungetch(c);
            while (cp > want)
                ungetch(*--cp);
            return false;
        }
        ++cp;
    }
}


static std::string
downcase(const std::string &text)
{
    std::string result;
    for (const char *cp = text.c_str(); ; )
    {
        unsigned char c = *cp++;
        if (!c)
            break;
        if (isupper(c))
            c = tolower(c);
        result += c;
    }
    return result;
}


typedef std::map<std::string, lexer_functor::pointer> names_t;
static names_t names;


void
lexer::load_names(void)
{
    if (!names.empty())
        return;

    struct table_t
    {
        const char *name;
        opcode_t value;
    };

    static const table_t table[] =
    {
        { "bs", opcode_right },
        { "c", opcode_extended_c },
        { "call", opcode_suj },
        { "cancel", opcode_extended_c },
        { "cancel_entry", opcode_clear_indicator },
        { "ce", opcode_clear_indicator },
        { "ceil", opcode_round_up },
        { "ceiling", opcode_round_up },
        { "change_sign", opcode_chg_sign },
        { "chg_sign", opcode_chg_sign },
        { "ci", opcode_clear_indicator },
        { "clear", opcode_extended_c },
        { "clear_display", opcode_clear_indicator },
        { "clear_entry", opcode_clear_indicator },
        { "clear_indicator", opcode_clear_indicator },
        { "cm3_tilde", opcode_extended_cm3_tilde },
        { "cm_tilde", opcode_extended_cm3_tilde },
        { "cs", opcode_chg_sign },
        { "decimal", opcode_dot },
        { "decimal_point", opcode_dot },
        { "display_print", opcode_extended_display_print },
        { "div", opcode_div },
        { "divide", opcode_div },
        { "division", opcode_div },
        { "dot", opcode_dot },
        { "down", opcode_round_down },
        { "e", opcode_ent },
        { "enter", opcode_ent },
        { "enter_jump", opcode_ej },
        { "entry", opcode_ent },
        { "entry_jump", opcode_ej },
        { "exit", opcode_extended_off },
        { "feed", opcode_fd },
        { "flag", opcode_fj },
        { "flag_jump", opcode_fj },
        { "floor", opcode_round_down },
        { "full_stop", opcode_dot },
        { "gosub", opcode_suj },
        { "jmp", opcode_uj },
        { "jsr", opcode_suj },
        { "jump", opcode_uj },
        { "label", opcode_fj },
        { "m3_tilde", opcode_extended_m3_tilde },
        { "m_tilde", opcode_extended_m3_tilde },
        { "minus_equals", opcode_minus_equals },
        { "minus_jump", opcode_mj },
        { "mul", opcode_mul },
        { "multiplication", opcode_mul },
        { "multiply", opcode_mul },
        { "off", opcode_extended_off },
        { "paper_feed", opcode_fd },
        { "period", opcode_dot },
        { "plus_equals", opcode_plus_equals },
        { "power_off", opcode_extended_off },
        { "print_display", opcode_extended_display_print },
        { "print_feed", opcode_fd },
        { "print_program", opcode_extended_program_print },
        { "printer_feed", opcode_fd },
        { "program_print", opcode_extended_program_print },
        { "quit", opcode_extended_off },
        { "return", opcode_srj },
        { "rev", opcode_rv },
        { "reverse", opcode_rv },
        { "reverse_values", opcode_rv },
        { "right", opcode_right },
        { "right_shift", opcode_right },
        { "rm3_tilde", opcode_extended_rm3_tilde },
        { "rm_tilde", opcode_extended_rm3_tilde },
        { "root", opcode_sqrt },
        { "round", opcode_round_off },
        { "rts", opcode_srj },
        { "s", opcode_ent },
        { "sc", opcode_chg_sign },
        { "sense_jump", opcode_sj },
        { "shift", opcode_right },
        { "shift_right", opcode_right },
        { "sign_change", opcode_chg_sign },
        { "sign_chg", opcode_chg_sign },
        { "sm3_tilde", opcode_extended_sm3_tilde },
        { "sm_tilde", opcode_extended_sm3_tilde },
        { "sqrt", opcode_sqrt },
        { "square_root", opcode_sqrt },
        { "start", opcode_extended_start },
        { "stop", opcode_ent },
        { "subroutine_flag", opcode_sfj },
        { "subroutine_flag_jump", opcode_sfj },
        { "subroutine_jump", opcode_suj },
        { "subroutine_label", opcode_sfj },
        { "subroutine_return_jump", opcode_srj },
        { "times", opcode_mul },
        { "unconditional_jump", opcode_uj },
        { "up", opcode_round_up },
        { "x", opcode_mul },
    };

    // Insert the table values into the map.
    // This will be faster than a linear search.
    for (const table_t *tp = table; tp < ENDOF(table); ++tp)
    {
        names[tp->name] = lexer_functor_opcode::create(subject, tp->value);
    }

    if (test_mode)
    {
        static const table_t table2[] =
        {
            { "rounding_switch_up", opcode_extended_rounding_switch_up },
            { "rounding_switch_off", opcode_extended_rounding_switch_off },
            { "rounding_switch_down", opcode_extended_rounding_switch_down },
            { "decimal_point_selector_0",
                opcode_extended_decimal_point_selector_0 },
            { "decimal_point_selector_1",
                opcode_extended_decimal_point_selector_1 },
            { "decimal_point_selector_2",
                opcode_extended_decimal_point_selector_2 },
            { "decimal_point_selector_3",
                opcode_extended_decimal_point_selector_3 },
            { "decimal_point_selector_4",
                opcode_extended_decimal_point_selector_4 },
            { "decimal_point_selector_5",
                opcode_extended_decimal_point_selector_5 },
            { "decimal_point_selector_6",
                opcode_extended_decimal_point_selector_6 },
            { "decimal_point_selector_7",
                opcode_extended_decimal_point_selector_7 },
            { "decimal_point_selector_8",
                opcode_extended_decimal_point_selector_8 },
            { "decimal_point_selector_9",
                opcode_extended_decimal_point_selector_9 },
            { "decimal_point_selector_10",
                opcode_extended_decimal_point_selector_10 },
            { "decimal_point_selector_11",
                opcode_extended_decimal_point_selector_11 },
            { "decimal_point_selector_12",
                opcode_extended_decimal_point_selector_12 },
            { "decimal_point_selector_float",
                opcode_extended_decimal_point_selector_float },
        };

        for (const table_t *tp = table2; tp < ENDOF(table2); ++tp)
        {
            names[tp->name] = lexer_functor_opcode::create(subject, tp->value);
        }

        {
            lexer_functor::pointer lrn =
                lexer_functor_program_mode::create
                (
                    subject,
                    calculator::program_mode_learn
                );
            names["lrn"] = lrn;
            names["learn"] = lrn;
        }

        {
            lexer_functor::pointer ope =
                lexer_functor_program_mode::create
                (
                    subject,
                    calculator::program_mode_operation
                );
            names["ope"] = ope;
            names["operation"] = ope;
            names["operate"] = ope;
        }

        {
            lexer_functor::pointer pro_che =
                lexer_functor_program_mode::create
                (
                    subject,
                    calculator::program_mode_program_check
                );
            names["pro_che"] = pro_che;
            names["program_check"] = pro_che;
        }

        {
            lexer_functor::pointer ope_che =
                lexer_functor_program_mode::create
                (
                    subject,
                    calculator::program_mode_operation_check
                );
            names["ope_che"] = ope_che;
            names["operate_check"] = ope_che;
            names["operation_check"] = ope_che;
        }

        {
            lexer_functor::pointer on =
                lexer_functor_method_bool::create
                (
                    subject,
                    &calculator::accumulate_mode_set,
                    true
                );
            names["am1_down"] = on;
            names["am1_lock"] = on;
            names["am1_on"] = on;
        }

        {
            lexer_functor::pointer off =
                lexer_functor_method_bool::create
                (
                    subject,
                    &calculator::accumulate_mode_set,
                    false
                );
            names["am1_off"] = off;
            names["am1_unlock"] = off;
            names["am1_up"] = off;
        }

        {
            lexer_functor::pointer on =
                lexer_functor_method_bool::create
                (
                    subject,
                    &calculator::constant_mode_set,
                    true
                );
            names["const_on"] = on;
            names["constant_on"] = on;
            names["k_down"] = on;
            names["k_lock"] = on;
            names["k_on"] = on;
            names["konstant_on"] = on;
        }

        {
            lexer_functor::pointer off =
                lexer_functor_method_bool::create
                (
                    subject,
                    &calculator::constant_mode_set,
                    false
                );
            names["const_off"] = off;
            names["constant_off"] = off;
            names["k_off"] = off;
            names["k_unlock"] = off;
            names["k_up"] = off;
            names["konstant_off"] = off;
        }
    }

    // If the tables contain conflicts, the real opcodes win.
    for (int j = 1; j < 127; ++j)
    {
        if (opcode_valid(j))
        {
            names[downcase(opcode_name((opcode_t)j))] =
                lexer_functor_opcode::create(subject, (opcode_t)j);
        }
    }
}


struct multibyte_t
{
    const char *name;
    opcode_t value;
};


static const multibyte_t multibyte[] =
{
    { "5/4", opcode_round_off },
    { UNICODE_MUL, opcode_mul },
    { UNICODE_DIV, opcode_div },
    { UNICODE_UP, opcode_round_up },
    { UNICODE_RIGHT, opcode_right },
    { UNICODE_DOWN, opcode_round_down },
    { UNICODE_SQRT, opcode_sqrt },
    { UNICODE_PRINT, opcode_print },
    { UNICODE_MINUS "=", opcode_minus_equals },
};


static std::string
trim(const std::string &text)
{
    std::string result;
    const char *s = text.c_str();
    bool white_space = false;
    for (;;)
    {
        unsigned char c = *s++;
        switch (c)
        {
        case '\0':
            return result;

        case ' ':
        case '\f':
        case '\n':
        case '\r':
        case '\t':
        case '\v':
            if (result.size())
                white_space = true;
            break;

        default:
            if (white_space)
            {
                result += ' ';
                white_space = false;
            }
            result += c;
            break;
        }
    }
}


void
lexer::process_comment(const std::string &text)
{
    if (src.size() != 1)
        return;
    if (card_properties_active)
    {
        if (strstr(text.c_str(), "Card-Pocket-End"))
        {
            card_properties_active = false;
        }
        else
        {
            const char *s = text.c_str();
            const char *colon = strchr(s, ':');
            if (colon)
            {
                std::string name = trim(std::string(s, colon - s));
                std::string value = trim(std::string(colon + 1));
                subject.property(name, value);
            }
        }
    }
    else
    {
        card_properties_active = !!strstr(text.c_str(), "Card-Pocket-Begin");
    }
}


bool
lexer::read_and_execute(void)
{
    ok = true;
    load_names();
    for (;;)
    {
        location::pointer start_loc = get_location();

        // First do some read-ahead, looking for multi-byte special cases
        for (const multibyte_t *mb = multibyte; mb < ENDOF(multibyte); ++mb)
        {
            if (next_is(mb->name))
            {
                subject.on_opcode(mb->value, get_location(start_loc));
                continue;
            }
        }

        int c = getch();
        switch (c)
        {
        case EOF:
            return ok;

        case '\n':
        case '\t':
        case '\f':
        case '\r':
        case ' ':
            // Ignore white space,
            // except as it serves to separate tokens.
            break;

        case '#':
            comment:
            {
                std::string text;
                for (;;)
                {
                    int c = getch();
                    if (c == EOF || c == '\n')
                    {
                        ungetch(c);
                        break;
                    }
                    text += (char)c;
                }
                process_comment(text);
            }
            break;

        case '$':
            {
                // This is a magical escape so that we can insert
                // arbitrary values into the code stream.
                int c1 = getch();
                if (c1 < '0' || c > '7')
                {
                    dollar_barf:
                    error
                    (
                        "the $ symbol must be followed by exactly three "
                            "digits, and form a valid code"
                    );
                    close();
                    return false;
                }
                c1 -= '0';

                int c2 = getch();
                if (c2 < '0' || c2 > '1')
                    goto dollar_barf;
                c2 -= '0';

                int c3 = getch();
                if (c3 < '0' || c > '9')
                    goto dollar_barf;
                c3 -= '0';

                int code = (c1 << 4) + (c2 * 10) + c3;
                if (code == 0 || code == 0x7F)
                    goto dollar_barf;
                subject.on_opcode((opcode_t)code, get_location(start_loc));
            }
            break;

        case '*':
            subject.on_opcode(opcode_mul, get_location(start_loc));
            break;

        case '+':
            if (next_is('='))
            {
                subject.on_opcode(opcode_plus_equals, get_location(start_loc));
                break;
            }
            goto junk;

        case '-':
            if (next_is('='))
            {
                subject.on_opcode(opcode_minus_equals, get_location(start_loc));
                break;
            }
            if (next_is('>'))
            {
                subject.on_opcode(opcode_right, get_location(start_loc));
                break;
            }
            subject.on_opcode(opcode_chg_sign, get_location(start_loc));
            break;

        case '.':
            subject.on_opcode(opcode_dot, get_location(start_loc));
            break;

        case '/':
            subject.on_opcode(opcode_div, get_location(start_loc));
            break;

            // FIXME: the "5/4" opcode could be a problem.

        case '0': case '1': case '2': case '3': case '4':
        case '5': case '6': case '7': case '8': case '9':
            subject.on_opcode
            (
                opcode_t(opcode_n0 + c - '0'),
                get_location(start_loc)
            );
            break;

        case ';':
            goto comment;

        case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G':
        case 'H': case 'I': case 'J': case 'K': case 'L': case 'M': case 'N':
        case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U':
        case 'V': case 'W': case 'X': case 'Y': case 'Z':
        case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
        case 'h': case 'i': case 'j': case 'k': case 'l': case 'm': case 'n':
        case 'o': case 'p': case 'q': case 'r': case 's': case 't': case 'u':
        case 'v': case 'w': case 'x': case 'y': case 'z':
            {
                std::string name;
                for (;;)
                {
                    if (isupper((unsigned char)c))
                        c = tolower((unsigned char)c);
                    name += (char)c;
                    c = getch();
                    switch (c)
                    {
                    case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
                    case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
                    case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
                    case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
                    case 'Y': case 'Z':
                    case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
                    case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':
                    case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':
                    case 's': case 't': case 'u': case 'v': case 'w': case 'x':
                    case 'y': case 'z':
                    case '0': case '1': case '2': case '3': case '4':
                    case '5': case '6': case '7': case '8': case '9':
                    case '_': case '~':
                        continue;

                    default:
                        ungetch(c);
                        break;
                    }
                    break;
                }

                // opcodes
                names_t::const_iterator it = names.find(name);
                if (it != names.end())
                {
                    (*(it->second))(get_location(start_loc));
                    break;
                }

                if (name == "include")
                {
                    // rest of line is include file name
                    std::string filename;
                    for (;;)
                    {
                        c = getch();
                        switch (c)
                        {
                        default:
                            filename += (char)c;
                            continue;

                        case '\t':
                        case ' ':
                            if (filename.empty())
                                continue;
                            ungetch(c);
                            break;

                        case '\n':
                        case '\r':
                        case '#':
                        case ';':
                            ungetch(c);
                            break;

                        case EOF:
                            break;
                        }
                        break;
                    }
                    open_include_file(filename);
                    break;
                }

                // no idea
                error("unknown key name \"%s\"", name.c_str());
                close();
                return false;
            }

        default:
            junk:
            if (isgraph((unsigned char)c))
                error("invalid input, near '%c'", c);
            else
                error("invalid input");
            close();
            return false;
        }
    }
}


bool
lexer::read_binary_and_execute(void)
{
    ok = true;
    int address = 0;
    for (;;)
    {
        // Stupid, I know, but the 1614P used 1-based addresses, instead
        // of the more modern 0-based addresses.  This *was* only 1972,
        // and the 1614P was probably designed a couple of years before
        // that, so we can cut them *some* slack.
        ++address;

        int c = getch();
        switch (c)
        {
        case EOF:
            return ok;

        case 0x00:
        case 0x7F:
            // These are ignored by the 1614P's card reader.
            break;

        default:
            if (c >= 1 && c <= 126)
            {
                // Allow almost anything here.  This is because random
                // shite can be used for flag jump labels.
                subject.on_opcode(opcode_t(c), location::pointer());
                break;
            }

            // Oops.
            src.back()->set_line_number(address);
            error("invalid code 0x%02X", c);
            return false;
        }
    }
}


void
lexer::error(const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    if (src.empty())
        subject.on_error_v(fmt, ap);
    else
        src.back()->error_v(fmt, ap);
    va_end(ap);

    // Finish processing after the first error, because we could be
    // feeding the GUI calculator input at this point.
    close();

    ok = false;
}


void
lexer::search_path_append(const std::string &dir)
{
    include_search_path.append(dir);
}


void
lexer::test_mode_set(bool value)
{
    test_mode = value;
}


location::pointer
lexer::get_location(void)
    const
{
    if (src.empty())
        return location::pointer();
    return src.back()->get_location();
}


location::pointer
lexer::get_location(const location::pointer &start)
    const
{
    location::pointer end = get_location();
    return location::span(start, end);
}