void performFixups(PSEG s)
{
UINT i,j;
PSEG f,t;
PRELOC r;
UINT offset;
INT section;
UINT disp;
PSYMBOL pub;
UINT delta;
PDATABLOCK d;
if(!s) return;
/* recurse down tree */
for(i=0;i<s->contentCount;++i)
{
if(s->contentList[i].flag==SEGMENT)
{
performFixups(s->contentList[i].seg);
}
}
for(i=0;i<s->relocCount;++i)
{
r=s->relocs+i;
for(j=0;j<s->contentCount;++j)
{
if(s->contentList[j].flag!=DATA) continue;
if((s->contentList[j].data->offset <= r->ofs)
&& ((s->contentList[j].data->offset + s->contentList[j].data->length) > r->ofs)) break;
}
if(j==s->contentCount)
{
addError("Fixup location %08lX is outside any data in segment %s",r->ofs,s->name);
continue;
}
d=s->contentList[j].data;
offset=r->ofs-d->offset;
t=NULL;
disp=0;
if(r->tseg)
{
t=r->tseg;
disp=t->base;
}
else if(r->text)
{
pub=r->text->pubdef;
if(!pub)
{
addError("Unresolved external %s",r->text->name);
continue;
}
t=pub->seg;
if(t)
disp=t->base+pub->ofs;
}
if(!t)
{
addError("Fixup target unresolved");
continue;
}
if(r->fseg)
{
f=r->fseg;
}
else if(r->fext)
{
pub=r->fext->pubdef;
if(!pub)
{
addError("Unresolved external %s",r->fext->name);
continue;
}
f=pub->seg;
}
else
{
f=NULL;
}
if(f && f->absolute && (r->base==REL_DEFAULT))
{
r->base=REL_FRAME;
}
switch(r->base)
{
case REL_ABS:
case REL_DEFAULT:
case REL_RVA:
section=t->section;
while(t->parent)
{
t=t->parent;
if(section<0) section=t->section;
disp+=t->base;
}
if(r->base==REL_RVA)
{
disp-=t->base;
}
break;
case REL_FILEPOS:
if(t->absolute)
{
addError("Attempt to get file position of absolute segment %s",t->name);
continue;
}
section=t->section;
while(t->parent && !t->fpset)
{
t=t->parent;
if(section<0) section=t->section;
disp+=t->base;
}
disp-=t->base;
if(t->fpset)
disp+=t->filepos;
if(f)
{
if(f->absolute)
{
addError("Attempt to get file position of absolute segment %s",f->name);
continue;
}
while(f->parent && !f->fpset)
{
f=f->parent;
if(section<0) section=f->section;
disp-=f->base;
}
disp+=f->base;
if(f->fpset)
disp-=f->filepos;
}
break;
case REL_SELF:
section=t->section;
while(t->parent)
{
t=t->parent;
if(section<0) section=t->section;
disp+=t->base;
}
f=s;
disp-=r->ofs;
while(f)
{
disp-=f->base;
f=f->parent;
}
break;
case REL_FRAME:
if(!f)
{
addError("Unspecified frame");
continue;
}
while(t->parent)
{
t=t->parent;
disp+=t->base;
}
section=f->section;
disp-=f->base;
if(section>=0)
disp+=f->base&(frameAlign-1);
while(f->parent && !f->absolute)
{
f=f->parent;
if(section<0)
{
section=f->section;
if(section>=0)
disp+=f->base&(frameAlign-1);
}
if(section>=0)
{
disp-=f->base;
}
}
break;
default:
addError("Unspecified reloc base");
continue;
}
disp+=r->disp;
switch(r->rtype)
{
case REL_OFS8:
delta=d->data[offset];
delta+=disp;
d->data[offset]=delta&0xff;
break;
case REL_OFS16:
if(disp>=0x10000)
{
addError("16-bit offset limit exceeded");
continue;
}
delta=d->data[offset]+(d->data[offset+1]<<8);
delta+=disp;
Set16(&d->data[offset],delta);
break;
case REL_OFS32:
delta=d->data[offset]+(d->data[offset+1]<<8)+(d->data[offset+2]<<16)+(d->data[offset+3]<<24);
delta+=disp;
Set32(&d->data[offset],delta);
break;
case REL_BYTE2:
delta=d->data[offset];
delta+=disp>>8;
d->data[offset]=delta&0xff;
break;
case REL_SEG:
if(section<0)
{
addError("Segmented reloc not permitted for specified frame");
continue;
}
if(section>=0x10000)
{
addError("Section number too large %08lX",section);
continue;
}
delta=d->data[offset]+(d->data[offset+1]<<8);
delta+=section;
Set16(&d->data[offset],delta);
break;
case REL_PTR16:
if(section<0)
{
addError("Segmented reloc not permitted for specified frame");
continue;
}
if(section>=0x10000)
{
addError("Section number too large %08lX",section);
continue;
}
if(disp>=0x10000)
{
addError("16-bit offset limit exceeded");
continue;
}
delta=d->data[offset]+(d->data[offset+1]<<8);
delta+=disp;
Set16(&d->data[offset],delta);
delta=d->data[offset+2]+(d->data[offset+3]<<8);
delta+=section;
Set16(&d->data[offset+2],delta);
break;
case REL_PTR32:
if(section<0)
{
addError("Segmented reloc not permitted for specified frame");
continue;
}
delta=d->data[offset]+(d->data[offset+1]<<8)+(d->data[offset+2]<<16)+(d->data[offset+3]<<24);
delta+=disp;
Set32(&d->data[offset],delta);
delta=d->data[offset+4]+(d->data[offset+5]<<8);
delta+=section;
Set16(&d->data[offset+4],delta);
break;
default:
addError("Invalid relocation type");
continue;
break;
}
}
}
int8 KismetExecuteEvent(int16 _DeviceID,int8 _EventID)
{
int8 a;//variable for the kismet blocks to use
int8 read8;
int16 read16;
int16 eventaddr;
int16 methodaddr;
int16 BlockAddr;
int16 timeout;
if(!OperationEnabled)return 1;//return if no operating is allowed
//ToSendDataBuffer[2]=((int8*)&_DeviceID)[0];
//ToSendDataBuffer[3]=((int8*)&_DeviceID)[1];
//ToSendDataBuffer[4]=_EventID;
MemoryBeginRead(EEPROMHEADERSIZE);
for(timeout=0;timeout<1024;timeout++)
{
read16=MemoryReadInt16();
eventaddr =MemoryReadInt16();
if(read16==_DeviceID)break;
if(read16==0xffff) { MemoryEndRead(); return 2; }
}
MemoryEndRead();
MemoryBeginRead(eventaddr);
for(timeout=0;timeout<1024;timeout++)
{
read8=MemoryReadInt8();
methodaddr=MemoryReadInt16();
if(read8==_EventID)break;
if(read8==0xff) { MemoryEndRead(); return 3; }
}
MemoryEndRead();
//ToSendDataBuffer[12]=((int8*)&eventaddr)[0];
//ToSendDataBuffer[13]=((int8*)&eventaddr)[1];
//ToSendDataBuffer[14]=((int8*)&methodaddr)[0];
//ToSendDataBuffer[15]=((int8*)&methodaddr)[1];
BlockAddr=methodaddr;
MemoryBeginRead(BlockAddr);
while(1)
{
int8 blocktype=MemoryReadInt8();
//#=EEPROM DATA $=REGISTER DATA
switch(blocktype)
{
case 0x00://end of code
default://or we dont understand it
{
MemoryEndRead();
return 0;
}
case 0x01://load literal int16
{
int8 reg =MemoryReadInt8();
int16 value =MemoryReadInt16();
Set16(reg,value);
}break;
case 0x02://load literal int8
{
int8 reg =MemoryReadInt8();
int8 value =MemoryReadInt8();
Set8(reg,value);
}break;
case 0x0B://equal
{
int8 reg1 =MemoryReadInt8();
int8 reg2 =MemoryReadInt8();
int8 reg3 =MemoryReadInt8();
Set16(reg3,(Get16(reg1)==Get16(reg2))?0xffff:0);
}break;
case 0x0C://differ
{
int8 reg1 =MemoryReadInt8();
int8 reg2 =MemoryReadInt8();
int8 reg3 =MemoryReadInt8();
Set16(reg3,(Get16(reg1)!=Get16(reg2))?0xffff:0);
}break;
case 0x0D://and
{
int8 reg1 =MemoryReadInt8();
int8 reg2 =MemoryReadInt8();
int8 reg3 =MemoryReadInt8();
Set16(reg3,Get16(reg1)&Get16(reg2));
}break;
case 0x0E://or
{
int8 reg1 =MemoryReadInt8();
int8 reg2 =MemoryReadInt8();
int8 reg3 =MemoryReadInt8();
Set16(reg3,Get16(reg1)|Get16(reg2));
}break;
case 0x0F://xor
{
int8 reg1 =MemoryReadInt8();
int8 reg2 =MemoryReadInt8();
int8 reg3 =MemoryReadInt8();
Set16(reg3,Get16(reg1)^Get16(reg2));
}break;
case 0x20://add
{
int8 reg1 =MemoryReadInt8();
int8 reg2 =MemoryReadInt8();
int8 reg3 =MemoryReadInt8();
Set16(reg3,Get16(reg1)+Get16(reg2));
}break;
case 0x21://sub
{
int8 reg1 =MemoryReadInt8();
int8 reg2 =MemoryReadInt8();
int8 reg3 =MemoryReadInt8();
Set16(reg3,Get16(reg1)-Get16(reg2));
}break;
case 0x22://mul
{
int8 reg1 =MemoryReadInt8();
int8 reg2 =MemoryReadInt8();
int8 reg3 =MemoryReadInt8();
Set16(reg3,Get16(reg1)*Get16(reg2));
}break;
case 0x23://div
{
int8 reg1 =MemoryReadInt8();
int8 reg2 =MemoryReadInt8();
int8 reg3 =MemoryReadInt8();
Set16(reg3,Get16(reg1)/Get16(reg2));
}break;
case 0x30://hours
{
int8 reg1 =MemoryReadInt8();
Set16(reg1,(int16)RTCHour);
}break;
case 0x31://minutes
{
int8 reg1 =MemoryReadInt8();
Set16(reg1,(int16)RTCMinute);
}break;
case 0x32://seconds
{
int8 reg1 =MemoryReadInt8();
Set16(reg1,(int16)RTCSecond);
}break;
case 0x33://days
{
int8 reg1 =MemoryReadInt8();
Set16(reg1,(int16)RTCDay);
}break;
case 0x0A://Set LED
{
int8 reg =MemoryReadInt8();
//Set16(reg,1);
SetLED(Get16(reg));
}break;
case 0x80:// $if goto $here?
{
int8 reg1 =MemoryReadInt8();
int8 reg2 =MemoryReadInt8();
if(Get16(reg1)==0)
{
BlockAddr=methodaddr+(int16)reg2;
MemoryEndRead();MemoryBeginRead(BlockAddr);
}
}break;
case 0x70://mov
{
int8 reg1 =MemoryReadInt8();
int8 reg2 =MemoryReadInt8();
int8 amnt =MemoryReadInt8();
for(a=0;a<amnt;a++)
Set8(reg2+a,Get8(reg1+a));
}break;
case 0x71://EPSend
{
int16 dev =MemoryReadInt16();
EPBufferSize=MemoryReadInt8();
//try three times
if(EPSend(dev))break;
if(EPSend(dev))break;
if(EPSend(dev))break;
}break;
case 0x90://Set Delay
{
int8 timer =MemoryReadInt8();
int8 event =MemoryReadInt8();
int8 reg =MemoryReadInt8();
int16 time=Get16(reg);
SetTimer(timer,event,time);
}break;
}
}
return 4;
}
