simh-testsetgenerator/Ibm1130/utils/punches.c

/*
 * punches - convert beteen IBM1130 simulator binary card image format and ascii text lists of punch numbers
 *
 * Usage:
 *      punches -b [infile [outfile]]
 *          Converts from ascii to binary. Reads stdin/writes stdout if infile/outfile not specified
 *
 *      punches -a [infile [outfile]]
 *          Converts from binary to ascii.
 *
 * The ASCII format consists of an arbitrary number of card images. Each card image consists of
 * a line with the word "start", followed by 80 lines each containing the punch data for one card
 * column, followe by a line with the word "end".
 *
 * A column specification line consists of the word "blank", for a column with no punches,
 * or an arbitrary number of integer row names separated by hyphens. The row names are 12, 11, 0, 1, 2, ..., 9.
 *
 * The character #, * or ; terminates an input line and the remainder of the line is ignored as a comment.
 * Blank lines are ignored and may occur at any place in the input file.
 *
 * A typical card specification might look like this:
 
   start
   * This is a comment line
   12-1-2
   blank
   5         # this is a comment after the data for column 3
   4
   2
   blank
   blank
   11-5
   2-6-3
.                     \
.                      | not all lines shown. Exactly 80 data lines are required
.                     /
blank
12-0-2-6-7-8
end

 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "util_io.h"
#ifdef WIN32                    // for Windows binary file mode setting
#  include <io.h>
#  include <fcntl.h>
#endif

#define TRUE  1
#define FALSE 0
typedef int BOOL;

#define BETWEEN(v,a,b) (((v) >= (a)) && ((v) <= (b)))

BOOL failed = FALSE;
int ncards = 0;

void tobinary (char *fnin, char *fnout);
void toascii (char *fnin, char *fnout);
void bail (char *msg);

int main (int argc, char **argv)
{
    enum {MODE_UNKNOWN, MODE_TOBINARY, MODE_TOASCII} mode = MODE_UNKNOWN;
    int i;
    char *arg, *fnin = NULL, *fnout = NULL;
    static char usestr[] = "Usage: punches -b|-a [infile [outfile]]";

    for (i = 1; i < argc; i++) {
        arg = argv[i];
        if (*arg == '-') {
            arg++;
            while (*arg) {
                switch (*arg++) {
                    case 'b':
                        mode = MODE_TOBINARY;
                        break;

                    case 'a':
                        mode = MODE_TOASCII;
                        break;

                    default:
                        bail(usestr);
                }
            }
        }
        else if (fnin == NULL)
            fnin = arg;
        else if (fnout == NULL)
            fnout = arg;
        else
            bail(usestr);
    }

    util_io_init();                             // check CPU for big/little endianness

    if (mode == MODE_TOBINARY)
        tobinary(fnin, fnout);
    else if (mode == MODE_TOASCII)
        toascii(fnin, fnout);
    else
        bail(usestr);

    if (failed) {
        if (fnin != NULL) {                     // if there was an error, delete output file if possible
            unlink(fnout);
            fprintf(stderr, "Output file \"%s\" deleted\n", fnout);
            exit(1);
        }
        else
            bail("Output file is incorrect");
    }
    else                                        // if no error, tell how many cards we converted
        fprintf(stderr, "* %d card%s converted\n", ncards, (ncards == 1) ? "" : "s");

    return 0;
}

// alltrim - remove string's leading and trailing whitespace

char *alltrim (char *str)
{
    char *c, *e;

    for (c = str; *c && *c <= ' '; c++)         // skip over leading whitespace
        ;

    if (c > str)                                // if there was some, copy string down over it
        strcpy(str, c);

    for (e = str-1, c = str; *c; c++)           // find last non-white character
        if (*c > ' ')
            e = c;

    e[1] = '\0';                                // terminate string immediately after last nonwhite character
    return str;                                 // return pointer to string
}

void tobinary (char *fnin, char *fnout)
{
    FILE *fin, *fout;
    BOOL gotnum;
    int col, v, lineno = 0;
    char str[256], *c;
    unsigned short buf[80], punches;
    static unsigned short punchval[13] = {
        0x2000, 0x1000, 0x0800, 0x0400, 0x0200,         // 0, 1, 2, 3, 4
        0x0100, 0x0080, 0x0040, 0x0020, 0x0010,         // 5, 6, 7, 8, 9
        0x0000,                                         // there is no 10 punch
        0x4000, 0x8000};                                // 11 and 12.

    if (fnin == NULL) {
        fin = stdin;
    }
    else if ((fin = fopen(fnin, "r")) == NULL) {
        perror(fnin);
        exit(1);
    }

    if (fnout == NULL) {
        fout = stdout;
#ifdef WIN32
        _setmode(_fileno(stdout), _O_BINARY);
#endif
    }
    else if ((fout = fopen(fnout, "wb")) == NULL) {
        perror(fnout);
        exit(1);
    }

    col = 0;                                        // we are starting between cards, expect start as first data line

    while (fgets(str, sizeof(str), fin) != NULL && ! failed) {
        alltrim(str);                               // trim leading/trailing blanks (including newline)
        lineno++;                                   // count input line

        if (*str == ';' || *str == '#'|| *str == '*' || ! *str)
            continue;                               // ignore comment or blank line

        if (strnicmp(str, "start", 5) == 0) {       // start marks new card, proceed to column 1 (strnicmp so trailing comment is ignored)
            if (col == 0)
                col = 1;
            else {
                fprintf(stderr, "\"start\" encountered where column %d was expected, at line %d\n", lineno);
                failed = TRUE;
            }
        }
        else if (strnicmp(str, "end", 3) == 0) {    // end is expected as 81'st data line
            if (col == 81) {
                fxwrite(buf, 2, 80, fout);          // write binary card image to output file
                ncards++;                           // increment card count
                col = 0;                            // reset, expect start next
            }
            else {
                fprintf(stderr, "\"end\" encountered where ");

                if (col == 0)
                    fprintf(stderr, "\"start\"");
                else
                    fprintf(stderr, "column %d", col);

                fprintf(stderr, " was expected, at line %d\n", lineno);
                failed = TRUE;
            }
        }
        else if (BETWEEN(col, 1, 80)) {             // for column 1 to 80, we expect a data line
            if (strnicmp(str, "blank", 5) == 0) {   // blank indicates an unpunched column
                buf[col-1] = 0;
                col++;
            }
            else {
                punches = 0;                        // prepare to parse a data line. Punches is output binary value for column

                v = 0;                              // v is current punch number
                gotnum = FALSE;                     // gotnum indicates we've seen a punch number

                for (c = str; ! failed; c++) {
                    if (BETWEEN(*c, '0', '9')) {    // this is a digit, accumulate into current punch number
                        v = v*10 + *c - '0';
                        gotnum = TRUE;              // note that we've seen a value
                    }
                    else if (*c == '-' || *c == '\0') {                 // at - separator or at end of string
                        if (gotnum && BETWEEN(v, 0, 12) && v != 10)
                            punches |= punchval[v];                     // add correct bit to column binary value
                        else {                                          // error if number not seen or punch number not 0..9, 11, or 12
                            fprintf(stderr, "Invalid punch value %d at line %d\n", v, lineno);
                            failed = TRUE;
                            break;
                        }

                        if (*c == '\0') {           // at end of string store value and advance column count
                            buf[col-1] = punches;
                            col++;
                            break;
                        }
                        else {
                            v = 0;                  // at separator, reset for next punch value
                            gotnum = FALSE;
                        }
                    }
                    else if (*c == '#' || *c == ';' || *c == '*') {
                        break;                      // terminate line parsing at comment character
                    }
                    else {                          // invalid character
                        fprintf(stderr, "Unexpected character '%c' at line %d\n", *c, lineno);
                        failed = TRUE;
                        break;
                    }
                }
            }
        }
        else {                                      // we expected start or end when not expecting column data
            fprintf(stderr, "\"%s\" encountered where \"%s\" was expected, at line %d\n", str,
                (col == 0) ? "start" : "end", lineno);
            failed = TRUE;
        }
    }

    fclose(fin);
    fclose(fout);
}

void toascii (char *fnin, char *fnout)
{
    FILE *fin, *fout;
    unsigned short buf[80], mask;
    int nread, col, row;
    BOOL first;
    static char *punchname[] = {"12", "11", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9"};

    if (fnin == NULL) {
        fin = stdin;                                    // no input file named, read from stdin
#ifdef WIN32
        _setmode(_fileno(stdin), _O_BINARY);            // (on Windows, must set binary mode)
#endif
    }
    else if ((fin = fopen(fnin, "rb")) == NULL) {       // open named input file
        perror(fnin);
        exit(1);
    }

    if (fnout == NULL) {                                // no output file named, write to stdout
        fout = stdout;
    }
    else if ((fout = fopen(fnout, "wb")) == NULL) {     // open named output file
        perror(fnout);
        exit(1);
    }
                                                        // write comment with input file name
    fprintf(fout, "* converted from %s\n", (fnin == NULL) ? "<stdin>" : fnin);

    while ((nread = fxread(buf, 2, 80, fin)) == 80) {   // pull cards from binary file
        ncards++;                                       // increment card count
        fprintf(fout, "**** card %d\nstart\n", ncards); // write comment with card number and start statement

        for (col = 0; col < 80; col++) {                // dump 80 columns
            if (buf[col] == 0) {
                fprintf(fout, "blank\n");               // no punches this column
            }
            else if (buf[col] & 0x000F) {               // if low bits are set it is not a valid IBM1130 card image
                fprintf(stderr, "Input file is not an IBM 1130 card image, low bits set found at card image %d\n", ncards);
                failed = TRUE;
                break;
            }
            else {
                first = TRUE;                           // scan the 12 punch bits
                for (mask = 0x8000, row = 0; row < 12; row++, mask >>= 1) {
                    if (buf[col] & mask) {              // output name of punch row for each bit set (12, 10, 0, ..., 9)
                        fprintf(fout, "%s%s", first ? "" : "-", punchname[row]);
                        first = FALSE;                  // next punch will need a hyphen
                    }
                }
                putc('\n', fout);
            }
        }

        fprintf(fout, "end\n");
    }

    if (nread != 0) {                           // oops, file wasn't a multiple of 160 bytes in length
        fprintf(stderr, "Input file invalid or contained a partial card image\n");
        failed = TRUE;
    }

    fclose(fin);
    fclose(fout);
}

void bail (char *msg)
{
    fprintf(stderr, "%s\n", msg);
    exit(1);
}