*** empty log message ***

[h316.git] / pc-tools / ldc / ldc.c

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <stdarg.h>
#include <sys/select.h>
#include "hw_types.h"
#include "hw_helpers.h"
#define XON 0x11
#define XOFF 0x13
#define CHAR_START 0x81
// 0x93
#define CHAR_END1 0223
#define CHAR_END2 0223
#define CHAR_END3 0223
#define MAX_BLOCK_SIZE 500

//#define DEBUG
//#define DEBUG_CHECKSUM
//#define DEBUG_STRUCTURE
//#define IGNORE_CHECKSUM
#define HARDCORE_DEBUG
/********************************************************/
void output (char *string, int length);
datablock *get_block ();

/********************************************************/
char ends[3] = { CHAR_END1, CHAR_END2, CHAR_END3 };
int errflag = 0;		// Global error flag
int tapemode = 0;
int inputfd;
int ignore = 0;
int dosplit = 0;
int splitnum = 0;
int silent = 0;
/********************************************************/


/********************************************************/
void dump_data (void *data, int count)
{
    int fd = open ("dump", O_RDWR | O_CREAT | O_APPEND, 0666);
    write (fd, "***", 3);
    write (fd, data, count);
    close (fd);
}

/********************************************************/
void endwarn (int ret)
{
    if (ret < 1) {
	err ("Unexpected problem in input");
	exit (3);
    }
}

/********************************************************/
/* Small output things */
void err (char *string)
{
    printf ("Error: -->  %s\n", string);
    errflag++;
}

void msg (char *string)
{
#ifdef DEBUG
    printf ("**  %s\n", string);
#endif
}

void msgf (char *format, ...)
{
    va_list ag;
    va_start (ag, format);
    char ms[100];
    vsprintf (ms, format, ag);
    msg (ms);
    va_end (ag);
}

void errf (char *format, ...)
{
    va_list ag;
    va_start (ag, format);
    char ms[100];
    vsprintf (ms, format, ag);
    err (ms);
    va_end (ag);
}

void say (char *string)
{
    if (!silent) printf ("%s\n", string);
}

void sayf (char *format, ...)
{
    va_list ag;
    va_start (ag, format);
    char ms[100];
    vsprintf (ms, format, ag);
    say (ms);
    va_end (ag);
}


/********************************************************/
/********************************************************/

/********************************************************/
/*Block input routines*/

unsigned char decode (unsigned char in)
{
    if (in & 64)
	switch (in) {
	case 0174:
	    return 05;
	    break;
	case 0374:
	    return 045;
	    break;
	case 0175:
	    return 012;
	    break;
	case 0375:
	    return 052;
	    break;
	case 0176:
	    return 021;
	    break;
	case 0376:
	    return 061;
	    break;
	case 0177:
	    return 023;
	    break;
	case 0377:
	    return 063;
	    break;
	default:
	    err ("decode(): Impossible case!!!\n");
	    return 0;
	    break;
    } else {
	if (in & 128)
	    in |= 32;
	return in;
    }

    return 0;
}

/********************************************************/
/********************************************************/

void combine466 (unsigned char *raw, unsigned char *data)
{
    hw16 *result = (hw16 *) data;

//    result->tape.low = 077;
    unsigned char r1, r2, r3;

    r1 = decode ((raw)[0]) & 017;
    r2 = decode ((raw)[1]) & 077;
    r3 = decode ((raw)[2]) & 077;

    result->tape.high = r1;
    result->tape.mid = r2;
    result->tape.low = r3;

#ifdef DEBUG_COMBINE
    msgf ("combine466 (data)     : %s%s%s", bin2str (r1, 4), bin2str (r2, 6),
	  bin2str (r3, 6));
    msgf ("combine466 (rawmem)   : %s%s", bin2str (data[1], 8),
	  bin2str (data[0], 8));
    msgf ("combine466 (structure): %s", bin2str (result->value, 16));
#endif
}

/*********************************************************************/
/*********************************************************************/
int checksum_error (hw16 * data, int size)
{
    unsigned short int checksumme = 0;
    int c;
    for (c = 0; c < (size - 1); c++) {
	checksumme ^= data[c].value;
#ifdef DEBUG_CHECKSUM
	msgf ("checksum_error(): Gelesen:%04x   Berechnet:%04x",
	      data[c + 1].value, checksumme);
	if (data[c + 1].value == checksumme)
	    msg ("checksum_error (): Treffer.");
#endif
    }
#ifdef DEBUG_CHECKSUM
    msgf ("checksum_error(): Gelesen:%04x   Berechnet:%04x",
	  data[size - 1].value, checksumme);
#endif
    if (data[size - 1].value != checksumme)
	return 1;
    return 0;
}

/********************************************************/
datablock *get_block()
{
    int blk_size, round, ret, found, complete;
    unsigned char buffer[3];
    hw16 *blk_data;
    unsigned char *raw_data;

    if (tapemode)
	tapestart ();
    do {
	ret = read (inputfd, buffer, 1);
#ifdef HARDCORE_DEBUG
	msgf ("READ          : (hex)%02x   (bin)%s    (dec)%3i      (oct)%3o",
	      buffer[0], bin2str (buffer[0], 8), buffer[0], buffer[0]);
#endif
	if (ret < 1) {
	    msg ("get_block(): Nichts mehr zu lesen");
	    return NULL;
	}
    
	if (buffer[0]==0x83){
		datablock *result = (datablock *) malloc (sizeof (datablock));
	        result->type     = BT_STOP;
		result->data     = NULL;
		result->raw_data = NULL;
	        result->size     = 0;
		return result;
	}
        
    } while (*buffer != (unsigned char) CHAR_START);

    msg ("get_block(): Blockstart erkannt");

//    blk_data = (hw16 *) malloc (MAX_BLOCK_SIZE * sizeof (hw16));
    blk_data=NULL;
    raw_data=NULL;
    round = 0;
    blk_size = 0;

    do {
	complete = 0;
	ret = read (inputfd, buffer + round, 1);
#ifdef HARDCORE_DEBUG
	static int lochzahl = 0;
	char *bin = bin2str (buffer[round], 8);
	int a;
	for (a = 0; a < 8; a++)
	    if (bin[a] == '1')
		lochzahl++;
	msgf ("READ (round %i): (hex)%02x   (bin)%s    (dec)%3i     " 
	      " (oct)%3o    Lochzahl:%4i", 
	      round, buffer[round], bin, buffer[round], buffer[round], lochzahl);

//      msgf ("READ(round %i) (hex)%02x", round, buffer[round]);
#endif
	endwarn (ret);
	round++;
	found = 0;
	if (buffer[round - 1] == CHAR_END1)
	    found++;
	if (buffer[round - 1] == CHAR_END2)
	    found++;

	if (found) {
	    complete++;
	} else {
	    if (round == 3) {
		//if (blk_size == MAX_BLOCK_SIZE) {