X-Git-Url: http://gitweb.hachti.de/?a=blobdiff_plain;f=pc-tools%2Fldc%2Fprocess.c;fp=pc-tools%2Fldc%2Fprocess.c;h=4e7a29d81f6668f503f47ef2490851ff736db411;hb=437b3ba835f66625031f4711cd0a963be67ccf5a;hp=0000000000000000000000000000000000000000;hpb=008a15c07914ebf7f69e6243c4d2754c8f959a7f;p=h316.git

diff --git a/pc-tools/ldc/process.c b/pc-tools/ldc/process.c
new file mode 100644
index 0000000..4e7a29d
--- /dev/null
+++ b/pc-tools/ldc/process.c
@@ -0,0 +1,338 @@
+#include <stdio.h>
+#include "hw_types.h"
+#include "hw_helpers.h"
+
+#include "process.h"
+
+//#define DEBUG_DATA
+/**********************************************************************/
+
+int get_blocktype (datablock * block){
+    return block->data[0].blocktype.type;
+}
+
+int get_blocksubtype(datablock * block){
+    if (block->data[0].blocktype.type!=0) return 0;
+    return block->data[0].blocktype.t0_subtype;
+}
+
+void block_copy(datablock* dest, datablock* src){
+    dest->data     = (hw16 *) malloc (src->size * sizeof (hw16));
+    dest->raw_data = (unsigned char *) malloc (src->size * 3 );
+    dest->size=src->size;
+    memcpy (dest->data, src->data, src->size * sizeof (hw16));
+    memcpy (dest->raw_data, src->raw_data, src->size * 3);
+
+}
+
+datablock * block_clone(datablock * orgblock){
+    datablock * block = (datablock *) malloc (sizeof (datablock));
+    block_copy(block,orgblock);
+    return block;
+}
+
+void block_dispose(datablock * victim){
+    free(victim->data);
+    free(victim->raw_data);
+    free(victim);
+}
+
+char ** extract_labels0(datablock * blockp){
+    char ** result=(char **) malloc (sizeof(char **));
+    result[0]==NULL;
+    if (get_blocktype(blockp)!=0) return NULL;
+            
+    datablock block;
+    block_copy(&block,blockp);
+    
+    hw16 * data = block.data;
+    int c;
+    parstrip ((char *)data +4, (block.size - 3) * 2);
+    twistbytes (data + 2, block.size - 3);
+    for (c = 0; c < (((head0*)data)->N - 3) / 3; c++) {
+	char akt[7];
+	memcpy (akt, ((char *) data) + 4 + c * 6, 6);
+	akt[6]=0;
+	
+	
+	int dd=5;
+	while (akt[dd]==' ') akt[dd--]=0; // hinten kürzen;
+	dd=0;
+	while (akt[dd]==' ') dd++;  // vorne kürzen;
+	char * aktres = malloc(strlen(akt+dd)+1);
+	strcpy (aktres,"      ");
+    	strncpy (aktres,akt+dd,strlen(akt+dd));
+	result=(char **)realloc(result, (c+1)* sizeof(char**));
+	result[c]=aktres;
+//	printf("akt: %s\n",result[c]);
+    }
+    result=(char **)realloc(result, (c+1)* sizeof(char**));
+    result[c]=NULL;
+    free(block.data);
+    free(block.raw_data);
+    return result;
+}
+
+void dispose_labels(char ** labels){
+    char * akt;
+    if (labels==NULL) return;
+    int c=0;
+    do {
+	free (labels[c++]);
+    } while (labels[c]!=NULL);
+    free (labels);
+}
+//***
+
+char * extract_label6(datablock * block){
+    datablock myblock;
+    block_copy(&myblock,block);
+    char * dat =(char *) myblock.data;
+    twistbytes (myblock.data + 1, 4);
+    parstrip (dat + 3, 6);
+    char *akt = malloc(7);
+    memcpy (akt, dat + 3, 6);
+    akt[6]=0;
+    free (myblock.data);
+    free (myblock.raw_data);
+    return akt;
+}
+
+
+//*****************
+void process_block (datablock * orgblock)
+{
+    if (orgblock->type==BT_STOP){
+	say("****************    ENDBLOCK    ****************");
+	return;
+    }
+    
+    if (orgblock->type!=BT_DATA) return;
+    
+    datablock block;
+    block_copy(&block, orgblock);
+
+    hw16 * data = block.data;
+
+    int type = get_blocktype(&block);
+    int subtype = get_blocksubtype(&block);
+
+    msg ("process_block(): Start");
+    msgf ("process_block(): Blocktyp: %o", type);
+    if (type == 0)
+	msgf ("process_block(): Subtyp (oct): %o",
+	      block.data[0].blocktype.t0_subtype);
+    switch (type) {
+    case 0:
+	{
+	    head0 *head = (head0 *) data;
+	    switch (subtype) {
+	    case 0:
+		{
+		    int c=0;
+		    char ** labels=extract_labels0(&block);
+		    do {
+			char * akt  = labels[c++];
+			if (c == 1)
+			    sayf ("%6s     (0-0)   subprogram name", akt);
+			else
+			    sayf ("%s     (0-0)       \"       \"", akt);
+		    } while (labels[c]!=NULL);
+		    dispose_labels(labels);
+		}
+		break;
+	    case 1:
+		say ("           (0-1)   non-load flag off");
+		break;
+	    case 2:
+		say ("           (0-2)   chain flag on");
+		break;
+	    case 3:
+		say ("           (0-3)   end of job");
+		break;
+	    case 4:
+		{
+		    say ("           (0-4)   data");
+
+#ifdef DEBUG_DATA_PLAIN
+		}
+		int words24 = (block.size - 4) * 2 / 3;
+		int c;
+		for (c = 3; c < (block.size - 1); c++) {
+		    msgf ("Datenwort(hex): %04x  Und (bin):%s", data[c].value,
+			  bin2str (data[c].value, 16));
+		}
+	    }
+#endif
+
+#ifdef DEBUG_DATA
+	    int words24 = (block.size - 4) * 2 / 3;
+	    msgf ("WORDS:%02i", words24);
+	    msgf ("BASE (oct):%06o", data[2].value);
+	    int c;
+	    twistbytes (data + 3, (block.size - 4));
+    	    for (c = 0; c < (words24); c++) {
+//		sayf("Nummer:%5i",c);
+		unsigned int dhigh = ((unsigned char *) data)[6 + 3 * c];
+		unsigned int dmid = ((unsigned char *) data)[7 + 3 * c];
+		unsigned int dlow = ((unsigned char *) data)[8 + 3 * c];
+		type_0_4_data mydata;
+		mydata.value = 0;
+		mydata.value += dhigh << 16;
+		mydata.value += dmid << 8;
+		mydata.value += dlow << 0;
+//               msgf("Daten: %08o  %06x",(unsigned long)mydata.value,mydata.value);
+		switch (mydata.generic.type) {
+		case 0:	//generic/unmodified data
+		    sayf ("%06o                   Generic/unmodified data",
+			  mydata.generic.data);
+		    break;
+		case 1:	//Address is known and to be desectorized
+		case 3:
+		case 7:
+		    sayf ("%o %o %02o %05o (%1o)         Known address",
+			  mydata.op_known_address.F,
+			  mydata.op_known_address.T,
+			  mydata.op_known_address.OP,
+			  mydata.op_known_address.ADDRESS,
+			  mydata.op_known_address.R);
+		    break;
+		case 2:	// Symbolic Address, to be desectorized
+		    sayf ("%o %o %02o %05o             Symbolic address",
+			  mydata.op_symbolic_address.F,
+			  mydata.op_symbolic_address.T,
+			  mydata.op_symbolic_address.OP,
+			  mydata.op_symbolic_address.SYMBOL_NUMBER);
+		    break;
+		case 4:	// Address ist known, do not desectorize
+
+		    sayf ("%o %o %06o                  Address known, not to be desectorized", mydata.known_address.F, mydata.known_address.T, mydata.known_address.ADDRESS);
+		    break;
+		case 6:	//Symbolic Address, not to be desctorized when known
+		    sayf ("%o %o %05o                  Symbolic Address, not to be desectorized when the address is known", mydata.symbolic_address.F, mydata.symbolic_address.T, mydata.symbolic_address.SYMBOL_NUMBER);
+
+		    break;
+		default:
+		    say ("There is an error in the 0-4 type word!");
+		}
+
+	    }
+#endif
+	}
+	break;
+    case 010:
+	say ("           (0-10)  symbol number definition block");
+	break;
+    case 014:
+	say ("           (0-14)  end");
+
+	break;
+    case 024:
+	say ("           (0-24)  switch to relocateable mode");
+	break;
+    case 030:
+	say ("           (0-30)  switch to absolute mode");
+	break;
+    case 054:
+	say ("           (0-54)  enter extended-memory desectorizing mode");
+	break;
+    case 060:
+	say ("           (0-60)  leave extended-memory desectorizing mode");
+	break;
+    case 044:{
+
+
+	    parstrip ((char *) data + 4, 6);
+	    twistbytes (data + 2, 3);
+	    char akt[7] = "SYMBOL";
+	    memcpy (akt, ((char *) data) + 4, 6);
+
+	    sayf ("%s     (0-44)  subprogram call", akt);
+	}
+	break;
+    case 050:
+	{
+	    int c;
+	    parstrip ((char *) data + 4, (block.size - 3) * 2);
+	    twistbytes (data + 2, block.size - 3);
+	    for (c = 0; c < (head->N - 3) / 3; c++) {
+		char akt[7] = "SYMBOL";
+		memcpy (akt, ((char *) data) + 4 + c * 6, 6);
+		if (c == 0)
+		    sayf ("%s     (0-50)  subprogram entry point definition",
+			  akt);
+		else
+		    sayf ("%s     (0-50)          \"           \"", akt);
+	    }
+
+	}
+
+	break;
+    case 064:
+	say ("           (0-64)  set base sector");
+	break;
+    default:
+	errf ("Unbekannter Blocktyp! (0-%0o)", subtype);
+	break;
+    }
+}
+
+break;
+case 1:
+say ("           (1)     absolute program words");
+break;
+case 2:
+say ("           (2)     relative program words");
+break;
+case 3:
+say ("           (3)     end jump (absolute)");
+break;
+case 4:
+say ("           (4)     end jump (relative)");
+break;
+case 5:{
+    char * dat =(char *) data;
+    twistbytes (data + 1, 4);
+    parstrip (dat + 3, 6);
+    char akt[7] = "SYMBOL";
+    memcpy (akt, dat + 3, 6);
+    twistbytes (data + 1, 4);
+
+    sayf ("%s     (5)     subroutine call", akt);
+}
+
+break;
+case 6:{
+    char * dat =(char *) data;
+    twistbytes (data + 1, 4);
+    parstrip (dat + 3, 6);
+    char akt[7] = "SYMBOL";
+    memcpy (akt, dat + 3, 6);
+    twistbytes (data + 1, 4);
+
+
+sayf ("%s     (6)     subroutine or common block definition",akt);
+
+
+}
+break;
+case 7:{
+    parstrip ((char *) data + 3, 6);
+    twistbytes (data + 1, 4);
+    char akt[7] = "SYMBOL";
+    memcpy (akt, ((char *) data) + 3, 6);
+    twistbytes (data + 1, 4);
+
+    sayf ("%s    (7)     reference (call) to common item", akt);
+}
+
+break;
+
+default:
+err ("Unbekannter Blocktyp!");
+break;
+break;
+
+
+}
+}