--- /dev/null
+#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;
+
+
+}
+}
projects / h316.git / blobdiff