pc-tools/ldc/process.c

   1 #include <stdio.h>
   2 #include "hw_types.h"
   3 #include "hw_helpers.h"
   4
   5 #include "process.h"
   6 #include "ldc.h"
   7
   8 //#define DEBUG_DATA
   9 /**********************************************************************/
  10
  11
  12 int get_blocktype (datablock * block){
  13     return block->data[0].blocktype.type;
  14 }
  15
  16 int get_blocksubtype(datablock * block){
  17     if (block->data[0].blocktype.type!=0) return 0;
  18     return block->data[0].blocktype.t0_subtype;
  19 }
  20
  21 void block_copy(datablock* dest, datablock* src){
  22     dest->data     = (hw16 *) malloc (src->size * sizeof (hw16));
  23     dest->raw_data = (unsigned char *) malloc (src->size * 3 );
  24     dest->size=src->size;
  25     memcpy (dest->data, src->data, src->size * sizeof (hw16));
  26     memcpy (dest->raw_data, src->raw_data, src->size * 3);
  27
  28 }
  29
  30 datablock * block_clone(datablock * orgblock){
  31     datablock * block = (datablock *) malloc (sizeof (datablock));
  32     block_copy(block,orgblock);
  33     return block;
  34 }
  35
  36 void block_dispose(datablock * victim){
  37     free(victim->data);
  38     free(victim->raw_data);
  39     free(victim);
  40 }
  41
  42 char ** extract_labels0(datablock * blockp){
  43     char ** result=(char **) malloc (sizeof(char **));
  44     result[0] = NULL;
  45     if (get_blocktype(blockp)!=0) return NULL;
  46
  47     datablock block;
  48     block_copy(&block,blockp);
  49
  50     hw16 * data = block.data;
  51     int c;
  52     parstrip ((char *)data +4, (block.size - 3) * 2);
  53     twistbytes (data + 2, block.size - 3);
  54     for (c = 0; c < (((head0*)data)->N - 3) / 3; c++) {
  55         char akt[7];
  56         memcpy (akt, ((char *) data) + 4 + c * 6, 6);
  57         akt[6]=0;
  58
  59         int dd=5;
  60         while (akt[dd]==' ') akt[dd--]=0; // hinten kürzen;
  61         dd=0;
  62         while (akt[dd]==' ') dd++;  // vorne kürzen;
  63         char * aktres = malloc(strlen(akt+dd)+1);
  64         strcpy (aktres,"      ");
  65         strncpy (aktres,akt+dd,strlen(akt+dd));
  66         result=(char **)realloc(result, (c+1)* sizeof(char**));
  67         result[c]=aktres;
  68     }
  69     result=(char **)realloc(result, (c+1)* sizeof(char**));
  70     result[c]=NULL;
  71     free(block.data);
  72     free(block.raw_data);
  73     return result;
  74 }
  75
  76 void dispose_labels(char ** labels){
  77     if (labels==NULL) return;
  78     int c=0;
  79     do {
  80         free (labels[c++]);
  81     } while (labels[c]!=NULL);
  82     free (labels);
  83 }
  84 //***
  85
  86 char * extract_label6(datablock * block){
  87     datablock myblock;
  88     block_copy(&myblock,block);
  89     char * dat =(char *) myblock.data;
  90     twistbytes (myblock.data + 1, 4);
  91     parstrip (dat + 3, 6);
  92     char *akt = malloc(7);
  93     memcpy (akt, dat + 3, 6);
  94     akt[6]=0;
  95     free (myblock.data);
  96     free (myblock.raw_data);
  97     return akt;
  98 }
  99
 100
 101 //*****************
 102 void process_block (datablock * orgblock)
 103 {
 104     if (orgblock->type==BT_STOP){
 105         say("****************    ENDBLOCK    ****************");
 106         return;
 107     }
 108
 109     if (orgblock->type!=BT_DATA) return;
 110
 111     datablock block;
 112     block_copy(&block, orgblock);
 113
 114     hw16 * data = block.data;
 115
 116     int type = get_blocktype(&block);
 117     int subtype = get_blocksubtype(&block);
 118
 119     msg ("process_block(): Start");
 120     msgf ("process_block(): Blocktyp: %o", type);
 121     if (type == 0)
 122         msgf ("process_block(): Subtyp (oct): %o",
 123               block.data[0].blocktype.t0_subtype);
 124     switch (type) {
 125     case 0:
 126         {
 127             head0 *head = (head0 *) data;
 128             switch (subtype) {
 129             case 0:
 130                 {
 131                     int c=0;
 132                     char ** labels=extract_labels0(&block);
 133                     do {
 134                         char * akt  = labels[c++];
 135                         if (c == 1)
 136                             sayf ("%6s     (0-0)   subprogram name", akt);
 137                         else
 138                             sayf ("%s     (0-0)       \"       \"", akt);
 139                     } while (labels[c]!=NULL);
 140                     dispose_labels(labels);
 141                 }
 142                 break;
 143             case 1:
 144                 say ("           (0-1)   non-load flag off");
 145                 break;
 146             case 2:
 147                 say ("           (0-2)   chain flag on");
 148                 break;
 149             case 3:
 150                 say ("           (0-3)   end of job");
 151                 break;
 152             case 4:
 153                 {
 154                     say ("           (0-4)   data");
 155
 156 #ifdef DEBUG_DATA_PLAIN
 157                 }
 158                 int words24 = (block.size - 4) * 2 / 3;
 159                 int c;
 160                 for (c = 3; c < (block.size - 1); c++) {
 161                     msgf ("Datenwort(hex): %04x  Und (bin):%s", data[c].value,
 162                           bin2str (data[c].value, 16));
 163                 }
 164             }
 165 #endif
 166
 167 #ifdef DEBUG_DATA
 168             int words24 = (block.size - 4) * 2 / 3;
 169             msgf ("WORDS:%02i", words24);
 170             msgf ("BASE (oct):%06o", data[2].value);
 171             int c;
 172             twistbytes (data + 3, (block.size - 4));
 173             for (c = 0; c < (words24); c++) {
 174 //              sayf("Nummer:%5i",c);
 175                 unsigned int dhigh = ((unsigned char *) data)[6 + 3 * c];
 176                 unsigned int dmid = ((unsigned char *) data)[7 + 3 * c];
 177                 unsigned int dlow = ((unsigned char *) data)[8 + 3 * c];
 178                 type_0_4_data mydata;
 179                 mydata.value = 0;
 180                 mydata.value += dhigh << 16;
 181                 mydata.value += dmid << 8;
 182                 mydata.value += dlow << 0;
 183 //               msgf("Daten: %08o  %06x",(unsigned long)mydata.value,mydata.value);
 184                 switch (mydata.generic.type) {
 185                 case 0: //generic/unmodified data
 186                     sayf ("%06o                   Generic/unmodified data",
 187                           mydata.generic.data);
 188                     break;
 189                 case 1: //Address is known and to be desectorized
 190                 case 3:
 191                 case 7:
 192                     sayf ("%o %o %02o %05o (%1o)         Known address",
 193                           mydata.op_known_address.F,
 194                           mydata.op_known_address.T,
 195                           mydata.op_known_address.OP,
 196                           mydata.op_known_address.ADDRESS,
 197                           mydata.op_known_address.R);
 198                     break;
 199                 case 2: // Symbolic Address, to be desectorized
 200                     sayf ("%o %o %02o %05o             Symbolic address",
 201                           mydata.op_symbolic_address.F,
 202                           mydata.op_symbolic_address.T,
 203                           mydata.op_symbolic_address.OP,
 204                           mydata.op_symbolic_address.SYMBOL_NUMBER);
 205                     break;
 206                 case 4: // Address ist known, do not desectorize
 207
 208                     sayf ("%o %o %06o                  Address known, not to be desectorized", mydata.known_address.F, mydata.known_address.T, mydata.known_address.ADDRESS);
 209                     break;
 210                 case 6: //Symbolic Address, not to be desctorized when known
 211                     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);
 212
 213                     break;
 214                 default:
 215                     say ("There is an error in the 0-4 type word!");
 216                 }
 217
 218             }
 219 #endif
 220         }
 221         break;
 222     case 010:
 223         say ("           (0-10)  symbol number definition block");
 224         break;
 225     case 014:
 226         say ("           (0-14)  end");
 227
 228         break;
 229     case 024:
 230         say ("           (0-24)  switch to relocateable mode");
 231         break;
 232     case 030:
 233         say ("           (0-30)  switch to absolute mode");
 234         break;
 235     case 054:
 236         say ("           (0-54)  enter extended-memory desectorizing mode");
 237         break;
 238     case 060:
 239         say ("           (0-60)  leave extended-memory desectorizing mode");
 240         break;
 241     case 044:{
 242
 243
 244             parstrip ((char *) data + 4, 6);
 245             twistbytes (data + 2, 3);
 246             char akt[7] = "SYMBOL";
 247             memcpy (akt, ((char *) data) + 4, 6);
 248
 249             sayf ("%s     (0-44)  subprogram call", akt);
 250         }
 251         break;
 252     case 050:
 253         {
 254             int c;
 255             parstrip ((char *) data + 4, (block.size - 3) * 2);
 256             twistbytes (data + 2, block.size - 3);
 257             for (c = 0; c < (head->N - 3) / 3; c++) {
 258                 char akt[7] = "SYMBOL";
 259                 memcpy (akt, ((char *) data) + 4 + c * 6, 6);
 260                 if (c == 0)
 261                     sayf ("%s     (0-50)  subprogram entry point definition",
 262                           akt);
 263                 else
 264                     sayf ("%s     (0-50)          \"           \"", akt);
 265             }
 266
 267         }
 268
 269         break;
 270     case 064:
 271         say ("           (0-64)  set base sector");
 272         break;
 273     default:
 274         errf ("Unbekannter Blocktyp! (0-%0o)", subtype);
 275         break;
 276     }
 277 }
 278
 279 break;
 280 case 1:
 281 say ("           (1)     absolute program words");
 282 break;
 283 case 2:
 284 say ("           (2)     relative program words");
 285 break;
 286 case 3:
 287 say ("           (3)     end jump (absolute)");
 288 break;
 289 case 4:
 290 say ("           (4)     end jump (relative)");
 291 break;
 292 case 5:{
 293     char * dat =(char *) data;
 294     twistbytes (data + 1, 4);
 295     parstrip (dat + 3, 6);
 296     char akt[7] = "SYMBOL";
 297     memcpy (akt, dat + 3, 6);
 298     twistbytes (data + 1, 4);
 299
 300     sayf ("%s     (5)     subroutine call", akt);
 301 }
 302
 303 break;
 304 case 6:{
 305     char * dat =(char *) data;
 306     twistbytes (data + 1, 4);
 307     parstrip (dat + 3, 6);
 308     char akt[7] = "SYMBOL";
 309     memcpy (akt, dat + 3, 6);
 310     twistbytes (data + 1, 4);
 311 sayf ("%s     (6)     subroutine or common block definition",akt);
 312
 313 }
 314 break;
 315 case 7:{
 316     char * dat =(char *) data;       // Get byte pointer
 317     twistbytes (data + 1, 4);        // Do the endian thing
 318     parstrip ((char *) data + 3, 6); // Strip parity bits away
 319     char akt[7] = "SYMBOL";
 320     memcpy (akt, dat + 3, 6);        // Take the name
 321     twistbytes (data + 1, 4);        // repair the head
 322     sayf ("%s     (7)     reference (call) to common item", akt);
 323 }
 324
 325 break;
 326
 327 default:
 328 err ("Unbekannter Blocktyp!");
 329 break;
 330 break;
 331
 332
 333 }
 334 }