[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;
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)     : %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 {
	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
	19	//#define DEBUG_CHECKSUM
	20	//#define DEBUG_STRUCTURE
	21	//#define IGNORE_CHECKSUM
	22	#define HARDCORE_DEBUG
	23	/********************************************************/
	24	void output (char *string, int length);
	25	datablock *get_block ();
	26
	27	/********************************************************/
	28	char ends[3] = { CHAR_END1, CHAR_END2, CHAR_END3 };
	29	int errflag = 0; // Global error flag
	30	int tapemode = 0;
	31	int inputfd;
	32	int ignore = 0;
	33	int dosplit = 0;
	34	int splitnum = 0;
77ce3d6a	35	int silent = 0;
0413f345	36	int read_pos = -5;
0413f345	37	int block_pos= -5;
437b3ba8	38	/********************************************************/
	39
	40
	41	/********************************************************/
	42	void dump_data (void *data, int count)
	43	{
	44	int fd = open ("dump", O_RDWR \| O_CREAT \| O_APPEND, 0666);
	45	write (fd, "***", 3);
	46	write (fd, data, count);
	47	close (fd);
	48	}
	49
	50	/********************************************************/
	51	void endwarn (int ret)
	52	{
	53	if (ret < 1) {
	54	err ("Unexpected problem in input");
	55	exit (3);
	56	}
	57	}
	58
	59	/********************************************************/
	60	/* Small output things */
	61	void err (char *string)
	62	{
	63	printf ("Error: --> %s\n", string);
	64	errflag++;
	65	}
	66
	67	void msg (char *string)
	68	{
	69	#ifdef DEBUG
	70	printf ("** %s\n", string);
	71	#endif
	72	}
	73
	74	void msgf (char *format, ...)
	75	{
	76	va_list ag;
	77	va_start (ag, format);
	78	char ms[100];
	79	vsprintf (ms, format, ag);
	80	msg (ms);
	81	va_end (ag);
	82	}
	83
	84	void errf (char *format, ...)
	85	{
	86	va_list ag;
	87	va_start (ag, format);
	88	char ms[100];
	89	vsprintf (ms, format, ag);
	90	err (ms);
	91	va_end (ag);
	92	}
	93
	94	void say (char *string)
	95	{
77ce3d6a	96	if (!silent) printf ("%s\n", string);
437b3ba8	97	}
	98
	99	void sayf (char *format, ...)
	100	{
	101	va_list ag;
	102	va_start (ag, format);
	103	char ms[100];
	104	vsprintf (ms, format, ag);
	105	say (ms);
	106	va_end (ag);
	107	}
	108
	109
	110	/********************************************************/
	111	/********************************************************/
	112
	113	/********************************************************/
	114	/Block input routines/
	115
	116	unsigned char decode (unsigned char in)
	117	{
	118	if (in & 64)
	119	switch (in) {
	120	case 0174:
	121	return 05;
	122	break;
	123	case 0374:
	124	return 045;
	125	break;
	126	case 0175:
	127	return 012;
	128	break;
	129	case 0375:
	130	return 052;
	131	break;
	132	case 0176:
	133	return 021;
	134	break;
	135	case 0376:
	136	return 061;
	137	break;
	138	case 0177:
	139	return 023;
	140	break;
	141	case 0377:
	142	return 063;
	143	break;
	144	default:
	145	err ("decode(): Impossible case!!!\n");
	146	return 0;
	147	break;
	148	} else {
	149	if (in & 128)
	150	in \|= 32;
	151	return in;
	152	}
	153
	154	return 0;
	155	}
	156
	157	/********************************************************/
	158	/********************************************************/
	159
	160	void combine466 (unsigned char raw, unsigned char data)
161	{
162	hw16 result = (hw16 ) data;
163
164	// result->tape.low = 077;
165	unsigned char r1, r2, r3;
166
167	r1 = decode ((raw)[0]) & 017;
168	r2 = decode ((raw)[1]) & 077;
169	r3 = decode ((raw)[2]) & 077;
170
171	result->tape.high = r1;
172	result->tape.mid = r2;
173	result->tape.low = r3;
174
175	#ifdef DEBUG_COMBINE
176	msgf ("combine466 (data) : %s%s%s", bin2str (r1, 4), bin2str (r2, 6),
177	bin2str (r3, 6));
178	msgf ("combine466 (rawmem) : %s%s", bin2str (data[1], 8),
179	bin2str (data[0], 8));
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