lib/calculator/save_program_as.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/assert.h>
#include <lib/ac/fcntl.h>
#include <lib/ac/stdio.h>
#include <lib/ac/unistd.h>
#include <libexplain/close.h>
#include <libexplain/creat.h>
#include <libexplain/fclose.h>
#include <libexplain/fflush.h>
#include <libexplain/fopen.h>
#include <libexplain/write.h>
#include <map>

#include <lib/calculator.h>
#include <lib/sizeof.h>


typedef std::map<int, const char *> system_subroutines_t;
static system_subroutines_t system_subroutines;


static void
setup_system_subroutines(void)
{
    if (!system_subroutines.empty())
        return;

    struct table_t
    {
        const char *name;
        int number;
    };

    // Instruction Manual, p. 56
    static const table_t table[] =
    {
        { "sin(x)", 0x21 },
        { "cos(x)", 0x22 },
        { "tan(x)", 0x23 },
        { "asin(x)", 0x24 },
        { "acos(x)", 0x25 },
        { "atan(x)", 0x26 },
        { "a**n", 0x27 },
        { "a**x", 0x28 },
        { "10**n", 0x29 },
        { "log10(x)", 0x2A },
        { "exp(x)", 0x2B },
        { "ln(x)", 0x2C },
        { "sinh(x)", 0x2D },
        { "cosh(x)", 0x2E },
        { "tanh(x)", 0x31 },
        { "asinh(x)", 0x32 },
        { "acosh(x)", 0x33 },
        { "atanh(x)", 0x34 },
        { "polar_to_rectangular", 0x35 },
        { "rectangular_to_polar", 0x36 },
        { "dms_to_degree", 0x37 },
        { "degree_to_dms", 0x38 },
        { "degree_to_radian", 0x39 },
        { "radian_to_degree", 0x3A },
        { "factorial(n)", 0x3B },
    };

    for (const table_t *tp = table; tp < ENDOF(table); ++tp)
        system_subroutines[tp->number] = tp->name;
}


void
calculator::save_program_as(const std::string &filename, bool binary)
{
    unsigned char *prog_data = programme + 1;
    size_t prog_size = 240;
    switch (program_selector)
    {
    case program_selector_i_ii:
    default:
        break;

    case program_selector_i:
        prog_size = 120;
        break;

    case program_selector_ii:
        prog_data = programme + 121;
        prog_size = 120;
        break;
    }
    assert(prog_data >= programme);
    assert(prog_data < programme + sizeof(programme));
    assert(prog_data + prog_size >= programme);
    assert(prog_data + prog_size <= programme + sizeof(programme));

    if (binary)
    {
        const int mode = 0666;
        int fd = creat(filename.c_str(), mode);
        if (fd < 0)
        {
            on_error("%s", explain_creat(filename.c_str(), mode));
            return;
        }
        if (write(fd, prog_data, prog_size) < 0)
        {
            on_error("%s", explain_write(fd, prog_data, prog_size));
            close(fd);
            return;
        }
        if (close(fd) < 0)
        {
            on_error("%s", explain_close(fd));
            return;
        }
    }
    else
    {
        FILE *fp = fopen(filename.c_str(), "w");
        if (!fp)
        {
            on_error("%s", explain_fopen(filename.c_str(), "w"));
            return;
        }

        // text mode requires a little more work.
        const unsigned char *p = prog_data;
        const unsigned char *prog_end = prog_data + prog_size;
        while (p < prog_end && prog_end[-1] == 0)
            --prog_end;
        while (p < prog_end)
        {
            unsigned char op = *p++;
            switch (op)
            {
            case 0:
            case 0xFF:
                break;

            case opcode_dot:
            case opcode_n0:
            case opcode_n1:
            case opcode_n2:
            case opcode_n3:
            case opcode_n4:
            case opcode_n5:
            case opcode_n6:
            case opcode_n7:
            case opcode_n8:
            case opcode_n9:
                fputs("    ", fp);
                for (;;)
                {
                    fprintf(fp, "%s", opcode_name((opcode_t)op).c_str());
                    if (p >= prog_end)
                        break;
                    op = *p;
                    switch (op)
                    {
                    case opcode_dot:
                    case opcode_n0:
                    case opcode_n1:
                    case opcode_n2:
                    case opcode_n3:
                    case opcode_n4:
                    case opcode_n5:
                    case opcode_n6:
                    case opcode_n7:
                    case opcode_n8:
                    case opcode_n9:
                        ++p;
                        continue;

                    default:
                        break;
                    }
                    break;
                }
                fputc('\n', fp);
                break;

            case opcode_sj:
            case opcode_ej:
            case opcode_mj:
            case opcode_uj:
            case opcode_suj:
                fputs("    ", fp);
                // Fall through...

            case opcode_fj:
            case opcode_sfj:
                fputs(opcode_name((opcode_t)op).c_str(), fp);
                if (p < prog_end)
                {
                    fputc(' ', fp);
                    int op2 = *p++;
                    if (op2 < 0x70)
                        fputs(opcode_raw_name((opcode_t)op2).c_str(), fp);
                    else
                        fputs(opcode_name((opcode_t)op2).c_str(), fp);

                    if (op == opcode_suj)
                    {
                        //
                        // Let's assume users don't re-use library
                        // subroutine labels, and thus include the names of
                        // library subroutines.
                        //
                        setup_system_subroutines();
                        system_subroutines_t::const_iterator it =
                            system_subroutines.find((int)op2);
                        if (it != system_subroutines.end())
                            fprintf(fp, " ; %s", it->second);
                    }
                }
                fputc('\n', fp);
                break;

            case opcode_round_up:
            case opcode_round_off:
            case opcode_round_down:
                fputs("    ", fp);
                fputs(opcode_name((opcode_t)op).c_str(), fp);
                if (p < prog_end)
                {
                    fputc(' ', fp);
                    op = *p++;
                    fputs(opcode_name((opcode_t)op).c_str(), fp);
                }
                fputc('\n', fp);
                break;

            default:
                fputs("    ", fp);
                fputs(opcode_name((opcode_t)op).c_str(), fp);
                fputc('\n', fp);
                break;
            }
        }
        if (fflush(fp))
        {
            on_error("%s", explain_fflush(fp));
            fclose(fp);
            return;
        }
        if (fclose(fp))
        {
            on_error("%s", explain_fclose(fp));
            return;
        }
    }
}