void CPipeServer::EnumClassesInImage()
{
int i;
void *image=(void *)ReadQword();
void *tdef=mono_image_get_table_info (image, MONO_TABLE_TYPEDEF);
int tdefcount=mono_table_info_get_rows(tdef);
WriteDword(tdefcount);
for (i = 0; i < tdefcount; i++)
{
void *c = mono_class_get(image, MONO_TOKEN_TYPE_DEF | i+1);
char *name=mono_class_get_name(c);
WriteQword((UINT_PTR)c);
WriteWord(strlen(name));
Write(name, strlen(name));
name=mono_class_get_namespace(c);
WriteWord(strlen(name));
Write(name, strlen(name));
}
}
void CopyFlashToEEPROM (void) {
unsigned char compare;
unsigned int i;
// Copies the contents of FLASH in Sequences[] to EEPROM
if (EEPROM_Present()) {
// Write Sequences data to external EEPROM
EEPROM_Write(0x0000, (unsigned char *)Sequences, sizeof(Sequences));
// Verify the external EEPROM contents
for (i=0; i<sizeof(Sequences); i++) {
compare = EEPROM_ReadChar(i);
if (compare != Sequences[i]) {
Error();
return; // abort
}
}
EEPROM_Write(EEPROM_GetSize()-2, MAGIC, 2); // initialize EEPROM magic number
// Set up internal EEPROM start address and sequence length
WriteWord(STARTSEQADD, 0x0000); // enable normal playback
WriteWord(TOTALSEQADD, Seq_Count()); // identify how many sequences are defined
ConfirmCommand();
} else {
Error();
}
}
void ResFile::WriteString(const std::wstring &str)
{
int n = str.size();
#ifdef WIN32
// The string actually isn't unicode, it is
// code-page based.
// the MENU font doesn't support code pages very well...
// Convert to unicode.
{
int i;
char buf[256];
WCHAR wbuf[256], *p = wbuf;
for (i=0; i < n; i++)
buf[i] = str[i];
buf[i] = 0;
wbuf[MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, buf,strlen(buf), wbuf, 256)]=0;
while (*p)
WriteWord(*p++);
}
#else
// writing word by word for portability
for (int i=0; i < n; i++)
WriteWord(str[i]);
#endif
WriteWord(0);
}
bool CBotVar::Save0State(FILE* pf)
{
if (!WriteWord(pf, 100+m_mPrivate))return false; // private variable?
if (!WriteWord(pf, m_bStatic))return false; // static variable?
if (!WriteWord(pf, m_type.GetType()))return false; // saves the type (always non-zero)
if (!WriteWord(pf, m_binit))return false; // variable defined?
return WriteString(pf, m_token->GetString()); // and variable name
}
/*
** ===================================================================
** Method : IFsh1_SetByteFlash (bean IntFLASH)
**
** Description :
** Write byte to address in FLASH.
** Parameters :
** NAME - DESCRIPTION
** Addr - Address to FLASH.
** Data - Data to write.
** Returns :
** --- - Error code, possible codes:
** - ERR_OK - OK
** - ERR_NOTAVAIL - Desired program/erase
** operation is not available
** - ERR_RANGE - Address is out of range
** - ERR_VALUE - Read value is not equal to
** written value
** - ERR_SPEED - This device does not work
** in the active speed mode
** - ERR_BUSY - Device is busy
** ===================================================================
*/
byte IFsh1_SetByteFlash(dword Addr,byte Data)
{
byte err;
if(((Addr&65535)<32768)||((Addr&65535)>49151)||((Addr>>16)<60)||((Addr>>16)>63))
return(ERR_RANGE); /* Check range of address */
if (Addr&1) { /* Not Aligned word ? */
err=WriteWord(Addr & 16777214, ((*(word *far)(Addr & 16777214)) & 65280) | Data);
} else {
err=WriteWord(Addr & 16777214, (Data<<8) | ((*(word *far)Addr) & 255));
}
return(err); /* Return error code if previous operation finished not correctly */
}
void CNodedMemoryBuffer::WriteWordField(int iFieldId, WORD wVal)
{
ASSERT(IsStoring());
WriteInt(iFieldId);
WriteDword(sizeof(WORD));
WriteWord(wVal);
}
void CPipeServer::GetClassNamespace()
{
void *klass=(void *)ReadQword();
char *methodname=mono_class_get_namespace(klass);
WriteWord(strlen(methodname));
Write(methodname, strlen(methodname));
}
void CPipeServer::GetMethodName()
{
void *method=(void *)ReadQword();
char *methodname=mono_method_get_name(method);
WriteWord(strlen(methodname));
Write(methodname, strlen(methodname));
}
void P_WriteDemoWeaponsChunk(BYTE **demo)
{
WriteWord(Weapons_ntoh.Size(), demo);
for (unsigned int i = 1; i < Weapons_ntoh.Size(); ++i)
{
WriteString(Weapons_ntoh[i]->TypeName.GetChars(), demo);
}
}
bool CBotProgram::SaveState(FILE* pf)
{
if (!WriteWord( pf, CBOTVERSION)) return false;
if (m_stack != nullptr )
{
if (!WriteWord( pf, 1)) return false;
if (!WriteString( pf, m_entryPoint->GetName() )) return false;
if (!m_stack->SaveState(pf)) return false;
}
else
{
if (!WriteWord( pf, 0)) return false;
}
return true;
}
void CPipeServer::GetImageName()
{
void *image=(void *)ReadQword();
char *s=mono_image_get_name(image);
WriteWord(strlen(s));
Write(s, strlen(s));
}
void set_breakpoints() {
int n;
UINT8 *base = ztx->z80Base;
for (n=0; n<nb_break; n++)
WriteWord(base+classic_bl[n].adr,0xd3ab); // outa (abh)
add_z80_port_wb(current_cpu & 0xf,0xab,0xab,classic_break);
}
bool CBotStack::SaveState(FILE* pf)
{
if ( this == NULL ) // end of the tree?
{
return WriteWord(pf, 0); // is a terminator
}
if ( m_next2 != NULL )
{
if (!WriteWord(pf, 2)) return false; // a mark of pursuit
if (!m_next2->SaveState(pf)) return false;
}
else
{
if (!WriteWord(pf, 1)) return false; // a mark of pursuit
}
if (!WriteWord(pf, m_bBlock)) return false; // is a local block
if (!WriteWord(pf, m_state)) return false; // in what state?
if (!WriteWord(pf, 0)) return false; // by compatibility m_bDontDelete
if (!WriteWord(pf, m_step)) return false; // in what state?
if (!SaveVar(pf, m_var)) return false; // current result
if (!SaveVar(pf, m_listVar)) return false; // local variables
return m_next->SaveState(pf); // saves the following
}
bool CBotVarInt::Save0State(FILE* pf)
{
if ( !m_defnum.IsEmpty() )
{
if(!WriteWord(pf, 200 )) return false; // special marker
if(!WriteString(pf, m_defnum)) return false; // name of the value
}
return CBotVar::Save0State(pf);
}
int bas_retint(int i)
{
w32 p;
p=bas_resstack(2);
WriteWord(p,i);
reg[4]=3;
return 0;
}
bool WriteString(FILE* pf, std::string s)
{
size_t lg1, lg2;
lg1 = s.size();
if (!WriteWord(pf, lg1)) return false;
lg2 = fwrite(s.c_str(), 1, lg1, pf );
return (lg1 == lg2);
}
static void i80286_data_descriptor_full(i80286_state *cpustate, int reg, UINT16 selector, int cpl, UINT32 trap, UINT16 offset, int size)
{
if (PM) {
UINT16 desc[3];
UINT8 r;
UINT32 addr;
/* selector format
15..3 number/address in descriptor table
2: 0 global, 1 local descriptor table
1,0: requested privileg level
must be higher or same as current privileg level in code selector */
if ((reg != SS) && !IDXTBL(selector)) {
cpustate->sregs[reg]=0;
cpustate->limit[reg]=0;
cpustate->base[reg]=0;
cpustate->rights[reg]=0;
cpustate->valid[reg]=0;
return;
}
if ((addr = i80286_selector_address(cpustate,selector)) == -1) throw trap;
desc[0] = ReadWord(addr);
desc[1] = ReadWord(addr+2);
desc[2] = ReadWord(addr+4);
r = RIGHTS(desc);
if (!SEGDESC(r)) throw trap;
if (reg == SS) {
if (!IDXTBL(selector)) throw trap;
if (DPL(r)!=cpl) throw trap;
if (RPL(selector)!=cpl) throw trap;
if (!RW(r) || CODE(r)) throw trap;
if (!PRES(r)) throw TRAP(STACK_FAULT,(IDXTBL(selector)+(trap&1)));
} else {
if ((DPL(r) < PMAX(cpl,RPL(selector))) && (!CODE(r) || (CODE(r) && !CONF(r)))) throw trap;
if (CODE(r) && !READ(r)) throw trap;
if (!PRES(r)) throw TRAP(SEG_NOT_PRESENT,(IDXTBL(selector)+(trap&1)));
}
if (offset+size) {
if ((CODE(r) || !EXPDOWN(r)) && ((offset+size-1) > LIMIT(desc))) throw (reg==SS)?TRAP(STACK_FAULT,(trap&1)):trap;
if (!CODE(r) && EXPDOWN(r) && ((offset <= LIMIT(desc)) || ((offset+size-1) > 0xffff))) throw (reg==SS)?TRAP(STACK_FAULT,(trap&1)):trap;
}
SET_ACC(desc);
WriteWord(addr+4, desc[2]);
cpustate->sregs[reg]=selector;
cpustate->limit[reg]=LIMIT(desc);
cpustate->base[reg]=BASE(desc);
cpustate->rights[reg]=RIGHTS(desc);
} else {
cpustate->sregs[reg]=selector;
cpustate->base[reg]=selector<<4;
}
cpustate->valid[reg]=1;
}
int bas_retstr(int len,char *str)
{
w32 p;
p=bas_resstack(len+2);
WriteWord(p,len);
memcpy((char *)theROM+p+2,str,len);
reg[4]=1;
return 0;
}
/*
** ===================================================================
** Method : IFsh1_SetWordFlash (bean IntFLASH)
**
** Description :
** Write word to address in FLASH.
** Parameters :
** NAME - DESCRIPTION
** Addr - Address to FLASH.
** Data - Data to write.
** Returns :
** --- - Error code, possible codes:
** - ERR_OK - OK
** - ERR_NOTAVAIL - Desired program/erase
** operation is not available
** - ERR_RANGE - Address is out of range
** - ERR_VALUE - Read value is not equal to
** written value
** - ERR_SPEED - This device does not work
** in the active speed mode
** - ERR_BUSY - Device is busy
** ===================================================================
*/
byte IFsh1_SetWordFlash(dword Addr,word Data)
{
byte err;
if(((Addr&65535)<32768)||((Addr&65535)>49150)||((Addr>>16)<60)||((Addr>>16)>63))
return(ERR_RANGE); /* Check range of address */
if (Addr & 1) /* Aligned address ? */
return ERR_NOTAVAIL;
err = WriteWord(Addr, Data); /* Write new data to Flash */
return(err); /* Return error */
}
void CPipeServer::DisassembleMethod()
{
void *method=(void *)ReadQword();
void *methodheader=mono_method_get_header(method);
UINT32 codesize, maxstack;
void *ilcode=mono_method_header_get_code(methodheader, &codesize, &maxstack);
char *disassembly=mono_disasm_code(NULL, method, ilcode, (void *)((UINT_PTR)ilcode+codesize));
WriteWord(strlen(disassembly));
Write(disassembly, strlen(disassembly));
g_free(disassembly);
}
bool CBotClass::SaveStaticState(FILE* pf)
{
if (!WriteWord( pf, CBOTVERSION*2)) return false;
// saves the state of static variables in classes
CBotClass* p = m_ExClass;
while ( p != NULL )
{
if (!WriteWord( pf, 1)) return false;
// save the name of the class
if (!WriteString( pf, p->GetName() )) return false;
CBotVar* pv = p->GetVar();
while( pv != NULL )
{
if ( pv->IsStatic() )
{
if (!WriteWord( pf, 1)) return false;
if (!WriteString( pf, pv->GetName() )) return false;
if ( !pv->Save0State(pf)) return false; // common header
if ( !pv->Save1State(pf) ) return false; // saves as the child class
if ( !WriteWord( pf, 0)) return false;
}
pv = pv->GetNext();
}
if (!WriteWord( pf, 0)) return false;
p = p->m_ExNext;
}
if (!WriteWord( pf, 0)) return false;
return true;
}
void CPipeServer::EnumFieldsInClass()
{
void *c=(void *)ReadQword();
void *iter=NULL;
void *field;
do
{
field=mono_class_get_fields(c, &iter);
WriteQword((UINT_PTR)field);
if (field)
{
char *name;
void *fieldtype=mono_field_get_type(field);
WriteQword((UINT_PTR)fieldtype);
WriteDword(mono_type_get_type(fieldtype));
WriteQword((UINT_PTR)mono_field_get_parent(field));
WriteDword((UINT_PTR)mono_field_get_offset(field));
WriteDword(mono_field_get_flags(field));
name=mono_field_get_name(field);
WriteWord(strlen(name));
Write(name, strlen(name));
name=mono_type_get_name(fieldtype);
if (name)
{
WriteWord(strlen(name));
Write(name, strlen(name));
g_free(name);
}
else
WriteWord(0);
}
} while (field);
}
void DefineEEMacros (void) {
unsigned int sequence = 0;
unsigned int prevStart;
PWM_Set (0, 0, 0, 0);
Seq_Find(sequence);
prevStart = ReadWord(STARTSEQADD);
if (prevStart == PLAYMACROS) prevStart = 0;
do {
PlaySequence(sequence);
if (PushButtons_Pressed(BUTTON1)) {
// advance to next sequence
PWM_Set (0, 0, 0, 0);
PushButtons_Clear(BUTTON1);
sequence++;
if (sequence >= Seq_Count()) sequence = 0;
Seq_Find(sequence);
}
if (PushButtons_Pressed(BUTTON2)) {
// add sequence to EEPROM
PWM_Set (0, 0, 0, 0);
PushButtons_Clear(BUTTON2);
if (Macros_Add(sequence)) {
ConfirmCommand();
} else Error();
}
} while (!PushButtons_Held(BUTTON2));
PushButtons_Clear(BUTTON2);
if (Macros_Count() != 0) {
WriteWord(STARTSEQADD, PLAYMACROS); // enable macro playback
} else {
// restore previous playback mode
WriteWord(STARTSEQADD, prevStart); // enable normal playback
}
ConfirmCommand();
ConfirmCommand();
InitMode();
}
void
Test( struct Custom* custom )
{
void* chip;
printf( "Testing with custom set to 0x%08lx\n", (ULONG) custom );
chip = AllocVec( sizeof( samples ), MEMF_CHIP );
CopyMem( samples, chip, sizeof( samples ) );
WriteLong( (ULONG*) &custom->aud[ 0 ].ac_ptr, (ULONG) chip );
WriteWord( (UWORD*) &custom->aud[ 0 ].ac_len, sizeof( samples ) / 2 );
WriteWord( (UWORD*) &custom->aud[ 0 ].ac_per, 447 );
WriteWord( (UWORD*) &custom->aud[ 0 ].ac_vol, 64 );
WriteWord( (UWORD*) &custom->dmacon, DMAF_SETCLR | DMAF_AUD0 | DMAF_MASTER );
Delay( 50 );
WriteWord( (UWORD*) &custom->dmacon, DMAF_AUD0 );
FreeVec( chip );
}
bool SaveVar(FILE* pf, CBotVar* pVar)
{
while ( true )
{
if ( pVar == NULL )
{
return WriteWord(pf, 0); // is a terminator
}
if ( !pVar->Save0State(pf)) return false; // common header
if ( !pVar->Save1State(pf) ) return false; // saves as the child class
pVar = pVar->GetNext();
}
}
void CPipeServer::GetMethodSignature()
{
void *method = (void *)ReadQword();
void *methodsignature = mono_method_signature(method);
char *sig = mono_signature_get_desc(methodsignature, TRUE);
int paramcount = mono_signature_get_param_count(methodsignature);
char **names=(char **)calloc(sizeof(char *), paramcount);
int i;
mono_method_get_param_names(method, (const char **)names);
WriteByte(paramcount);
for (i = 0; i < paramcount; i++)
{
if (names[i])
{
WriteByte(strlen(names[i]));
Write(names[i], strlen(names[i]));
}
else
WriteByte(0);
}
free(names);
WriteWord(strlen(sig));
Write(sig, strlen(sig));
g_free(sig);
//12/5/2014:send the returntype as well
void *returntype = mono_signature_get_return_type(methodsignature);
if (returntype)
{
char *tname = mono_type_get_name(returntype);
if (tname)
{
WriteByte(strlen(tname));
Write(tname, strlen(tname));
g_free(tname);
}
else
WriteByte(0);
}
else
WriteByte(0);
}
void CPipeServer::Object_GetClass()
{
void *object=(void *)ReadQword();
char *classname;
void *klass;
//OutputDebugStringA("MONOCMD_OBJECT_GETCLASS");
ExpectingAccessViolations=TRUE; //cause access violations to throw an exception
try
{
unsigned int i;
klass=mono_object_get_class(object);
classname=mono_class_get_name(klass);
//small test to see if the classname is readable
for (i=0; i<strlen(classname); i++)
{
char x=classname[i];
if (x=='\0')
break;
}
if (klass!=0)
{
WriteQword((UINT64)klass);
WriteWord(strlen(classname));
Write(classname, strlen(classname));
}
else
{
WriteQword(0);
}
}
catch (char *e)
{
OutputDebugStringA("Error getting the class:\n");
OutputDebugStringA(e);
WriteQword(0); //failure. Invalid object
}
ExpectingAccessViolations=FALSE; //back to normal behaviour
}
void CJavaEventServer::DynamicCodeGenerated(jvmtiEnv *jvmti_env, const char* name, const void* address, jint length)
{
Lock();
try
{
WriteByte(EVENTCMD_DYNAMICCODEGENERATED);
WriteQword((UINT_PTR)address);
WriteDword(length);
WriteWord((WORD)strlen(name));
Write((void *)name, (int)strlen(name));
}
catch (char *e)
{
OutputDebugStringA(e);
//no connection yet
}
Unlock();
}
void disp_gun(int nb, int x,int y) {
// nb is 0 for player 1 and 1 for player 2
if (old_bpp != display_cfg.bpp) {
sprite_gun[0] = SpriteGun1;
sprite_gun[1] = SpriteGun2;
if (display_cfg.bpp == 16 || display_cfg.bpp == 15) {
int n;
update_palette();
for (n=252; n<=254; n++) {
UINT16 res;
GET_PEN_FOR_COLOUR_16(
pal[n].r,
pal[n].g,
pal[n].b,
res);
WriteWord(&map[n*2],res);
}
}
old_bpp = display_cfg.bpp;
} else if (display_cfg.bpp == 32) {
int n;
update_palette();
for (n=252; n<=254; n++) {
UINT32 res;
GET_PEN_FOR_COLOUR_32(
pal[n].r,
pal[n].g,
pal[n].b,
res);
WriteLong(&map[n*4],res);
}
}
old_bpp = display_cfg.bpp;
switch(display_cfg.bpp) {
case 8: Draw16x16_Trans_8(sprite_gun[nb],x,y,0); update_palette(); break;
case 15:
case 16: Draw16x16_Trans_Mapped_16(sprite_gun[nb],x,y,map); break;
case 32: Draw16x16_Trans_Mapped_32(sprite_gun[nb],x,y,map); break;
}
}
static void ProcessInterrupts(void)
{ /* gestione interrupts */
if(pendingInterrupt==7 || pendingInterrupt>iMask)
{
if(!supervisor)
{
usp=(*sp);
(*sp)=ssp;
}
ExceptionIn(24+pendingInterrupt);
WriteLong((*sp)-4,(w32)pc-(long)theROM);
(*sp)-=6;
WriteWord(*sp,GetSR());
SetPC(theROM[24+pendingInterrupt]);
iMask=pendingInterrupt;
pendingInterrupt=0;
supervisor=true;
trace=false;
stopped=false;
}
}
