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