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:
//
// Code translation tables for character codes used by early IBM data processing
// machines. An ibm_codec object translates codes for a specific codeset between
// Unicode or ASCII and a number of machine-specific codes.
//
// Hollerith code is a 12-bit code representing a column on an IBM punched card.
// The 12-bit column is split into zones and digits, a zero punch being both a
// zone and a digit. Zone punches are 12, 11, zero, and none, while digit
// punches are zero, 1, 2, ... 8, and 9. If all 12 rows of a card column are
// utilized, there are 1024 possible codes per column. In practice, codes
// were restricted to a single zone punch combined with one or two digit punches.
// For codes where two digit punches are used, one of those punches will be an 8.
// The zero punch may act as either a zone or digit: It is considered to be a
// digit when it appears alone or combined an 11 or 12 punch, otherwise it acts
// as a zone punch.
//
// Binary Coded Decimal (BCD) is a 6-bit code made up of a 2-bit zone code and a
// 4-bit digit code, providing up to 64 unique codes. Tape (the usual destination
// and source for BCD data) adds an additional parity bit. The bits comprising
// BCD characters were recorded on 1/2" magnetic tape in 7 parallel tracks.
//
// Due to its method of operation, a BCD character on tape may not consist of
// all zero bits. Automatic conversion is provided by the tape hardware between
// an even parity BCD zero (000) and a BCD 'substitute blank' (0020) character
// when writing to tape. Likewise, a substitute blank is converted to a BCD zero
// when reading a tape in even parity mode. Tapes written in odd parity mode
// suffer no such limitations because an odd parity BCD zero (0100) already has
// a bit set.
//
// Present in the BCD character set are codes that have special meaning to various
// hardware devices. Generally called marks, they serve to delineate character
// data in various ways. As used by IBM tape systems, the 'tape mark' character is
// used to delineate a file on tape. Tape hardware may search independently of the
// CPU for tape marks, accelerating certain types of tape processing.
//
// In even parity mode, the 704 tape hardware automatically modifies the BCD zone
// bits. This translation preserves the BCD collating sequence when character
// comparisons are performed by binary magnitude comparison.
//
// Collating sequence is an important property of any character set. An
// examination of BCD codes shows that simply sorting by the binary magnitude
// of the codes will not yield a useful collating sequence. Hardware or
// software methods are needed to sort this character set. The 701/704/709/709x
// family of machines translated BCD on its way to and from tape when operating
// in the even parity mode. Translation conisted of reassigning zones so that
// BCD alphabetic characters sorted naturally, but did not help with special
// characters. The 14xx machines incorporated complex hardware logic to compare
// BCD codes directly, resulting in what we consider to be the authoritative BCD
// collating sequence. See fig. 64 in A24-3116-0, "System Operation Reference
// Manual, IBM 1440 Data Processing System". The 1401 BCD compare logic can
// be found in system diagrams 44.30.11.2, 44.31.11.2, 44.32.11.2, 44.33.11.2,
// 44.34.11.2, 44.34.21.2, and 44.34.31.2.
//
// Early machines used modified card machines (ex. 407 for 704 printer) for unit
// record I/O, and so were limited to the 48 character BCD codeset supported by
// these machines.
//
//
// 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
//////////////////////////////////////////////////////////////////////////////////
 
#ifndef __ibm650_soap2__ibm_codec__
#define __ibm650_soap2__ibm_codec__
 
#include <stdint.h>
#include <vector>
 
// -------------------------------------------------------------------------------
// Selects the character code set. Selections may be combined, for example to
// select the FORTRAN 48 character BCD set, specify cs_bcd48+cs_bcd48_f.
// -------------------------------------------------------------------------------
enum ibm_codeset {
  cs_bcd48       = 0x00000001, // 36 letters and digits   BCD codeset
  cs_bcd48_a     = 0x00000002, // commercial 48 character BCD codeset
  cs_bcd48_f     = 0x00000004, // FORTRAN    48 character BCD codeset
  cs_bcd48_h     = 0x00000008, // scientific 48 character BCD codeset
  cs_bcd64       = 0x00000010  // 64 character            BCD codeset
};
 
// -------------------------------------------------------------------------------
// Binary Hollerith punch codes.
// -------------------------------------------------------------------------------
enum {
  holl_12_punch = (1 << 11),
  holl_11_punch = (1 << 10),
  holl_0_punch  = (1 << 9),
  holl_1_punch  = (1 << 8),
  holl_2_punch  = (1 << 7),
  holl_3_punch  = (1 << 6),
  holl_4_punch  = (1 << 5),
  holl_5_punch  = (1 << 4),
  holl_6_punch  = (1 << 3),
  holl_7_punch  = (1 << 2),
  holl_8_punch  = (1 << 1),
  holl_9_punch  = (1 << 0)
};
 
// -------------------------------------------------------------------------------
// Class ibm_codec.
// -------------------------------------------------------------------------------
class ibm_codec {
  std::vector<int8_t>  hollerith_to_code650_;
  std::vector<int16_t> code650_to_hollerith_;
  std::vector<int32_t> hollerith_to_unicode_;
  std::vector<int16_t> unicode_to_hollerith_;
  std::vector<int32_t> keycode_to_unicode_;
  std::vector<int16_t> hollerith_to_ascii_;
  std::vector<int16_t> ascii_to_hollerith_;
  std::vector<int8_t>  ascii_to_code650_;
  std::vector<int16_t> code650_to_ascii_;
  void setup_tables(int);
 
public:
  static inline int clamp_650(int v) {
    return (v < 0) ? 0 : (v > 99) ? 99 : v;
  }
  static inline int clamp_hollerith(int v) {
    return (v < 0) ? 0 : (v > 4095) ? 4095 : v;
  }
  static inline int clamp_unicode(int v) {
    return (v < 0) ? 0 : (v > 65535) ? 65535 : v;
  }
  static inline int clamp_keycode(int v) {
    return (v < 0) ? 0 : (v > 255) ? 0 : v;
  }
  static inline int clamp_ascii(int v) {
    return (v < 0) ? 0 : (v > 255) ? 0 : v;
  }
  ibm_codec(int c)           { setup_tables(c); }
  void change_codeset(int c) { setup_tables(c); }
 
  inline bool valid_hollerith_for_650(int c) const {
    return code650_to_hollerith_[clamp_650(c)] >= 0;
  }
  inline uint16_t hollerith_to_unicode(int c) const {
    return clamp_unicode(hollerith_to_unicode_[clamp_hollerith(c)]);
  }
  inline bool valid_unicode_for_hollerith(int c) const {
    return hollerith_to_unicode_[clamp_hollerith(c)] >= 0;
  }
  inline uint16_t unicode_to_hollerith(int c) const {
    return clamp_hollerith(unicode_to_hollerith_[clamp_unicode(c)]);
  }
  inline bool valid_hollerith_for_unicode(int c) const {
    return unicode_to_hollerith_[clamp_unicode(c)] >= 0;
  }
  inline uint16_t keycode_to_unicode(int c) const {
    return keycode_to_unicode_[clamp_keycode(c)];
  }
  inline bool valid_unicode_for_keycode(int c) const {
    return keycode_to_unicode_[clamp_keycode(c)] >= 0;
  }
  inline uint16_t hollerith_to_ascii(int c) const {
    return clamp_unicode(hollerith_to_ascii_[clamp_hollerith(c)]);
  }
  inline uint16_t ascii_to_hollerith(int c) const {
    return clamp_hollerith(ascii_to_hollerith_[clamp_ascii(c)]);
  }
  inline bool valid_hollerith_for_ascii(int c) const {
    return ascii_to_hollerith_[clamp_ascii(c)] >= 0;
  }
  inline uint8_t ascii_to_code650(int c) const {
    return clamp_650(ascii_to_code650_[clamp_ascii(c)]);
  }
  inline bool valid_code650_for_ascii(int c) const {
    return ascii_to_code650_[clamp_ascii(c)] >= 0;
  }
  inline uint16_t code650_to_ascii(int c) const {
    return clamp_ascii(code650_to_ascii_[clamp_650(c)]);
  }
  inline bool valid_ascii_for_code650(int c) const {
    return code650_to_ascii_[clamp_650(c)] >= 0;
  }
};
 
#endif /* defined(__ibm650_soap2__ibm_codec__) */