Subversion Repositories eco32

/*

 * ranlib.c -- archive index generator

 */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <time.h>

#include <fcntl.h>

#include "endian.h"

#include "ranlib.h"

#include "../include/ar.h"

#include "../include/a.out.h"

#define TEMP_NAME               "__.SYMDEF"

#define STRING_SIZE_INIT        1024

#define STRING_SIZE_GROW        2

#define MAX_SYM_ENTRIES         1000

#define MSB     ((unsigned int) 1 << (sizeof(unsigned int) * 8 - 1))

typedef struct {

  unsigned int name;    /* name of symbol (as offset into string space) */

  off_t position;       /* position of member which defines the symbol */

                        /* (as file offset to the member's ArHeader) */

} Entry;

FILE *fi;

FILE *fo;

off_t nxtOff;           /* file offset to next member */

off_t curOff;

Entry table[MAX_SYM_ENTRIES];

int numEntries;

int createIndex;

char firstName[MAX_NAME];

ArHeader arhdr;

ExecHeader exhdr;

/**************************************************************/

char *stringArea = NULL;

unsigned int sizeAllocated = 0;

unsigned int sizeUsed = 0;

unsigned int getStringPos(void) {

  return sizeUsed;

}

void storeCharacter(char c) {

  unsigned int newSize;

  char *newArea;

  if (sizeUsed + 1 > sizeAllocated) {

    if (sizeAllocated == 0) {

      newSize = STRING_SIZE_INIT;

    } else {

      newSize = STRING_SIZE_GROW * sizeAllocated;

    }

    newArea = malloc(newSize);

    if (newArea == NULL) {

      fprintf(stderr, "ar: cannot allocate string area\n");

      exit(1);

    }

    if (stringArea != NULL) {

      memcpy(newArea, stringArea, sizeUsed);

      free(stringArea);

    }

    stringArea = newArea;

    sizeAllocated = newSize;

  }

  stringArea[sizeUsed++] = c;

}

/**************************************************************/

int nextMember(void) {

  int pad;

  curOff = nxtOff;

  fseek(fi, nxtOff, SEEK_SET);

  if (fread(&arhdr, sizeof(arhdr), 1, fi) != 1) {

    return 0;

  }

  conv4FromEcoToNative((unsigned char *) &arhdr.date);

  conv4FromEcoToNative((unsigned char *) &arhdr.uid);

  conv4FromEcoToNative((unsigned char *) &arhdr.gid);

  conv4FromEcoToNative((unsigned char *) &arhdr.mode);

  conv4FromEcoToNative((unsigned char *) &arhdr.size);

  pad = -arhdr.size & 0x03;

  arhdr.size += pad;

  nxtOff = ftell(fi) + arhdr.size;

  return 1;

}

void addSymbol(unsigned int nameOffset) {

  off_t curPos;

  int c;

  if (numEntries >= MAX_SYM_ENTRIES) {

    fprintf(stderr, "ar: symbol table overflow\n");

    exit(1);

  }

  table[numEntries].name = getStringPos();

  table[numEntries].position = curOff;

  numEntries++;

  curPos = ftell(fi);

  fseek(fi, curOff + sizeof(arhdr) + nameOffset, SEEK_SET);

  do {

    c = fgetc(fi);

    storeCharacter(c);

  } while (c != 0) ;

  fseek(fi, curPos, SEEK_SET);

}

void fixSize(void) {

  off_t deltaOff;

  int pad;

  int i;

  deltaOff = sizeof(arhdr) + sizeof(int) +

             numEntries * sizeof(Entry) + getStringPos();

  pad = -deltaOff & 0x03;

  deltaOff += pad;

  nxtOff = sizeof(unsigned int);

  nextMember();

  if(strncmp(arhdr.name, TEMP_NAME, MAX_NAME) == 0) {

    /* there is an index already present */

    createIndex = 0;

    deltaOff -= sizeof(arhdr) + arhdr.size;

  } else {

    /* no index yet present, create new one */

    createIndex = 1;

    strncpy(firstName, arhdr.name, MAX_NAME);

  }

  for (i = 0; i < numEntries; i++) {

    table[i].position += deltaOff;

  }

}

/**************************************************************/

void showSymdefs(char *symdefs) {

  FILE *in;

  int numSymbols;

  int i;

  Entry e;

  off_t curPos;

  off_t pos;

  int c;

  in = fopen(symdefs, "r");

  if (in == NULL) {

    printf("error: cannot open symdef file '%s'\n", symdefs);

    exit(1);

  }

  if (fread(&numSymbols, sizeof(int), 1, in) != 1) {

    printf("cannot read symdef file\n");

    exit(1);

  }

  conv4FromEcoToNative((unsigned char *) &numSymbols);

  printf("%d symbols\n", numSymbols);

  for (i = 0; i < numSymbols; i++) {

    if (fread(&e, sizeof(e), 1, in) != 1) {

      printf("cannot read symdef file\n");

      exit(1);

    }

    conv4FromEcoToNative((unsigned char *) &e.name);

    conv4FromEcoToNative((unsigned char *) &e.position);

    printf("%4d: name = 0x%08X, position = 0x%08lX, string = '",

           i, e.name, e.position);

    curPos = ftell(in);

    pos = sizeof(int) + numSymbols * sizeof(Entry) + e.name;

    fseek(in, pos, SEEK_SET);

    while (1) {

      c = fgetc(in);

      if (c == EOF) {

        printf("\nerror: unexpected end of file\n");

        exit(1);

      }

      if (c == 0) {

        break;

      }

      printf("%c", c);

    }

    printf("'\n");

    fseek(in, curPos, SEEK_SET);

  }

  fclose(in);

}

/**************************************************************/

int hasSymbols(char *archive) {

  unsigned int arMagic;

  int res;

  fi = fopen(archive, "r");

  if (fi == NULL) {

    return 0;

  }

  nxtOff = sizeof(unsigned int);

  if (fread(&arMagic, sizeof(arMagic), 1, fi) != 1 ||

      read4FromEco((unsigned char *) &arMagic) != AR_MAGIC) {

    fclose(fi);

    return 0;

  }

  fseek(fi, 0, SEEK_SET);

  if (nextMember() == 0) {

    fclose(fi);

    return 0;

  }

  fclose(fi);

  res = (strncmp(arhdr.name, TEMP_NAME, MAX_NAME) == 0);

  return res;

}

int updateSymbols(char *archive, int verbose) {

  unsigned int arMagic;

  unsigned int skip;

  int numSymbols;

  unsigned int stringStart;

  SymbolRecord symbol;

  int i;

  char *args[3];

  int res;

  if (verbose) {

    printf("ar: updating symbols in %s\n", archive);

  }

  fi = fopen(archive, "r");

  if (fi == NULL) {

    fprintf(stderr, "ar: cannot re-open %s\n", archive);

    return 1;

  }

  nxtOff = sizeof(unsigned int);

  if (fread(&arMagic, sizeof(arMagic), 1, fi) != 1 ||

      read4FromEco((unsigned char *) &arMagic) != AR_MAGIC) {

    fprintf(stderr, "ar: %s not in archive format\n", archive);

    fclose(fi);

    return 1;

  }

  fseek(fi, 0, SEEK_SET);

  numEntries = 0;

  if (nextMember() == 0) {

    fclose(fi);

    return 0;

  }

  /* iterate over archive members */

  do {

    if (fread(&exhdr, sizeof(exhdr), 1, fi) != 1 ||

        read4FromEco((unsigned char *) &exhdr.magic) != EXEC_MAGIC) {

      /* archive member not in proper format - skip */

      continue;

    }

    conv4FromEcoToNative((unsigned char *) &exhdr.magic);

    conv4FromEcoToNative((unsigned char *) &exhdr.csize);

    conv4FromEcoToNative((unsigned char *) &exhdr.dsize);

    conv4FromEcoToNative((unsigned char *) &exhdr.bsize);

    conv4FromEcoToNative((unsigned char *) &exhdr.crsize);

    conv4FromEcoToNative((unsigned char *) &exhdr.drsize);

    conv4FromEcoToNative((unsigned char *) &exhdr.symsize);

    conv4FromEcoToNative((unsigned char *) &exhdr.strsize);

    skip = exhdr.csize + exhdr.dsize + exhdr.crsize + exhdr.drsize;

    fseek(fi, skip, SEEK_CUR);

    numSymbols = exhdr.symsize / sizeof(SymbolRecord);

    if (numSymbols == 0) {

      fprintf(stderr,

              "ar: symbol table of %s is empty\n",

              arhdr.name);

      continue;

    }

    stringStart = sizeof(exhdr) + skip + exhdr.symsize;

    /* iterate over symbols */

    while (--numSymbols >= 0) {

      if (fread(&symbol, sizeof(symbol), 1, fi) != 1) {

        fprintf(stderr, "ar: cannot read archive\n");

        break;

      }

      conv4FromEcoToNative((unsigned char *) &symbol.name);

      conv4FromEcoToNative((unsigned char *) &symbol.type);

      conv4FromEcoToNative((unsigned char *) &symbol.value);

      if ((symbol.type & MSB) == 0) {

        /* this is an exported symbol */

        addSymbol(stringStart + symbol.name);

      }

    }

  } while (nextMember() != 0) ;

  fixSize();

  fclose(fi);

  fo = fopen(TEMP_NAME, "w");

  if (fo == NULL) {

    fprintf(stderr, "ar: can't create temporary file\n");

    return 1;

  }

  conv4FromNativeToEco((unsigned char *) &numEntries);

  if (fwrite(&numEntries, sizeof(numEntries), 1, fo) != 1) {

    fprintf(stderr, "ar: can't write temporary file\n");

    fclose(fo);

    unlink(TEMP_NAME);

    return 1;

  }

  conv4FromEcoToNative((unsigned char *) &numEntries);

  for (i = 0; i < numEntries; i++) {

    conv4FromNativeToEco((unsigned char *) &table[i].name);

    conv4FromNativeToEco((unsigned char *) &table[i].position);

  }

  if (fwrite(table, sizeof(Entry), numEntries, fo) != numEntries) {

    fprintf(stderr, "ar: can't write temporary file\n");

    fclose(fo);

    unlink(TEMP_NAME);

    return 1;

  }

  for (i = 0; i < numEntries; i++) {

    conv4FromEcoToNative((unsigned char *) &table[i].name);

    conv4FromEcoToNative((unsigned char *) &table[i].position);

  }

  if (fwrite(stringArea, 1, getStringPos(), fo) != getStringPos()) {

    fprintf(stderr, "ar: can't write temporary file\n");

    fclose(fo);

    unlink(TEMP_NAME);

    return 1;

  }

  fclose(fo);

  if (verbose) {

    showSymdefs(TEMP_NAME);

  }

  if (createIndex) {

    /* ar -rlb firstName archive TEMP_NAME */

    args[0] = firstName;

    args[1] = archive;

    args[2] = TEMP_NAME;

    res = exec_rCmd(1, args);

  } else {

    /* ar -rl archive TEMP_NAME */

    args[0] = archive;

    args[1] = TEMP_NAME;

    args[2] = NULL;

    res = exec_rCmd(0, args);

  }

  unlink(TEMP_NAME);

  return res;

}