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