int input(char *filename,LIST &l,int &x)
{
FILE *fp=fopen(filename,"rt");
if (!fp)
return 0;
int n,m,temp;
NODE *p;
fscanf(fp,"%d ",&n);
init(l);
for (int i=1;i<=n;i++)
{
fscanf(fp,"%d ",&temp);
p=getnode(temp);
addtail(l,p);
}
xoatrung(l);
fscanf(fp,"%d ",&m);
for (i=1;i<=m;i++)
{
fscanf(fp,"%d ",&temp);
if (!timtrung(l.pHead,temp))
{
p=getnode(temp);
addtail(l,p);
}
}
fscanf(fp,"%d ",&x);
fclose(fp);
return 1;
}
static struct Shdr64Node *addShdr64(struct list *l)
{
struct Shdr64Node *s = mycalloc(sizeof(struct Shdr64Node));
addtail(l,&(s->n));
return s;
}
void *MEM_callocN(unsigned int len, char *str)
{
MemHead *memh;
MemTail *memt;
len = (len + 3 ) & ~3; /* allocate in units of 4 */
memh= (MemHead *)calloc(len+sizeof(MemHead)+sizeof(MemTail),1);
if(memh!=0) {
memh->tag1 = MEMTAG1;
memh->name = str;
memh->nextname = 0;
memh->len = len;
/* memh->level = 0; */
memh->tag2 = MEMTAG2;
memt = (MemTail *)(((char *) memh) + sizeof(MemHead) + len);
memt->tag3 = MEMTAG3;
addtail(membase,&memh->next);
if (memh->next) memh->nextname = MEMNEXT(memh->next)->name;
totblock++;
mem_in_use += len;
return (++memh);
}
print_error("Calloc returns nill: len=%d in %s\n",len,str);
return 0;
}
void _input(char *filename,LIST &l)
{
FILE *fp=fopen(filename,"rt");
int n;
fscanf(fp,"%d ",&n);
init(l);
for (int i=0;i<n;i++)
{
LOPHOC x;
fgets(x.tenlop,31,fp);
fscanf(fp,"%d ",&x.siso);
for (int i=0;i<x.siso;i++)
{
fgets(x.dslop[i].hoten,31,fp);
float temp;
fscanf(fp,"%f ",&temp);
x.dslop[i].toan=temp;
fscanf(fp,"%f ",&temp);
x.dslop[i].van=temp;
x.dslop[i].dtb=(x.dslop[i].toan+x.dslop[i].van)/2;
}
NODE *p=getnode(x);
addtail(l,p);
}
fclose(fp);
}
static unsigned long aout_addsym(char *name,taddr value,int bind,
int info,int type,int desc,int be)
/* add a new symbol, return its symbol table index */
{
struct SymbolNode **chain = &aoutsymlist.hashtab[hashcode(name)%SYMHTABSIZE];
struct SymbolNode *sym;
while (sym = *chain)
chain = &sym->hashchain;
/* new symbol table entry */
*chain = sym = mycalloc(sizeof(struct SymbolNode));
if (!name)
name = emptystr;
sym->name = name;
sym->index = aoutsymlist.nextindex++;
setval(be,sym->s.n_strx,4,aout_addstr(name));
sym->s.n_type = type;
/* GNU binutils don't use BIND_LOCAL/GLOBAL in a.out files! We do! */
sym->s.n_other = ((bind&0xf)<<4) | (info&0xf);
setval(be,sym->s.n_desc,2,desc);
setval(be,sym->s.n_value,4,value);
addtail(&aoutsymlist.l,&sym->n);
return sym->index;
}
static unsigned long aout_addstr(char *s)
/* add a new symbol name to the string table and return its offset */
{
struct StrTabNode **chain = &aoutstrlist.hashtab[hashcode(s)%STRHTABSIZE];
struct StrTabNode *sn;
if (*s == '\0')
return 0;
/* search string in hash table */
while (sn = *chain) {
if (!strcmp(s,sn->str))
return (sn->offset); /* it's already in, return offset */
chain = &sn->hashchain;
}
/* new string table entry */
*chain = sn = mymalloc(sizeof(struct StrTabNode));
sn->hashchain = NULL;
sn->str = s;
sn->offset = aoutstrlist.nextoffset;
addtail(&aoutstrlist.l,&sn->n);
aoutstrlist.nextoffset += strlen(s) + 1;
return sn->offset;
}
static struct Shdr64Node *addShdr64(void)
{
struct Shdr64Node *s = mycalloc(sizeof(struct Shdr64Node));
addtail(&shdrlist,&(s->n));
shdrindex++;
return s;
}
void hoanvi(LIST &l,NODE *p,NODE *q)
{
if (!p || !q || p==q)
return ;
int k=0;
NODE *pPrev=NULL;
NODE *qPrev=NULL;
NODE *pNext=p->pNext;
NODE *qNext=q->pNext;
NODE *p1=l.pHead;
if (p1==p || p1==q)
k++;
for (;k<2;p1=p1->pNext)
{
if (p1->pNext==p)
{
pPrev=p1;
k++;
}
else
if (p1->pNext==q)
{
qPrev=p1;
k++;
}
}
l.pTail=qPrev;
if (!l.pTail)
l.pHead=NULL;
addtail(l,p);
// p, q xa nhau hay p < q
if (qNext!=p)
{
addtail(l,qNext);
l.pTail=pPrev;
}
if (!l.pTail)
l.pHead=NULL;
addtail(l,q);
if (pNext!=q) // p > q
addtail(l,pNext);
else // p < q
addtail(l,qPrev);
for (l.pTail=q;l.pTail->pNext;l.pTail=l.pTail->pNext);
}
static void addRel64(elfull o,elfull a,elfull i,elfull r)
{
if (RELA) {
struct Rela64Node *rn = mymalloc(sizeof(struct Rela64Node));
setval(be,rn->r.r_offset,8,o);
setval(be,rn->r.r_addend,8,a);
setval(be,rn->r.r_info,8,ELF64_R_INFO(i,r));
addtail(&relalist,&(rn->n));
}
else {
struct Rel64Node *rn = mymalloc(sizeof(struct Rel64Node));
setval(be,rn->r.r_offset,8,o);
setval(be,rn->r.r_info,8,ELF64_R_INFO(i,r));
addtail(&relalist,&(rn->n));
}
}
static unsigned addString(struct StrTabList *sl,char *s)
{
struct StrTabNode *sn = mymalloc(sizeof(struct StrTabNode));
unsigned idx = sl->index;
sn->str = s;
addtail(&(sl->l),&(sn->n));
sl->index += (unsigned)strlen(s) + 1;
return idx;
}
static void addRel64(int be,taddr o,taddr a,taddr i)
{
struct RelocNode *rn = mymalloc(sizeof(struct RelocNode));
setval(be,rn->r.r_offset,8,o);
#if RELA
setval(be,rn->r.r_addend,8,a);
#endif
setval(be,rn->r.r_info,8,i);
addtail(&relalist,&(rn->n));
}
static struct Symbol64Node *addSymbol64(int be,char *name)
{
struct Symbol64Node *sn = mycalloc(sizeof(struct Symbol64Node));
addtail(&symlist,&(sn->n));
if (name) {
sn->name = name;
setval(be,sn->s.st_name,4,addString(&strlist,name));
}
symindex++;
return sn;
}
static void ReadListFile(struct GlobalVars *gv,char *name,uint16_t flags)
/* read a file, which contains a list of object file names */
{
FILE *f;
struct InputFile *ifn;
int c;
char buf[256],*n=NULL;
if (f = fopen(name,"r")) {
do {
int len = 0;
c = fgetc(f);
if (c == '\"') { /* read file name in quotes */
n = buf;
len = 0;
while ((c = fgetc(f))!=EOF && c!='\"') {
if (len < 255) {
len++;
*n++ = c;
}
}
}
else if (c > ' ') {
if (n == NULL) {
n = buf;
len = 0;
}
if (len < 255) {
len++;
*n++ = c;
}
}
if (c<=' ' && n) { /* file name ends here */
*n = 0;
ifn = alloc(sizeof(struct InputFile));
ifn->name = allocstring(buf);
ifn->lib = FALSE;
ifn->flags = flags;
addtail(&gv->inputlist,&ifn->n);
n = NULL;
}
}
while (c != EOF);
fclose(f);
}
else
error(8,name); /* cannot open */
}
int input(char *filename,LIST &l)
{
FILE *fp=fopen(filename,"rb");
if (!fp)
return 0;
HOPSUA x;
init(l);
NODE *p;
while (fread(&x,sizeof(HOPSUA),1,fp))
{
p=getnode(x);
addtail(l,p);
}
fclose(fp);
return 1;
}
int input(char *filename,LIST l)
{
FILE *fp=fopen(filename,"rb");
if (!fp)
return 0;
DAILY x;
NODE *p;
while (fread(&x,sizeof(DAILY),1,fp))
{
DAILY x;
p=getnode(x);
addtail(l,p);
}
fclose(fp);
return 1;
}
static void aout_addreloclist(struct list *rlst,unsigned long raddr,
unsigned long rindex,unsigned long rinfo,int be)
/* add new relocation_info to .text or .data reloc-list */
{
struct RelocNode *rn = mymalloc(sizeof(struct RelocNode));
setval(be,rn->r.r_address,4,raddr);
setbits(be,rn->r.r_info,32,RELB_symbolnum,RELS_symbolnum,rindex);
setbits(be,rn->r.r_info,32,RELB_reloc,RELS_reloc,rinfo);
addtail(rlst,&rn->n);
if (isPIC && !readbits(be,rn->r.r_info,32,RSTDB_pcrel,1)
&& !readbits(be,rn->r.r_info,32,RSTDB_baserel,1)) {
/* the relocation is probably absolute, so it is no PIC anymore */
isPIC = 0;
}
}
void _input(char *filename,LIST &l)
{
FILE *fp=fopen(filename,"wt");
int n;
fscanf(fp,"%d" ,n);
for (int i=0;i<n;i++)
DAILY x;
fgets(x.madaily,6,fp);
fgets(x.tendaily,31,fp);
fscanf(fp,"%d" ,&x.dienthoai);
fprintf(fp,"%d %d %d" ,&x.ngaytiepnhan.ng,
&x.ngaytiepnhan.th,x.ngaytiepnhan.nm);
fgets(x.diachi,51,fp);
fgets(x.email,51,fp);
NODE *p=getnode(x);
addtail(l,p);
}
void _input(char *filename,LIST &l)
{
FILE *fp=fopen(filename,"rt");
int n;
fscanf(fp,"%d ",&n);
init(l);
for (int i=0;i<n;i++)
{
HOPSUA x;
fgets(x.nhanhieu,21,fp);
float temp;
fscanf(fp,"%f ",&temp);
x.trongluong=temp;
fscanf(fp,"%d %d %d ",&x.hsd.ng,&x.hsd.th,
&x.hsd.nm);
NODE *p=getnode(x);
addtail(l,p);
}
fclose(fp);
}
static void make_memhead_header(MemHead *memh, size_t len, const char *str)
{
MemTail *memt;
memh->tag1 = MEMTAG1;
memh->name = str;
memh->nextname = NULL;
memh->len = len;
memh->mmap = 0;
memh->tag2 = MEMTAG2;
memt = (MemTail *)(((char *) memh) + sizeof(MemHead) + len);
memt->tag3 = MEMTAG3;
addtail(membase,&memh->next);
if (memh->next) memh->nextname = MEMNEXT(memh->next)->name;
totblock++;
mem_in_use += len;
peak_mem = mem_in_use > peak_mem ? mem_in_use : peak_mem;
}
void enQueue(LIST &q,NODE *p)
{
addtail(q,p);
}
struct local_value *add_constant(value cst, fncode fn)
/* Effects: Adds a constant to code of 'fn'.
*/
{
return addtail(fn->fnmemory, &fn->csts, cst);
}
int main(int argc,char *argv[])
{
struct GlobalVars *gv = &gvars;
int i,j;
char *buf;
struct LibPath *libp;
struct InputFile *ifn;
bool stdlib = TRUE;
int so_version = 0; /* minum version for shared objects */
uint16_t flags = 0; /* input file flags */
/* initialize and set default values */
memset(gv,0,sizeof(struct GlobalVars));
initlist(&gv->libpaths);
initlist(&gv->rpaths);
gv->dynamic = TRUE; /* link with dynamic libraries first */
gv->interp_path = DEFAULT_INTERP_PATH;
gv->soname = NULL;
gv->endianess = -1; /* endianess is unknown */
/* initialize targets */
for (j=0; fff[j]; j++) {
if (fff[j]->init)
fff[j]->init(gv);
}
#ifdef DEFTARGET
for (j=0; fff[j]; j++) {
if (!strcmp(fff[j]->tname,DEFTARGET)) {
gv->dest_format = (uint8_t)j;
break;
}
}
if (fff[j] == NULL) {
fprintf(stderr,"Configuration warning: Selected default target "
"\"%s\" is not included.\nThe current default target "
"is \"%s\".\n",DEFTARGET,fff[gv->dest_format]->tname);
printf("\n");
}
#endif
initlist(&gv->inputlist);
initlist(&gv->lnksec);
gv->dest_name = "a.out";
gv->maxerrors = DEF_MAXERRORS;
gv->reloctab_format = RTAB_UNDEF;
gv->osec_base_name = NULL;
if (argc<2 || (argc==2 && *argv[1]=='?')) {
show_usage();
exit(EXIT_SUCCESS);
}
for (i=1; i<argc; i++) {
if (*argv[i] == '-') { /* option detected */
switch (argv[i][1]) {
case 'b':
if (!strcmp(&argv[i][2],"aseoff")) { /* set base-relative offset */
long bo;
sscanf(get_arg(argc,argv,&i),"%li",&bo);
fff[gv->dest_format]->baseoff = bo;
}
else { /* select target format */
if (buf = get_option_arg(argc,argv,&i)) {
/* for compatibility with older vlink versions,
elf32amiga is automatically converted into elf32powerup
and amigaos into amigahunk */
if (!strcmp(buf,"elf32amiga"))
buf = "elf32powerup";
else if (!strcmp(buf,"amigaos"))
buf = "amigahunk";
for (j=0; fff[j]; j++) {
if (!strcmp(fff[j]->tname,buf))
break;
}
if (fff[j])
gv->dest_format = (uint8_t)j;
else
error(9,buf); /* invalid target format */
}
}
break;
case 'c':
if (!strncmp(&argv[i][2],"lr-",3))
flags &= ~(chk_flags(argv[i])); /* -clr-flags */
else
error(2,argv[i]); /* unrecognized option */
break;
case 'd':
if (!argv[i][2] || argv[i][2]=='c' || argv[i][2]=='p')
gv->alloc_common = TRUE; /* force alloc. of common syms. */
else if (argv[i][2] == 'a')
gv->alloc_addr = TRUE; /* force alloc. of address syms. */
else
error(2,argv[i]); /* unrecognized option */
break;
case 'e':
if (!strcmp(&argv[i][2],"xport-dynamic"))
gv->dyn_exp_all = TRUE; /* export all globals as dynamic */
else /* defines entry point */
gv->entry_name = get_option_arg(argc,argv,&i);
break;
case 'f':
if (!strcmp(&argv[i][2],"ixunnamed")) {
gv->fix_unnamed = TRUE; /* assign a name to unnamed sections */
}
else { /* set a flavour */
char *name,**fl;
if (name = get_option_arg(argc,argv,&i)) {
if (fl = gv->flavours.flavours) {
char **tmp = alloc((gv->flavours.n_flavours+1)*sizeof(char *));
memcpy(tmp,fl,gv->flavours.n_flavours*sizeof(char *));
free(fl);
fl = tmp;
}
else
fl = alloc(sizeof(char *));
fl[gv->flavours.n_flavours++] = name;
gv->flavours.flavours = fl;
gv->flavours.flavours_len += strlen(name) + 1;
}
}
break;
case 'g':
if (!strcmp(&argv[i][2],"c-empty"))
gv->gc_sects = GCS_EMPTY;
else if (!strcmp(&argv[i][2],"c-all"))
gv->gc_sects = GCS_ALL;
else
error(2,argv[i]); /* unrecognized option */
break;
case 'h':
if (!strcmp(&argv[i][2],"unkattr")) {
struct SecAttrOvr *sao;
char secname[64];
lword val;
val = get_assign_arg(argc,argv,&i,secname,64);
sao = addsecattrovr(gv,secname,SAO_MEMFLAGS);
sao->memflags = (uint32_t)val;
}
else {
if (argv[i][2] == '\0') {
show_usage(); /* help text */
exit(EXIT_SUCCESS);
}
else
error(2,argv[i]); /* unrecognized option */
}
break;
case 'i':
if (!strcmp(&argv[i][2],"nterp"))
gv->interp_path = get_arg(argc,argv,&i);
else
error(2,argv[i]); /* unrecognized option */
break;
case 'k':
gv->keep_sect_order = TRUE;
break;
case 'l': /* library specifier */
if (buf = get_option_arg(argc,argv,&i)) {
ifn = alloc(sizeof(struct InputFile));
ifn->name = buf;
ifn->lib = TRUE;
ifn->dynamic = gv->dynamic;
ifn->so_ver = so_version;
so_version = 0;
ifn->flags = flags;
addtail(&gv->inputlist,&ifn->n);
}
break;
case 'm':
if (!strcmp(&argv[i][2],"inalign")) {
long a;
sscanf(get_arg(argc,argv,&i),"%li",&a);
gv->min_alignment = (uint8_t)a;
}
else if (!strcmp(&argv[i][2],"rel"))
gv->auto_merge = TRUE;
else if (!strcmp(&argv[i][2],"type"))
gv->merge_same_type = TRUE;
else if (!strcmp(&argv[i][2],"ultibase"))
gv->multibase = TRUE;
else
error(2,argv[i]); /* unrecognized option */
break;
case 'n':
if (!argv[i][2])
gv->no_page_align = TRUE;
else if (!strcmp(&argv[i][2],"ostdlib"))
stdlib = FALSE;
else
error(2,argv[i]); /* unrecognized option */
break;
case 'o': /* set output file name */
if (!strncmp(&argv[i][2],"sec=",4) && argv[i][6]!='\0') {
/* defines a base name of the sections to output */
gv->osec_base_name = &argv[i][6];
gv->output_sections = TRUE; /* output each section as a file */
}
else if (!strcmp(&argv[i][2],"sec"))
gv->output_sections = TRUE; /* output each section as a file */
else
gv->dest_name = get_option_arg(argc,argv,&i);
break;
case 'q': /* force relocations into final executable */
gv->keep_relocs = TRUE;
break;
case 'r': /* output is an relocatable object again */
if (!argv[i][2]) {
gv->dest_object = TRUE;
}
else if (!strcmp(&argv[i][2],"path")) {
if (buf = get_arg(argc,argv,&i)) {
libp = alloc(sizeof(struct LibPath));
libp->path = buf;
addtail(&gv->rpaths,&libp->n);
}
}
else
error(2,argv[i]); /* unrecognized option */
break;
case 's':
switch (argv[i][2]) {
case '\0': /* strip all symbols */
gv->strip_symbols = STRIP_ALL;
break;
case 'c': /* -sc force small code */
gv->small_code = TRUE;
break;
case 'd': /* -d force small data */
gv->small_data = TRUE;
break;
case 'e':
if (!strncmp(&argv[i][3],"t-",2)) /* -set-flags */
flags |= chk_flags(argv[i]);
else
error(2,argv[i]); /* unrecognized option */
break;
case 'h': /* -shared */
if (!strcmp(&argv[i][3],"ared"))
gv->dest_sharedobj = TRUE;
else
error(2,argv[i]); /* unrecognized option */
break;
case 'o': /* -soname <real name> */
if (!strcmp(&argv[i][3],"name"))
gv->soname = get_arg(argc,argv,&i);
else
error(2,argv[i]); /* unrecognized option */
break;
case 't': /* -static */
if (!strcmp(&argv[i][3],"atic"))
gv->dynamic = FALSE;
else
error(2,argv[i]); /* unrecognized option */
break;
default:
error(2,argv[i]); /* unrecognized option */
break;
}
break;
case 't': /* trace file accesses */
if (!strcmp(&argv[i][2],"extbaserel"))
gv->textbaserel = TRUE;
else if (!strncmp(&argv[i][2],"os-",3)) {
/* -tos-options for targets ataritos and aoutmint */
if (!strcmp(&argv[i][5],"flags")) {
long fl;
sscanf(get_arg(argc,argv,&i),"%li",&fl);
gv->tosflags = fl;
}
else if (!strcmp(&argv[i][5],"fastload"))
gv->tosflags |= 1;
else if (!strcmp(&argv[i][5],"fastram"))
gv->tosflags |= 2;
else if (!strcmp(&argv[i][5],"fastalloc"))
gv->tosflags |= 4;
else if (!strcmp(&argv[i][5],"private"))
gv->tosflags &= ~0x30;
else if (!strcmp(&argv[i][5],"global"))
gv->tosflags |= 0x10;
else if (!strcmp(&argv[i][5],"super"))
gv->tosflags |= 0x20;
else if (!strcmp(&argv[i][5],"readable"))
gv->tosflags |= 0x30;
else if (!strcmp(&argv[i][5],"textbased"))
gv->textbasedsyms = 1;
else
error(2,argv[i]); /* unrecognized option */
}
else if (!argv[i][2])
gv->trace_file = stderr;
else
error(2,argv[i]); /* unrecognized option */
break;
case 'u': /* mark symbol as undefined */
if (buf = get_option_arg(argc,argv,&i))
add_symnames(&gv->undef_syms,buf);
break;
case 'v': /* show version and target info */
show_version();
printf("Standard library path: "
#ifdef LIBPATH
LIBPATH
#endif
"\nDefault target: %s\n"
"Supported targets:",fff[gv->dest_format]->tname);
for (j=0; fff[j]; j++)
printf(" %s",fff[j]->tname);
printf("\n");
exit(EXIT_SUCCESS);
case 'w': /* suppress warnings */
gv->dontwarn = TRUE;
break;
case 'x': /* discard all local symbols */
gv->discard_local = DISLOC_ALL;
break;
case 'y': /* trace all accesses on a specific symbol */
if (gv->trace_syms == NULL)
gv->trace_syms = alloc_hashtable(TRSYMHTABSIZE);
if (buf = get_option_arg(argc,argv,&i)) {
struct SymNames **chain =
&gv->trace_syms[elf_hash(buf)%TRSYMHTABSIZE];
while (*chain)
chain = &(*chain)->next;
*chain = alloczero(sizeof(struct SymNames));
(*chain)->name = buf;
}
break;
case 'B': /* set link mode */
if (buf = get_option_arg(argc,argv,&i)) {
if (!strcmp(buf,"static")) {
gv->dynamic = FALSE;
}
else if (!strcmp(buf,"dynamic")) {
gv->dynamic = TRUE;
}
else if (!strcmp(buf,"shareable")) {
gv->dest_sharedobj = TRUE;
}
else if (!strcmp(buf,"forcearchive")) {
gv->whole_archive = TRUE;
}
else if (!strcmp(buf,"symbolic")) {
; /* don't know, what this means... */
}
else {
error(3,buf); /* unknown link mode */
}
}
break;
case 'C': /* select con-/destructor type */
if (buf = get_option_arg(argc,argv,&i)) {
if (!strcmp(buf,"gnu")) {
gv->collect_ctors_type = CCDT_GNU;
}
else if (!strcmp(buf,"vbcc")) {
gv->collect_ctors_type = CCDT_VBCC;
}
else if (!strcmp(buf,"vbccelf")) {
gv->collect_ctors_type = CCDT_VBCC_ELF;
}
else if (!strcmp(buf,"sasc")) {
gv->collect_ctors_type = CCDT_SASC;
}
else /* @@@ print error message */
gv->collect_ctors_type = CCDT_NONE;
}
break;
case 'E': /* set endianess */
switch (argv[i][2]) {
case 'B':
gv->endianess = _BIG_ENDIAN_;
break;
case 'L':
gv->endianess = _LITTLE_ENDIAN_;
break;
default:
error(2,argv[i]); /* unrecognized option */
break;
}
break;
case 'F': /* read a file with object file names */
if (buf = get_option_arg(argc,argv,&i))
ReadListFile(gv,buf,flags);
break;
case 'L': /* new library search path */
if (buf = get_option_arg(argc,argv,&i)) {
libp = alloc(sizeof(struct LibPath));
libp->path = buf;
addtail(&gv->libpaths,&libp->n);
}
break;
case 'M': /* mapping output */
gv->map_file = stdout;
break;
case 'P': /* protect symbol against stripping */
if (buf = get_option_arg(argc,argv,&i))
add_symnames(&gv->prot_syms,buf);
break;
case 'R': /* use short form for relocations */
if (buf = get_option_arg(argc,argv,&i)) {
if (!strcmp(buf,"std"))
gv->reloctab_format = RTAB_STANDARD;
else if (!strcmp(buf,"add"))
gv->reloctab_format = RTAB_ADDEND;
else if (!strcmp(buf,"short"))
gv->reloctab_format = RTAB_SHORTOFF;
else
error(123,buf); /* unknown reloc table format ignored */
}
break;
case 'S': /* strip debugger symbols */
gv->strip_symbols = STRIP_DEBUG;
break;
case 'T': /* read linker script file or set text address */
if (!strcmp(&argv[i][2],"text")) {
if (i+1 < argc)
sscanf(argv[++i],"%lli",&gv->start_addr);
else
error(5,'T'); /* option requires argument */
}
else if (buf = get_option_arg(argc,argv,&i)) {
if (gv->ldscript = mapfile(buf))
gv->scriptname = buf;
else
error(8,buf);
}
break;
case 'V': /* set minimum version for next shared object */
if (buf = get_option_arg(argc,argv,&i))
so_version = atoi(buf);
break;
case 'X': /* discard temporary local symbols only */
gv->discard_local = DISLOC_TMP;
break;
case 'Z': /* keep trailing zero-bytes at end of section */
gv->keep_trailing_zeros = TRUE;
break;
default:
error(2,argv[i]); /* unrecognized option */
break;
}
}
else { /* normal input file name */
ifn = alloc(sizeof(struct InputFile));
ifn->name = argv[i];
ifn->lib = FALSE;
ifn->flags = flags;
addtail(&gv->inputlist,&ifn->n);
}
}
/* add default library search path at the end of the list */
if (stdlib) {
#ifdef LIBPATH
libp = alloc(sizeof(struct LibPath));
libp->path = LIBPATH; /* default search path */
addtail(&gv->libpaths,&libp->n);
#endif
}
/* allocate flavour path buffer and sort flavours */
gv->flavours.flavour_dir = alloc(gv->flavours.flavours_len + 1);
if (gv->flavours.n_flavours > 1) {
qsort((void *)gv->flavours.flavours, gv->flavours.n_flavours,
sizeof(char **), flavours_cmp);
}
/* link them... */
linker_init(gv);
linker_load(gv); /* load all objects and libraries and their symbols */
linker_resolve(gv); /* resolve symbol references */
linker_relrefs(gv); /* find all relative references between sections */
linker_dynprep(gv); /* prepare for dynamic linking */
linker_sectrefs(gv); /* find all referenced sections from the start */
linker_gcsects(gv); /* section garbage collection (gc_sects) */
linker_join(gv); /* join sections with same name and type */
linker_mapfile(gv); /* mapfile output */
linker_copy(gv); /* copy section contents and fix symbol offsets */
linker_delunused(gv);/* delete empty/unused sects. without relocs/symbols */
linker_relocate(gv); /* relocate addresses in joined sections */
linker_write(gv); /* write output file in selected target format */
linker_cleanup(gv);
cleanup(gv);
return 0;
}
LIST *daten_lesen(void)
{
int i,index=0;
int id,
armour,startarmour,
ticks,hitbyindex,
mun,startmun,zeichen;
char alive,selfdestruct,
name[FCHARS];
LIST *l;
NODE *n;
short *kills;
NODE **robotarr;
struct Robot *robo,newrobo;
memset(&newrobo,0,sizeof(newrobo));
l=newlist();
while(!feof(stdin))
{
gets(buffer); /* AmigaRobots */
if(feof(stdin)) break;
gets(buffer); /* Arena */
strcpy(arena,buffer+7);
gets(buffer); /* Roboterzahl */
sscanf(buffer,"Roboteranzahl: %ld",&i);
gets(buffer); /* Runden ... */
gets(buffer); /* Werte ... */
gets(buffer); /* ID Panzerung ... */
kills=malloc((i+20)*sizeof(*kills));
memset(kills,0,(i+20)*sizeof(*kills));
robotarr=malloc((i+20)*sizeof(*robotarr));
memset(robotarr,0,(i+20)*sizeof(*robotarr));
while(i-- > 0)
{
gets(buffer); /* Roboterzeile */
sscanf(buffer,"%ld%c %ld/%ld %ld %ld%c %ld/%ld %n",
&id,
&alive,
&armour,
&startarmour,
&ticks,
&hitbyindex,
&selfdestruct,
&mun,
&startmun,
&zeichen
);
strcpy(name,buffer+zeichen);
if(!(n=findname(l,strtoupper(name)))) /* gefunden?, sonst neu */
{
n=newnode(&newrobo,sizeof(newrobo),index++,strtoupper(name));
addtail(l,n);
}
robotarr[id]=n; /* Welcher Roboter liegt wo (der 1. ist ...) */
if(!n) {perror("Kein Speicher für Knoten!\n"); exit(20);}
robo=getdata(n);
if(alive != '+')
{
robo->killed++;
kills[hitbyindex]++;
}
else
robo->survived++;
strncpy(robo->name,name,FCHARS-1);
robo->ticks += ticks;
robo->armour += armour;
robo->startarmour += startarmour;
robo->mun += mun;
robo->startmun += startmun;
}
while(id > 0)
{
if(robotarr[id])
{
robo=getdata(robotarr[id]);
robo->kills += kills[id];
}
id--;
}
free(kills);
free(robotarr);
}
return l;
}
