[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 DEBUG_COMBINE
//#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;
int read_pos = -5;
int block_pos= -5;
/********************************************************/


/********************************************************/
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)     : %02x %02x %02x",r1,r2,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 {
	read_pos+=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);
    
    block_pos=read_pos;
    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);
	read_pos+=ret;
#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) {
Commit	Line	Data
437b3ba8	1	#include <stdio.h>
	2	#include <unistd.h>
	3	#include <stdlib.h>
	4	#include <fcntl.h>
	5	#include <stdarg.h>
	6	#include <sys/select.h>
	7	#include "hw_types.h"
	8	#include "hw_helpers.h"
	9	#define XON 0x11
	10	#define XOFF 0x13
	11	#define CHAR_START 0x81
	12	// 0x93
	13	#define CHAR_END1 0223
	14	#define CHAR_END2 0223
	15	#define CHAR_END3 0223
	16	#define MAX_BLOCK_SIZE 500
	17
	18	//#define DEBUG
036c9298	19	#define DEBUG_CHECKSUM
	20	#define DEBUG_STRUCTURE
	21	#define DEBUG_COMBINE
437b3ba8	22	//#define IGNORE_CHECKSUM
	23	#define HARDCORE_DEBUG
	24	/********************************************************/
	25	void output (char *string, int length);
	26	datablock *get_block ();
	27
	28	/********************************************************/
	29	char ends[3] = { CHAR_END1, CHAR_END2, CHAR_END3 };
	30	int errflag = 0; // Global error flag
	31	int tapemode = 0;
	32	int inputfd;
	33	int ignore = 0;
	34	int dosplit = 0;
	35	int splitnum = 0;
77ce3d6a	36	int silent = 0;
0413f345	37	int read_pos = -5;
0413f345	38	int block_pos= -5;
437b3ba8	39	/********************************************************/
	40
	41
	42	/********************************************************/
	43	void dump_data (void *data, int count)
	44	{
	45	int fd = open ("dump", O_RDWR \| O_CREAT \| O_APPEND, 0666);
	46	write (fd, "***", 3);
	47	write (fd, data, count);
	48	close (fd);
	49	}
	50
	51	/********************************************************/
	52	void endwarn (int ret)
	53	{
	54	if (ret < 1) {
	55	err ("Unexpected problem in input");
	56	exit (3);
	57	}
	58	}
	59
	60	/********************************************************/
	61	/* Small output things */
	62	void err (char *string)
	63	{
	64	printf ("Error: --> %s\n", string);
	65	errflag++;
	66	}
	67
	68	void msg (char *string)
	69	{
	70	#ifdef DEBUG
	71	printf ("** %s\n", string);
	72	#endif
	73	}
	74
	75	void msgf (char *format, ...)
	76	{
	77	va_list ag;
	78	va_start (ag, format);
	79	char ms[100];
	80	vsprintf (ms, format, ag);
	81	msg (ms);
	82	va_end (ag);
	83	}
	84
	85	void errf (char *format, ...)
	86	{
	87	va_list ag;
	88	va_start (ag, format);
	89	char ms[100];
	90	vsprintf (ms, format, ag);
	91	err (ms);
	92	va_end (ag);
	93	}
	94
	95	void say (char *string)
	96	{
77ce3d6a	97	if (!silent) printf ("%s\n", string);
437b3ba8	98	}
	99
	100	void sayf (char *format, ...)
	101	{
	102	va_list ag;
	103	va_start (ag, format);
	104	char ms[100];
	105	vsprintf (ms, format, ag);
	106	say (ms);
	107	va_end (ag);
	108	}
	109
	110
	111	/********************************************************/
	112	/********************************************************/
	113
	114	/********************************************************/
	115	/Block input routines/
	116
	117	unsigned char decode (unsigned char in)
	118	{
	119	if (in & 64)
	120	switch (in) {
	121	case 0174:
	122	return 05;
	123	break;
	124	case 0374:
	125	return 045;
	126	break;
	127	case 0175:
	128	return 012;
	129	break;
	130	case 0375:
	131	return 052;
	132	break;
	133	case 0176:
	134	return 021;
	135	break;
	136	case 0376:
	137	return 061;
	138	break;
	139	case 0177:
	140	return 023;
	141	break;
	142	case 0377:
	143	return 063;
	144	break;
	145	default:
	146	err ("decode(): Impossible case!!!\n");
	147	return 0;
	148	break;
	149	} else {
	150	if (in & 128)
	151	in \|= 32;
	152	return in;
	153	}
	154
	155	return 0;
	156	}
	157
	158	/********************************************************/
	159	/********************************************************/
	160
	161	void combine466 (unsigned char raw, unsigned char data)
162	{
163	hw16 result = (hw16 ) data;
164
165	// result->tape.low = 077;
166	unsigned char r1, r2, r3;
167
168	r1 = decode ((raw)[0]) & 017;
169	r2 = decode ((raw)[1]) & 077;
170	r3 = decode ((raw)[2]) & 077;
171
172	result->tape.high = r1;
173	result->tape.mid = r2;
174	result->tape.low = r3;
175
176	#ifdef DEBUG_COMBINE
036c9298	177	msgf ("combine466 (data) : %02x %02x %02x",r1,r2,r3, 6);
	178	// msgf ("combine466 (rawmem) : %s%s", bin2str (data[1], 8),
	179	// bin2str (data[0], 8));
437b3ba8	180	msgf ("combine466 (structure): %s", bin2str (result->value, 16));
	181	#endif
	182	}
	183
	184	/*********************************************************************/
	185	/*********************************************************************/
	186	int checksum_error (hw16 * data, int size)
	187	{
	188	unsigned short int checksumme = 0;
	189	int c;
	190	for (c = 0; c < (size - 1); c++) {
	191	checksumme ^= data[c].value;
	192	#ifdef DEBUG_CHECKSUM
	193	msgf ("checksum_error(): Gelesen:%04x Berechnet:%04x",
	194	data[c + 1].value, checksumme);
	195	if (data[c + 1].value == checksumme)
	196	msg ("checksum_error (): Treffer.");
	197	#endif
	198	}
	199	#ifdef DEBUG_CHECKSUM
	200	msgf ("checksum_error(): Gelesen:%04x Berechnet:%04x",
	201	data[size - 1].value, checksumme);
	202	#endif
	203	if (data[size - 1].value != checksumme)
	204	return 1;
	205	return 0;
	206	}
	207
	208	/********************************************************/
	209	datablock *get_block()
	210	{
	211	int blk_size, round, ret, found, complete;
	212	unsigned char buffer[3];
	213	hw16 *blk_data;
	214	unsigned char *raw_data;
	215
	216	if (tapemode)
	217	tapestart ();
	218	do {
0413f345	219	read_pos+=ret=read (inputfd, buffer, 1);
0413f345	220
437b3ba8	221	#ifdef HARDCORE_DEBUG
	222	msgf ("READ : (hex)%02x (bin)%s (dec)%3i (oct)%3o",
	223	buffer[0], bin2str (buffer[0], 8), buffer[0], buffer[0]);
	224	#endif
	225	if (ret < 1) {
	226	msg ("get_block(): Nichts mehr zu lesen");
	227	return NULL;
	228	}
	229
	230	if (buffer[0]==0x83){
	231	datablock result = (datablock ) malloc (sizeof (datablock));
	232	result->type = BT_STOP;
	233	result->data = NULL;
	234	result->raw_data = NULL;
	235	result->size = 0;
	236	return result;
	237	}
	238
	239	} while (*buffer != (unsigned char) CHAR_START);
0413f345	240
0413f345	241	block_pos=read_pos;
437b3ba8	242	msg ("get_block(): Blockstart erkannt");
	243
	244	// blk_data = (hw16 ) malloc (MAX_BLOCK_SIZE sizeof (hw16));
	245	blk_data=NULL;
	246	raw_data=NULL;
	247	round = 0;
	248	blk_size = 0;
	249
	250	do {
	251	complete = 0;
	252	ret = read (inputfd, buffer + round, 1);
0413f345	253	read_pos+=ret;
437b3ba8	254	#ifdef HARDCORE_DEBUG
	255	static int lochzahl = 0;
	256	char *bin = bin2str (buffer[round], 8);
	257	int a;
	258	for (a = 0; a < 8; a++)
	259	if (bin[a] == '1')
	260	lochzahl++;
	261	msgf ("READ (round %i): (hex)%02x (bin)%s (dec)%3i "
	262	" (oct)%3o Lochzahl:%4i",
	263	round, buffer[round], bin, buffer[round], buffer[round], lochzahl);
	264
	265	// msgf ("READ(round %i) (hex)%02x", round, buffer[round]);
	266	#endif
	267	endwarn (ret);
	268	round++;
	269	found = 0;
	270	if (buffer[round - 1] == CHAR_END1)
	271	found++;
	272	if (buffer[round - 1] == CHAR_END2)
	273	found++;
	274
	275	if (found) {
	276	complete++;
	277	} else {
	278	if (round == 3) {
	279	//if (blk_size == MAX_BLOCK_SIZE) {
	280