rdoff/rdoff.c

   1 /* rdoff.c      library of routines for manipulating rdoff files
   2  *
   3  * The Netwide Assembler is copyright (C) 1996 Simon Tatham and
   4  * Julian Hall. All rights reserved. The software is
   5  * redistributable under the licence given in the file "Licence"
   6  * distributed in the NASM archive.
   7  */
   8
   9 /* TODO:        The functions in this module assume they are running
  10  *              on a little-endian machine. This should be fixed to
  11  *              make it portable.
  12  */
  13
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16 #include <string.h>
  17 #include <errno.h>
  18
  19 #include "rdoff.h"
  20
  21 #define newstr(str) strcpy(malloc(strlen(str) + 1),str)
  22 #define newstrcat(s1,s2) strcat(strcpy(malloc(strlen(s1) + strlen(s2) + 1), \
  23                                        s1),s2)
  24
  25 /* ========================================================================
  26  * Code for memory buffers (for delayed writing of header until we know
  27  * how long it is).
  28  * ======================================================================== */
  29
  30
  31 memorybuffer * newmembuf(){
  32   memorybuffer * t;
  33
  34   t = malloc(sizeof(memorybuffer));
  35
  36   t->length = 0;
  37   t->next = NULL;
  38   return t;
  39 }
  40
  41 void membufwrite(memorybuffer *b, void *data, int bytes) {
  42   int16 w;
  43   long l;
  44
  45   if (b->next) {        /* memory buffer full - use next buffer */
  46     membufwrite(b->next,data,bytes);
  47     return;
  48   }
  49   if ((bytes < 0 && b->length - bytes > BUF_BLOCK_LEN)
  50       || (bytes > 0 && b->length + bytes > BUF_BLOCK_LEN)) {
  51
  52     /* buffer full and no next allocated... allocate and initialise next
  53      * buffer */
  54
  55     b->next = newmembuf();
  56     membufwrite(b->next,data,bytes);
  57   }
  58
  59   switch(bytes) {
  60   case -4:              /* convert to little-endian */
  61     l = * (long *) data ;
  62     b->buffer[b->length++] = l & 0xFF;
  63     l >>= 8 ;
  64     b->buffer[b->length++] = l & 0xFF;
  65     l >>= 8 ;
  66     b->buffer[b->length++] = l & 0xFF;
  67     l >>= 8 ;
  68     b->buffer[b->length++] = l & 0xFF;
  69     break;
  70
  71   case -2:
  72     w = * (int16 *) data ;
  73     b->buffer[b->length++] = w & 0xFF;
  74     w >>= 8 ;
  75     b->buffer[b->length++] = w & 0xFF;
  76     break;
  77
  78   default:
  79     while(bytes--) {
  80       b->buffer[b->length++] = *(* (unsigned char **) &data);
  81
  82       (* (unsigned char **) &data)++ ;
  83     }
  84     break;
  85   }
  86 }
  87
  88 void membufdump(memorybuffer *b,FILE *fp)
  89 {
  90   if (!b) return;
  91
  92   fwrite (b->buffer, 1, b->length, fp);
  93
  94   membufdump(b->next,fp);
  95 }
  96
  97 int membuflength(memorybuffer *b)
  98 {
  99   if (!b) return 0;
 100   return b->length + membuflength(b->next);
 101 }
 102
 103 void freemembuf(memorybuffer *b)
 104 {
 105   if (!b) return;
 106   freemembuf(b->next);
 107   free(b);
 108 }
 109
 110 /* =========================================================================
 111    General purpose routines and variables used by the library functions
 112    ========================================================================= */
 113
 114 long translatelong(long in) {           /* translate from little endian to
 115                                            local representation */
 116   long r;
 117   unsigned char *i;
 118
 119   i = (unsigned char *)&in;
 120   r = i[3];
 121   r = (r << 8) + i[2];
 122   r = (r << 8) + i[1];
 123   r = (r << 8) + *i;
 124
 125   return r;
 126 }
 127
 128 const char *RDOFFId = "RDOFF1"; /* written to the start of RDOFF files */
 129
 130 const char *rdf_errors[7] = {
 131   "no error occurred","could not open file","invalid file format",
 132   "error reading file","unknown error","header not read",
 133   "out of memory"};
 134
 135 int rdf_errno = 0;
 136
 137 /* ========================================================================
 138    The library functions
 139    ======================================================================== */
 140
 141 int rdfopen(rdffile *f, const char *name)
 142 {
 143     FILE * fp;
 144
 145     fp = fopen(name,"rb");
 146     if (!fp) return rdf_errno = 1;              /* error 1: file open error */
 147
 148     return rdfopenhere(f,fp,NULL,"");
 149 }
 150
 151 int rdfopenhere(rdffile *f, FILE *fp, int *refcount, char *name)
 152 {
 153   char buf[8];
 154   long initpos;
 155
 156   if (translatelong(0x01020304) != 0x01020304)
 157   {                                     /* fix this to be portable! */
 158     fputs("*** this program requires a little endian machine\n",stderr);
 159     fprintf(stderr,"01020304h = %08lxh\n",translatelong(0x01020304));
 160     exit(3);
 161   }
 162
 163   f->fp = fp;
 164   initpos = ftell(fp);
 165
 166   fread(buf,6,1,f->fp);         /* read header */
 167   buf[6] = 0;
 168
 169   if (strcmp(buf,RDOFFId)) {
 170     fclose(f->fp);
 171     return rdf_errno = 2;       /* error 2: invalid file format */
 172   }
 173
 174   if (fread(&f->header_len,1,4,f->fp) != 4) {
 175     fclose(f->fp);
 176     return rdf_errno = 3;       /* error 3: file read error */
 177   }
 178
 179   f->header_ofs = ftell(f->fp);
 180
 181   if (fseek(f->fp,f->header_len,SEEK_CUR)) {
 182     fclose(f->fp);
 183     return rdf_errno = 2;       /* seek past end of file...? */
 184   }
 185
 186   if (fread(&f->code_len,1,4,f->fp) != 4) {
 187     fclose(f->fp);
 188     return rdf_errno = 3;
 189   }
 190
 191   f->code_ofs = ftell(f->fp);
 192   if (fseek(f->fp,f->code_len,SEEK_CUR)) {
 193     fclose(f->fp);
 194     return rdf_errno = 2;
 195   }
 196
 197   if (fread(&f->data_len,1,4,f->fp) != 4) {
 198     fclose(f->fp);
 199     return rdf_errno = 3;
 200   }
 201
 202   f->data_ofs = ftell(f->fp);
 203   fseek(f->fp,initpos,SEEK_SET);
 204   f->header_loc = NULL;
 205
 206   f->name = newstr(name);
 207   f->refcount = refcount;
 208   if (refcount) (*refcount)++;
 209   return 0;
 210 }
 211
 212 int rdfclose(rdffile *f)
 213 {
 214     if (! f->refcount || ! *--f->refcount)
 215         fclose(f->fp);
 216     free(f->name);
 217
 218     return 0;
 219 }
 220
 221 void rdfperror(const char *app,const char *name)
 222 {
 223   fprintf(stderr,"%s:%s: %s\n",app,name,rdf_errors[rdf_errno]);
 224   if (rdf_errno == 1 || rdf_errno == 3)
 225   {
 226       perror(app);
 227   }
 228
 229 }
 230
 231 int rdfloadseg(rdffile *f,int segment,void *buffer)
 232 {
 233   long fpos;
 234   long slen;
 235
 236   switch(segment) {
 237   case RDOFF_HEADER:
 238     fpos = f->header_ofs;
 239     slen = f->header_len;
 240     f->header_loc = (char *)buffer;
 241     f->header_fp = 0;
 242     break;
 243   case RDOFF_CODE:
 244     fpos = f->code_ofs;
 245     slen = f->code_len;
 246     break;
 247   case RDOFF_DATA:
 248     fpos = f->data_ofs;
 249     slen = f->data_len;
 250     break;
 251   default:
 252     fpos = 0;
 253     slen = 0;
 254   }
 255
 256   if (fseek(f->fp,fpos,SEEK_SET))
 257     return rdf_errno = 4;
 258
 259   if (fread(buffer,1,slen,f->fp) != slen)
 260     return rdf_errno = 3;
 261
 262   return 0;
 263 }
 264
 265 /* Macros for reading integers from header in memory */
 266
 267 #define RI8(v) v = f->header_loc[f->header_fp++]
 268 #define RI16(v) { v = (f->header_loc[f->header_fp] + \
 269                        (f->header_loc[f->header_fp+1] << 8)); \
 270                   f->header_fp += 2; }
 271
 272 #define RI32(v) { v = (f->header_loc[f->header_fp] + \
 273                        (f->header_loc[f->header_fp+1] << 8) + \
 274                        (f->header_loc[f->header_fp+2] << 16) + \
 275                        (f->header_loc[f->header_fp+3] << 24)); \
 276                   f->header_fp += 4; }
 277
 278 #define RS(str,max) { for(i=0;i<max;i++){\
 279   RI8(str[i]); if (!str[i]) break;} str[i]=0; }
 280
 281 rdfheaderrec *rdfgetheaderrec(rdffile *f)
 282 {
 283   static rdfheaderrec r;
 284   int i;
 285
 286   if (!f->header_loc) {
 287     rdf_errno = 5;
 288     return NULL;
 289   }
 290
 291   if (f->header_fp >= f->header_len) return 0;
 292
 293   RI8(r.type);
 294   switch(r.type) {
 295   case 1:       /* Relocation record */
 296     RI8(r.r.segment);
 297     RI32(r.r.offset);
 298     RI8(r.r.length);
 299     RI16(r.r.refseg);
 300     break;
 301
 302   case 2:       /* Imported symbol record */
 303     RI16(r.i.segment);
 304     RS(r.i.label,32);
 305     break;
 306
 307   case 3:       /* Exported symbol record */
 308     RI8(r.e.segment);
 309     RI32(r.e.offset);
 310     RS(r.e.label,32);
 311     break;
 312
 313   case 4:       /* DLL record */
 314     RS(r.d.libname,127);
 315     break;
 316
 317   case 5:       /* BSS reservation record */
 318     RI32(r.b.amount);
 319     break;
 320
 321   default:
 322     rdf_errno = 2; /* invalid file */
 323     return NULL;
 324   }
 325   return &r;
 326 }
 327
 328 void rdfheaderrewind(rdffile *f)
 329 {
 330   f->header_fp = 0;
 331 }
 332
 333
 334 rdf_headerbuf * rdfnewheader(void)
 335 {
 336     return newmembuf();
 337 }
 338
 339 int rdfaddheader(rdf_headerbuf * h, rdfheaderrec * r)
 340 {
 341     switch (r->type)
 342     {
 343     case 1:
 344         membufwrite(h,&r->type,1);
 345         membufwrite(h,&r->r.segment,1);
 346         membufwrite(h,&r->r.offset,-4);
 347         membufwrite(h,&r->r.length,1);
 348         membufwrite(h,&r->r.refseg,-2);    /* 9 bytes written */
 349         break;
 350
 351     case 2:                             /* import */
 352         membufwrite(h,&r->type,1);
 353         membufwrite(h,&r->i.segment,-2);
 354         membufwrite(h,&r->i.label,strlen(r->i.label) + 1);
 355         break ;
 356
 357     case 3:                             /* export */
 358         membufwrite(h,&r->type,1);
 359         membufwrite(h,&r->e.segment,1);
 360         membufwrite(h,&r->e.offset,-4);
 361         membufwrite(h,&r->e.label,strlen(r->e.label) + 1);
 362         break ;
 363
 364     case 4:                             /* DLL */
 365         membufwrite(h,&r->type,1);
 366         membufwrite(h,&r->d.libname,strlen(r->d.libname) + 1);
 367         break ;
 368
 369     case 5:                             /* BSS */
 370         membufwrite(h,&r->type,1);
 371         membufwrite(h,&r->b.amount,-4);
 372         break ;
 373
 374     default:
 375         return (rdf_errno = 2);
 376     }
 377     return 0;
 378 }
 379
 380 int rdfwriteheader(FILE * fp, rdf_headerbuf * h)
 381 {
 382     long                l;
 383
 384     fwrite (RDOFFId, 1, strlen(RDOFFId), fp) ;
 385
 386     l = translatelong ( membuflength (h) );
 387     fwrite (&l, 4, 1, fp);
 388
 389     membufdump(h, fp);
 390
 391     return 0;           /* no error handling in here... CHANGE THIS! */
 392 }
 393
 394 void rdfdoneheader(rdf_headerbuf * h)
 395 {
 396     freemembuf(h);
 397 }