/*
 * besm6_punch.c: BESM-6 punchtape devices
 *
 * Copyright (c) 2009, Leonid Broukhis
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:

 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * SERGE VAKULENKO OR LEONID BROUKHIS BE LIABLE FOR ANY CLAIM, DAMAGES
 * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
 * OR OTHER DEALINGS IN THE SOFTWARE.

 * Except as contained in this notice, the name of Leonid Broukhis or
 * Serge Vakulenko shall not be used in advertising or otherwise to promote
 * the sale, use or other dealings in this Software without prior written
 * authorization from Leonid Broukhis and Serge Vakulenko.
 */
#include "besm6_defs.h"

t_stat fs_event (UNIT *u);

UNIT fs_unit [] = {
    { UDATA (fs_event, UNIT_SEQ+UNIT_ATTABLE, 0) },
    { UDATA (fs_event, UNIT_SEQ+UNIT_ATTABLE, 0) },
};

int curchar[2], feed[2], isfifo[2];
char line[2][128];

#define FS1_READY (1<<15)
#define FS2_READY (1<<14)

/* #define NEGATIVE_RDY */

#ifndef NEGATIVE_RDY
#   define ENB_RDY      SET_RDY
#   define DIS_RDY      CLR_RDY
#   define IS_RDY       ISSET_RDY
#else
#   define ENB_RDY      CLR_RDY
#   define DIS_RDY      SET_RDY
#   define IS_RDY       ISCLR_RDY
#endif

#define SET_RDY(x)      do READY |= x; while (0)
#define CLR_RDY(x)      do READY &= ~(x); while (0)
#define ISSET_RDY(x)    ((READY & (x)) != 0)
#define ISCLR_RDY(x)    ((READY & (x)) == 0)

#define FS_RATE         1000*MSEC/1500

unsigned char FS[2];

REG fs_reg[] = {
    { REGDATA ( "Готов", READY, 2,  2, 14, 1, NULL, NULL, 0, 0, 0) },
    { ORDATA  ( "ФС1500-1", FS[0], 8) },
    { ORDATA  ( "ФС1500-2", FS[2], 8) },
    { 0 }
};

MTAB fs_mod[] = {
    { 0 }
};

t_stat fs_reset (DEVICE *dptr);
t_stat fs_attach (UNIT *uptr, CONST char *cptr);
t_stat fs_detach (UNIT *uptr);

DEVICE fs_dev = {
    "FS", fs_unit, fs_reg, fs_mod,
    2, 8, 19, 1, 8, 50,
    NULL, NULL, &fs_reset, NULL, &fs_attach, &fs_detach,
    NULL, DEV_DISABLE | DEV_DEBUG
};

#define CARD_LEN 120
enum {
    FS_IDLE,
    FS_STARTING,
    FS_BINARY,
    FS_RUNNING,
    FS_IMAGE,
    FS_IMAGE_LAST = FS_IMAGE + CARD_LEN - 1,
    FS_TOOLONG,
    FS_FILLUP,
    FS_FILLUP_LAST = FS_FILLUP + CARD_LEN - 1,
    FS_ENDA3,
    FS_ENDA3_LAST = FS_ENDA3 + CARD_LEN - 1,
    FS_TAIL,
} fs_state[2];

int fs_textmode[2];

/*
 * Reset routine
 */
t_stat fs_reset (DEVICE *dptr)
{
    sim_cancel (&fs_unit[0]);
    sim_cancel (&fs_unit[1]);
    fs_state[0] = fs_state[1] = FS_IDLE;
    DIS_RDY(FS1_READY | FS2_READY);
    if (fs_unit[0].flags & UNIT_ATT)
        ENB_RDY(FS1_READY);
    if (fs_unit[1].flags & UNIT_ATT)
        ENB_RDY(FS2_READY);
    return SCPE_OK;
}

/*
 * Attaches a raw binary file by default,
 * with a -t switch attaches a prepared text file in UTF-8.
 */
t_stat fs_attach (UNIT *u, CONST char *cptr)
{
    t_stat s;
    int num = u - fs_unit;
    fs_textmode[num] = sim_switches & SWMASK('T');
    sim_switches &= ~SWMASK('T');
    s = attach_unit (u, cptr);
    if (s != SCPE_OK)
        return s;
    isfifo[num] = (0 == sim_set_fifo_nonblock (u->fileref));
    ENB_RDY(FS1_READY >> num);
    return SCPE_OK;
}

t_stat fs_detach (UNIT *u)
{
    int num = u - fs_unit;
    DIS_RDY(FS1_READY >> num);
    return detach_unit (u);
}

/*
 * Управление двигателем, лампой, протяжкой
 */
void fs_control (int num, uint32 cmd)
{
    UNIT *u = &fs_unit[num];

    static int bytecnt = 0;
    if (fs_dev.dctrl)
        besm6_debug("<<< ФС1500-%d команда %o", num, cmd);
    if (! IS_RDY(FS1_READY >> num)) {
        if (fs_dev.dctrl)
            besm6_debug("<<< ФС1500-%d не готово", num, cmd);
        return;
    }
    switch (cmd) {
    case 0:         /* полное выключение */
        sim_cancel (u);
        fs_state[num] = FS_IDLE;
        if (fs_dev.dctrl)
            besm6_debug("<<<ФС1500-%d ВЫКЛ..", num);
        bytecnt = 0;
        break;
    case 4:         /* двигатель без протяжки */
        fs_state[num] = FS_STARTING;
        if (fs_dev.dctrl)
            besm6_debug("<<<ФС1500-%d ВКЛ.", num);
        sim_cancel (u);
        break;
    case 5:         /* протяжка */
        if (fs_state[num] == FS_IDLE)
            besm6_debug("<<< ФС1500-%d протяжка без мотора", num);
        else if (fs_state[num] != FS_TAIL) {
            sim_activate (u, FS_RATE);
            bytecnt++;
        } else {
            if (! isfifo[num]) {
                fs_detach(u);
                fs_state[num] = FS_IDLE;
            }
        }
        break;
    default:
        besm6_debug ("<<< ФС1500-%d неизвестная команда %o", num, cmd);
    }
    if (cmd && fs_dev.dctrl) {
        besm6_debug("<<<ФС1500-%d: %d симв.", num, bytecnt);
    }
}

unsigned char unicode_to_gost (unsigned short val);

/*
 * The UPP code is the GOST 10859 code with odd parity.
 * UPP stood for "unit for preparation of punchards".
 */
static unsigned char unicode_to_upp (unsigned short ch) {
    unsigned char ret;
    ch = ret = unicode_to_gost (ch);
    ch = (ch & 0x55) + ((ch >> 1) & 0x55);
    ch = (ch & 0x33) + ((ch >> 2) & 0x33);
    ch = (ch & 0x0F) + ((ch >> 4) & 0x0F);
    return (ch & 1) ? ret : ret | 0x80;
}

int utf8_getc (FILE *fin);

/*
 * Событие: читаем очередной символ с перфоленты в регистр.
 * Устанавливаем флаг прерывания.
 */
t_stat fs_event (UNIT *u)
{
    int num = u - fs_unit;
  again:
    if (fs_state[num] == FS_STARTING) {
        /* The first interrupt after starting the motor is dummy,
         * no need to read anything from the attached file.
         */
        FS[num] = 0;
        fs_state[num] = fs_textmode[num] ? FS_RUNNING : FS_BINARY;
    } else if (fs_state[num] == FS_BINARY) {
        int ch = getc (u->fileref);
        if (ch < 0) {
            FS[num] = 0;
            fs_state[num] = FS_TAIL;
        } else {
            FS[num] = ch;
        }
    } else if (fs_state[num] == FS_RUNNING) {
        int ch;
        /* Line separators are ignored in running text mode */
        do ch = utf8_getc (u->fileref); while (ch == '\n' || ch == '\r');
        if (ch < 0) {
            /* the tail end of the tape has no holes */
            FS[num] = 0;
            fs_state[num] = FS_TAIL;
        } else if (ch == (']' & 037)) {
            /* Switching from running text mode to "virtual punchcard" mode and back
             * is done with an ASCII GS (group separator) symbol ctrl-].
             */
            fs_state[num] = FS_IMAGE;
            goto again;
        } else {
            FS[num] = unicode_to_upp (ch);
        }
    } else if (FS_IMAGE <= fs_state[num] && fs_state[num] <= FS_IMAGE_LAST) {
        int ch = utf8_getc (u->fileref);
        if (ch < 0) {
            /* premature end of tape */
            FS[num] = 0;
            fs_state[num] = FS_TAIL;
        } else if (ch == '\r') {
            /* always ignored */
            goto again;
        } else if (ch == '\n') {
            /* Start returning zero bytes up to the end of the current "virtual punchard" */
            fs_state[num] = FS_FILLUP + (fs_state[num] - FS_IMAGE);
            goto again;
        } else if (ch == (']' & 037)) {
            if (fs_state[num] != FS_IMAGE)
                besm6_debug("<<< ENDA3 requested mid-card?");
            fs_state[num] = FS_ENDA3;
            goto again;
        } else {
            FS[num] = unicode_to_upp (ch);
            if (++fs_state[num] == FS_TOOLONG) {
                /* If a line is too long (> 120 chars), start the next "virtual punchcard" */
                fs_state[num] = FS_IMAGE;
            }
        }
    } else if (FS_FILLUP <= fs_state[num] && fs_state[num] <= FS_FILLUP_LAST) {
        FS[num] = 0;
        if (++fs_state[num] == FS_ENDA3) {
            fs_state[num] = FS_IMAGE;
        }
    } else if (FS_ENDA3 <= fs_state[num] && fs_state[num] <= FS_ENDA3_LAST) {
        if ((fs_state[num] - FS_ENDA3) % 5 == 0)
            FS[num] = 0200;
        else
            FS[num] = 0;
        if (++fs_state[num] == FS_TAIL) {
            fs_state[num] = FS_RUNNING;
        }
    } else if (fs_state[num] == FS_IDLE || fs_state[num] == FS_TAIL) {
        FS[num] = 0;
    }
    GRP |= GRP_FS1_SYNC >> num;
    return SCPE_OK;
}

int fs_read(int num) {
    if (fs_dev.dctrl)
        besm6_debug("<<< ФС1500-%d: байт %03o", num, FS[num]);

    return FS[num];
}

/*
 * Unlike the OS which uses GOST overline (approximated by ^) as a line separator
 * in running text mode, the BESM-ALGOL programming system used a nonprintable
 * character (0174) from the unused part of the codetable to allow compressing multiple
 * source lines on a punchcard. To specify that character,
 * we use ASCII RS (record separator) symbol ctrl-^.
 */
unsigned char
unicode_to_gost (unsigned short val)
{
    static const unsigned char tab0 [256] = {
        /* 00 - 07 */   017,    017,    017,    017,    017,    017,    017,    017,
        /* 08 - 0f */   017,    017,    0214,   017,    017,    017,    017,    017,
        /* 10 - 17 */   017,    017,    017,    017,    017,    017,    017,    017,
        /* 18 - 1f */   017,    017,    017,    017,    017,    017,    0174,   017,
        /*  !"#$%&' */  0017,   0133,   0134,   0034,   0127,   0126,   0121,   0033,
        /* ()*+,-./ */  0022,   0023,   0031,   0012,   0015,   0013,   0016,   0014,
        /* 01234567 */  0000,   0001,   0002,   0003,   0004,   0005,   0006,   0007,
        /* 89:;<=>? */  0010,   0011,   0037,   0026,   0035,   0025,   0036,   0136,
        /* @ABCDEFG */  0021,   0040,   0042,   0061,   0077,   0045,   0100,   0101,
        /* HIJKLMNO */  0055,   0102,   0103,   0052,   0104,   0054,   0105,   0056,
        /* PQRSTUVW */  0060,   0106,   0107,   0110,   0062,   0111,   0112,   0113,
        /* XYZ[\]^_ */  0065,   0063,   0114,   0027,   017,    0030,   0115,   0132,
        /* `abcdefg */  0032,   0040,   0042,   0061,   0077,   0045,   0100,   0101,
        /* hijklmno */  0055,   0102,   0103,   0052,   0104,   0054,   0105,   0056,
        /* pqrstuvw */  0060,   0106,   0107,   0110,   0062,   0111,   0112,   0113,
        /* xyz{|}~  */  0065,   0063,   0114,   017,    0130,   017,    0123,   017,
        /* 80 - 87 */   017,    017,    017,    017,    017,    017,    017,    017,
        /* 88 - 8f */   017,    017,    017,    017,    017,    017,    017,    017,
        /* 90 - 97 */   017,    017,    017,    017,    017,    017,    017,    017,
        /* 98 - 9f */   017,    017,    017,    017,    017,    017,    017,    017,
        /* a0 - a7 */   017,    017,    017,    017,    017,    017,    017,    017,
        /* a8 - af */   017,    017,    017,    017,    0123,   017,    017,    017,
        /* b0 - b7 */   0136,   017,    017,    017,    017,    017,    017,    017,
        /* b8 - bf */   017,    017,    017,    017,    017,    017,    017,    017,
        /* c0 - c7 */   017,    017,    017,    017,    017,    017,    017,    017,
        /* c8 - cf */   017,    017,    017,    017,    017,    017,    017,    017,
        /* d0 - d7 */   017,    017,    017,    017,    017,    017,    017,    0024,
        /* d8 - df */   017,    017,    017,    017,    017,    017,    017,    017,
        /* e0 - e7 */   017,    017,    017,    017,    017,    017,    017,    017,
        /* e8 - ef */   017,    017,    017,    017,    017,    017,    017,    017,
        /* f0 - f7 */   017,    017,    017,    017,    017,    017,    017,    0124,
        /* f8 - ff */   017,    017,    017,    017,    017,    017,    017,    017,
    };
    switch (val >> 8) {
    case 0x00:
        return tab0 [val];
    case 0x04:
        switch ((unsigned char) val) {
        case 0x10: return 0040;
        case 0x11: return 0041;
        case 0x12: return 0042;
        case 0x13: return 0043;
        case 0x14: return 0044;
        case 0x15: return 0045;
        case 0x16: return 0046;
        case 0x17: return 0047;
        case 0x18: return 0050;
        case 0x19: return 0051;
        case 0x1a: return 0052;
        case 0x1b: return 0053;
        case 0x1c: return 0054;
        case 0x1d: return 0055;
        case 0x1e: return 0056;
        case 0x1f: return 0057;
        case 0x20: return 0060;
        case 0x21: return 0061;
        case 0x22: return 0062;
        case 0x23: return 0063;
        case 0x24: return 0064;
        case 0x25: return 0065;
        case 0x26: return 0066;
        case 0x27: return 0067;
        case 0x28: return 0070;
        case 0x29: return 0071;
        case 0x2a: return 0135;
        case 0x2b: return 0072;
        case 0x2c: return 0073;
        case 0x2d: return 0074;
        case 0x2e: return 0075;
        case 0x2f: return 0076;
        case 0x30: return 0040;
        case 0x31: return 0041;
        case 0x32: return 0042;
        case 0x33: return 0043;
        case 0x34: return 0044;
        case 0x35: return 0045;
        case 0x36: return 0046;
        case 0x37: return 0047;
        case 0x38: return 0050;
        case 0x39: return 0051;
        case 0x3a: return 0052;
        case 0x3b: return 0053;
        case 0x3c: return 0054;
        case 0x3d: return 0055;
        case 0x3e: return 0056;
        case 0x3f: return 0057;
        case 0x40: return 0060;
        case 0x41: return 0061;
        case 0x42: return 0062;
        case 0x43: return 0063;
        case 0x44: return 0064;
        case 0x45: return 0065;
        case 0x46: return 0066;
        case 0x47: return 0067;
        case 0x48: return 0070;
        case 0x49: return 0071;
        case 0x4a: return 0135;
        case 0x4b: return 0072;
        case 0x4c: return 0073;
        case 0x4d: return 0074;
        case 0x4e: return 0075;
        case 0x4f: return 0076;
        }
        break;
    case 0x20:
        switch ((unsigned char) val) {
        case 0x15: return 0131;
        case 0x18: return 0032;
        case 0x19: return 0033;
        case 0x32: return 0137;
        case 0x3e: return 0115;
        }
        break;
    case 0x21:
        switch ((unsigned char) val) {
        case 0x2f: return 0020;
        case 0x91: return 0021;
        }
        break;
    case 0x22:
        switch ((unsigned char) val) {
        case 0x27: return 0121;
        case 0x28: return 0120;
        case 0x60: return 0034;
        case 0x61: return 0125;
        case 0x64: return 0116;
        case 0x65: return 0117;
        case 0x83: return 0122;
        }
        break;
    case 0x23:
        switch ((unsigned char) val) {
        case 0xe8: return 0020;
        }
        break;
    case 0x25:
        switch ((unsigned char) val) {
        case 0xc7: return 0127;
        case 0xca: return 0127;
        }
        break;
    }
    return 017;
}

/*
 * Read Unicode symbol from file.
 * Convert from UTF-8 encoding.
 */
int
utf8_getc (FILE *fin)
{
    int c1, c2, c3;
  again:
    c1 = getc (fin);
    if (c1 < 0 || ! (c1 & 0x80))
        return c1;
    c2 = getc (fin);
    if (! (c1 & 0x20))
        return (c1 & 0x1f) << 6 | (c2 & 0x3f);
    c3 = getc (fin);
    if (c1 == 0xEF && c2 == 0xBB && c3 == 0xBF) {
        /* Skip zero width no-break space. */
        goto again;
    }
    return (c1 & 0x0f) << 12 | (c2 & 0x3f) << 6 | (c3 & 0x3f);
}