Subversion Repositories i650

//////////////////////////////////////////////////////////////////////////////////

// IBM 650 Reconstruction in Verilog (i650)

// 

// This file is part of the IBM 650 Reconstruction in Verilog (i650) project

// http:////www.opencores.org/project,i650

//

// Description: An implementation of SOAP 2 for the IBM 650.

// 

// Additional Comments: .

//

// Copyright (c) 2015 Robert Abeles

//

// This source file is free software; you can redistribute it

// and/or modify it under the terms of the GNU Lesser General

// Public License as published by the Free Software Foundation;

// either version 2.1 of the License, or (at your option) any

// later version.

//

// This source 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 Lesser General Public License for more

// details.

//

// You should have received a copy of the GNU Lesser General

// Public License along with this source; if not, download it

// from http://www.opencores.org/lgpl.shtml

//////////////////////////////////////////////////////////////////////////////////

#include "ibm_codec.h"

#include <iostream>

#include <iomanip>

using namespace std;

// -------------------------------------------------------------------------

// Hollerith zone and digit punches.

// -------------------------------------------------------------------------

enum holl_zn {

  holl_znone,

  holl_z0,

  holl_z11,     // aka X punch

  holl_z12      // aka Y punch

};

enum holl_dig {

  holl_dnone,

  holl_d0,

  holl_d1,

  holl_d2,

  holl_d3,

  holl_d4,

  holl_d5,

  holl_d6,

  holl_d7,

  holl_d8,

  holl_d9,

  holl_d8_2,

  holl_d8_3,

  holl_d8_4,

  holl_d8_5,

  holl_d8_6,

  holl_d8_7

};

// -------------------------------------------------------------------------

// Glyph specification.

// -------------------------------------------------------------------------

struct glyph_spec {

    holl_zn  zone;

    holl_dig digit;

    int      unicode;

    int      ascii;

    int      keycode; // Qt keycode

    int      code650;

    int      bcd704;

    int      bcd705;

    int      codeset;

};

// -------------------------------------------------------------------------

// Not all BCD characters have readily available keyboard equivalents.

// To these characters, we assign a modifier plus an alphabetic key.

// When the keycode field is not negative, it contains the unmodified

// keycode of the alphabetic key that when entered with a platform-

// pecific modifier key will enter the unavailable code. For example,

// pressing alt-R on a Mac will enter the unicode 'square root' character.

// Pressing the modifier key with a digit, '-', or '=' key will act

// as a multipunch, where '-' is an 11 punch and '=' is a 12 punch.

//

// The special characters in the final group, shown below, have

// several alternate encodings, designated by IBM as special character

// arrangements A through K. Encodings A, F and H are implemented above.

//

// A - &.^-$*,%/#@

// B - /.^-$*,%&#@

// C - &.^-$*,%0#@

// D - -.^-$*,%/#@

// E - -.<./*,%&#>

// F - +.)-$*,(/=-

// G - +.^-$*,%/+-

// H - +.)-$*,(/='

// J - +.^-$*,%/#@

// K - +.)-$*,(/=@

//

// In addition to the standard 48 BCD encodings shown above, the 705

// uses 6 additional encodings, 4 for marks (tape mark, record mark,

// group mark, storage and drum mark), and 2 encodings for signed zeroes

// (plus zero, minus zero).

//

// A word about marks. Some of the BCD character codes have special meaning to

// early IBM business computers. The 702 and its successor machines (705, 7070)

// were 'character oriented', i.e., they operated on variable length BCD character

// strings. Mark characters ('tape mark', 'record mark', 'group mark',

// 'segment mark', and 'word separator') served to delineate variable length

// objects on tape and in memory.

//

// In fact, a six bit character can have 64 unique values. The remaining

// unused BCD character codes were assigned by subsequent machines until

// all possible codes were accounted for. Mappings between BCD and Hollerith

// remain stable across the IBM product line, but glyph assignment differs

// between systems, options, and RPQs.

// -------------------------------------------------------------------------

#define A48 cs_bcd48_a

#define F48 cs_bcd48_f

#define H48 cs_bcd48_h

#define BCD48 cs_bcd48

#define BCD64 cs_bcd64

static glyph_spec glyph_codes[] = {

//   zone        digit      unicode ascii keycd 650 704  14xx codeset(s)

//                                              BCD BCD  BCD

    {holl_znone, holl_dnone, ' ',    ' ',  -1,  00, 060, 000, BCD48},

    {holl_znone, holl_d0,    '0',    '0',  -1,  90, 000, 012, BCD48},

    {holl_znone, holl_d1,    '1',    '1',  -1,  91, 001, 001, BCD48},

    {holl_znone, holl_d2,    '2',    '2',  -1,  92, 002, 002, BCD48},

    {holl_znone, holl_d3,    '3',    '3',  -1,  93, 003, 003, BCD48},

    {holl_znone, holl_d4,    '4',    '4',  -1,  94, 004, 004, BCD48},

    {holl_znone, holl_d5,    '5',    '5',  -1,  95, 005, 005, BCD48},

    {holl_znone, holl_d6,    '6',    '6',  -1,  96, 006, 006, BCD48},

    {holl_znone, holl_d7,    '7',    '7',  -1,  97, 007, 007, BCD48},

    {holl_znone, holl_d8,    '8',    '8',  -1,  98, 010, 010, BCD48},

    {holl_znone, holl_d9,    '9',    '9',  -1,  99, 011, 011, BCD48},

    {holl_z12,   holl_d0,    '?',    '?',  -1,  -1, 032, 072, BCD64},  // plus zero

    {holl_z12,   holl_d1,    'A',    'A',  -1,  61, 021, 061, BCD48},

    {holl_z12,   holl_d2,    'B',    'B',  -1,  62, 022, 062, BCD48},

    {holl_z12,   holl_d3,    'C',    'C',  -1,  63, 023, 063, BCD48},

    {holl_z12,   holl_d4,    'D',    'D',  -1,  64, 024, 064, BCD48},

    {holl_z12,   holl_d5,    'E',    'E',  -1,  65, 025, 065, BCD48},

    {holl_z12,   holl_d6,    'F',    'F',  -1,  66, 026, 066, BCD48},

    {holl_z12,   holl_d7,    'G',    'G',  -1,  67, 027, 067, BCD48},

    {holl_z12,   holl_d8,    'H',    'H',  -1,  68, 030, 070, BCD48},

    {holl_z12,   holl_d9,    'I',    'I',  -1,  69, 031, 071, BCD48},

    {holl_z11,   holl_d0,    '!',    '!',  -1,  -1, 052, 052, BCD64},  // minus zero

    {holl_z11,   holl_d1,    'J',    'J',  -1,  71, 041, 041, BCD48},

    {holl_z11,   holl_d2,    'K',    'K',  -1,  72, 042, 042, BCD48},

    {holl_z11,   holl_d3,    'L',    'L',  -1,  73, 043, 043, BCD48},

    {holl_z11,   holl_d4,    'M',    'M',  -1,  74, 044, 044, BCD48},

    {holl_z11,   holl_d5,    'N',    'N',  -1,  75, 045, 045, BCD48},

    {holl_z11,   holl_d6,    'O',    'O',  -1,  76, 046, 046, BCD48},

    {holl_z11,   holl_d7,    'P',    'P',  -1,  77, 047, 047, BCD48},

    {holl_z11,   holl_d8,    'Q',    'Q',  -1,  78, 050, 050, BCD48},

    {holl_z11,   holl_d9,    'R',    'R',  -1,  79, 051, 051, BCD48},

    {holl_z0,    holl_d1,    '/',    '/',  -1,  31, 061, 021, A48+F48+H48},

    {holl_z0,    holl_d2,    'S',    'S',  -1,  82, 062, 022, BCD48},

    {holl_z0,    holl_d3,    'T',    'T',  -1,  83, 063, 023, BCD48},

    {holl_z0,    holl_d4,    'U',    'U',  -1,  84, 064, 024, BCD48},

    {holl_z0,    holl_d5,    'V',    'V',  -1,  85, 065, 025, BCD48},

    {holl_z0,    holl_d6,    'W',    'W',  -1,  86, 066, 026, BCD48},

    {holl_z0,    holl_d7,    'X',    'X',  -1,  87, 067, 027, BCD48},

    {holl_z0,    holl_d8,    'Y',    'Y',  -1,  88, 070, 030, BCD48},

    {holl_z0,    holl_d9,    'Z',    'Z',  -1,  89, 071, 031, BCD48},

    {holl_z12,   holl_dnone, '&',    '&',  -1,  20, 020, 060, A48},

    {holl_z12,   holl_dnone, '+',    '+',  -1,  20, 020, 060, F48+H48},

    {holl_z12,   holl_d8_3,  '.',    '.',  -1,  18, 033, 073, A48+F48+H48},

    {holl_z12,   holl_d8_4, L'⌑',    '^', 'L',  19, 034, 074, A48},    // unicode 'square lozenge'

    {holl_z12,   holl_d8_4,  ')',    ')',  -1,  19, 034, 074, F48+H48},

    {holl_z12,   holl_d8_5,  '[',    '[',  -1,  -1, 035, 075, BCD64},

    {holl_z12,   holl_d8_6,  '<',    '<',  -1,  -1, 036, 076, BCD64},

    {holl_z12,   holl_d8_7,L'\uF000', -1, 'G',  -1, 037, 077, BCD64},  // group mark, use uF000 for triple dagger

    {holl_z11,   holl_dnone, '-',    '-',  -1,  30, 040, 040, A48+F48+H48},

    {holl_z11,   holl_d8_3,  '$',    '$',  -1,  28, 053, 053, A48+F48+H48},

    {holl_z11,   holl_d8_4,  '*',    '*',  -1,  29, 054, 054, A48+F48+H48},

    {holl_z11,   holl_d8_5,  ']',    ']',  -1,  29, 055, 055, BCD64},

    {holl_z11,   holl_d8_6,  ';',    ';',  -1,  29, 056, 056, BCD64},

    {holl_z11,   holl_d8_7,L'\uF004', -1, 'D',  29, 057, 057, BCD64},  // delta -> unicode uppercase delta

    {holl_z0,    holl_d8_2, L'‡',     -1, 'R',  -1, 073, 033, BCD64},  // record mark -> double dagger

    {holl_z0,    holl_d8_3,  ',',    ',',  -1,  38, 073, 033, A48+F48+H48},

    {holl_z0,    holl_d8_4,  '%',    '%',  -1,  39, 074, 034, A48},

    {holl_z0,    holl_d8_4,  '(',    '(',  -1,  39, 074, 034, F48+H48},

    {holl_z0,    holl_d8_5,L'\u2423', -1, 'W',  -1, 075, 035, BCD64},  // word separator -> open box

    {holl_z0,    holl_d8_6, '\\',    '\\', -1,  -1, 076, 036, BCD64},  // left oblique

    {holl_z0,    holl_d8_7,L'\u29FB', -1, 'S',  -1, 077, 037, BCD64},  // segment mark -> triple plus

    {holl_znone, holl_d8_2,L'\u2422',' ', ' ',  -1, 060, 020, BCD64},  // alternate blank

    {holl_znone, holl_d8_3,  '#',    '#',  -1,  48, 013, 013, A48},

    {holl_znone, holl_d8_3,  '=',    '=',  -1,  48, 013, 013, F48+H48},

    {holl_znone, holl_d8_4,  '@',    '@',  -1,  49, 014, 014, A48},

    {holl_znone, holl_d8_4,  '-',    '-',  -1,  49, 014, 014, F48},    // FORTRAN's other minus

    {holl_znone, holl_d8_4,  '\'',   '\'', -1,  49, 014, 014, H48},

    {holl_znone, holl_d8_5,  ':',    ':',  -1,  -1, 015, 015, BCD64},  // colon

    {holl_znone, holl_d8_6,  '>',    '>',  -1,  -1, 016, 016, BCD64},  // greater than

    {holl_znone, holl_d8_7, L'√',     -1, 'T',  -1, 017, 017, BCD64}   // radical

};

static uint16_t make_holl(int z, int d)

{

    uint16_t h = 0;

    switch (z) {

        case holl_znone:

            break;

        case holl_z0:

            h += (1 << 9);

            break;

        case holl_z11:

            h += (1 << 10);

            break;

        case holl_z12:

            h += (1 << 11);

            break;

        default:

            break;

    }

    switch (d) {

        case holl_dnone:

            break;

        case holl_d0:

            h += (1 << 9);

            break;

        case holl_d1:

            h += (1 << 8);

            break;

        case holl_d2:

            h += (1 << 7);

            break;

        case holl_d3:

            h += (1 << 6);

            break;

        case holl_d4:

            h += (1 << 5);

            break;

        case holl_d5:

            h += (1 << 4);

            break;

        case holl_d6:

            h += (1 << 3);

            break;

        case holl_d7:

            h += (1 << 2);

            break;

        case holl_d8:

            h += (1 << 1);

            break;

        case holl_d9:

            h += (1 << 0);

            break;

        case holl_d8_2:

            h += (1 << 1) + (1 << 7);

            break;

        case holl_d8_3:

            h += (1 << 1) + (1 << 6);

            break;

        case holl_d8_4:

            h += (1 << 1) + (1 << 5);

            break;

        case holl_d8_5:

            h += (1 << 1) + (1 << 4);

            break;

        case holl_d8_6:

            h += (1 << 1) + (1 << 3);

            break;

        case holl_d8_7:

            h += (1 << 1) + (1 << 2);

            break;

        default:

            break;

    }

    return h;

}

void ibm_codec::setup_tables(int c) {

    hollerith_to_code650_.resize(4096);

    code650_to_hollerith_.resize(100);

    hollerith_to_unicode_.resize(4096);

    unicode_to_hollerith_.resize(65536);

    hollerith_to_ascii_  .resize(4096);

    ascii_to_hollerith_  .resize(256);

    ascii_to_code650_    .resize(256);

    code650_to_ascii_    .resize(100);

    keycode_to_unicode_  .resize(256);

    // mark all translations invalid (-1)

    for (int i = 0; i < 65536; i++) {

        unicode_to_hollerith_[i] = -1;

        if (i < 4096) {

            hollerith_to_code650_[i] = -1;

            hollerith_to_unicode_[i] = -1;

            hollerith_to_ascii_[i]   = -1;

        }

        if (i < 256) {

            ascii_to_code650_[i]     = -1;

            ascii_to_hollerith_[i]   = -1;

            keycode_to_unicode_[i]   = -1;

        }

        if (i < 100) {

            code650_to_hollerith_[i] = -1;

            code650_to_ascii_[i]     = -1;

        }

    }

    // Fill in glyphs from table that are in the specified codeset(s).

    // When multiple glyphs map to the same codepoint, the first

    // glyph encoutered in the table occupying a codepoint takes

    // precedence.

    for (auto glyph : glyph_codes) {

        if (!(glyph.codeset & c)) continue;

        uint16_t hcode = make_holl(glyph.zone, glyph.digit);

        if (hollerith_to_code650_[hcode] < 0)

            hollerith_to_code650_[hcode] = glyph.code650;

        if (code650_to_hollerith_[glyph.code650] < 0)

            code650_to_hollerith_[glyph.code650] = hcode;

        if (hollerith_to_unicode_[hcode] < 0)

            hollerith_to_unicode_[hcode] = glyph.unicode;

        if (unicode_to_hollerith_[glyph.unicode] < 0)

            unicode_to_hollerith_[glyph.unicode] = hcode;

        if (keycode_to_unicode_[glyph.keycode] < 0)

            keycode_to_unicode_[glyph.keycode] = glyph.unicode;

        if (hollerith_to_ascii_[hcode] < 0)

            hollerith_to_ascii_[hcode] = glyph.ascii;

        if (ascii_to_hollerith_[glyph.ascii] < 0)

            ascii_to_hollerith_[glyph.ascii] = hcode;

        if (ascii_to_code650_[glyph.ascii] < 0)

            ascii_to_code650_[glyph.ascii] = glyph.code650;

        if (code650_to_ascii_[glyph.code650] < 0)

            code650_to_ascii_[glyph.code650] = glyph.ascii;

    }

}