mirror of
git://xwords.git.sourceforge.net/gitroot/xwords/xwords
synced 2024-11-18 10:08:29 +01:00
966 lines
33 KiB
C
966 lines
33 KiB
C
/* -*-mode: C; fill-column: 78; c-basic-offset: 4; -*- */
|
|
/*
|
|
* Copyright 2004 by Eric House (fixin@peak.org). All rights reserved.
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
#include <Event.h>
|
|
#include <Menu.h>
|
|
#include <DateTime.h>
|
|
#include <VFSMgr.h>
|
|
|
|
#include "pace_man.h"
|
|
|
|
#include "palmmain.h" /* for custom event types */
|
|
#include "palmsavg.h"
|
|
|
|
/* Looks like I still need this??? */
|
|
void*
|
|
memcpy( void* dest, const void* src, unsigned long n )
|
|
{
|
|
void* oldDest = dest;
|
|
unsigned char* d = (unsigned char*)dest;
|
|
unsigned char* s = (unsigned char*)src;
|
|
|
|
FUNC_HEADER(memcpy);
|
|
|
|
if ( dest < src ) {
|
|
while ( n-- > 0 ) {
|
|
*d++ = *s++;
|
|
}
|
|
} else {
|
|
d += n;
|
|
s += n;
|
|
while ( n-- > 0 ) {
|
|
*--d = *--s;
|
|
}
|
|
}
|
|
|
|
FUNC_TAIL(memcpy);
|
|
return oldDest;
|
|
} /* memcpy */
|
|
|
|
unsigned long
|
|
Byte_Swap32( unsigned long l )
|
|
{
|
|
unsigned long result;
|
|
result = ((l >> 24) & 0xFF);
|
|
result |= ((l >> 8) & 0xFF00);
|
|
result |= ((l << 8) & 0xFF0000);
|
|
result |= ((l << 24) & 0xFF000000);
|
|
return result;
|
|
}
|
|
|
|
unsigned short
|
|
Byte_Swap16( unsigned short l )
|
|
{
|
|
unsigned short result;
|
|
result = ((l >> 8) & 0xFF);
|
|
result |= ((l << 8) & 0xFF00);
|
|
return result;
|
|
}
|
|
|
|
void
|
|
write_unaligned32( unsigned char* dest, unsigned long val )
|
|
{
|
|
int i;
|
|
dest += sizeof(val);
|
|
for ( i = 0; i < sizeof(val); ++i ) {
|
|
*--dest = val & 0x000000FF;
|
|
val >>= 8;
|
|
}
|
|
} /* write_unaligned32 */
|
|
|
|
void
|
|
write_unaligned16( unsigned char* dest, unsigned short val )
|
|
{
|
|
int i;
|
|
|
|
dest += sizeof(val);
|
|
for ( i = 0; i < sizeof(val); ++i ) {
|
|
*--dest = val & 0x00FF;
|
|
val >>= 8;
|
|
}
|
|
} /* write_unaligned16 */
|
|
|
|
#define write_unaligned8( p, v ) *(p) = v
|
|
|
|
unsigned short
|
|
read_unaligned16( const unsigned char* src )
|
|
{
|
|
int i;
|
|
unsigned short val = 0;
|
|
|
|
for ( i = 0; i < sizeof(val); ++i ) {
|
|
val <<= 8;
|
|
val |= *src++;
|
|
}
|
|
|
|
return val;
|
|
} /* read_unaligned16 */
|
|
|
|
#define read_unaligned8(cp) (*(cp))
|
|
|
|
unsigned long
|
|
read_unaligned32( const unsigned char* src )
|
|
{
|
|
int i;
|
|
unsigned long val = 0;
|
|
|
|
for ( i = 0; i < sizeof(val); ++i ) {
|
|
val <<= 8;
|
|
val |= *src++;
|
|
}
|
|
|
|
return val;
|
|
} /* read_unaligned32 */
|
|
|
|
/* Need to parse the format string */
|
|
Int16
|
|
StrPrintF( Char* s, const Char* formatStr, ... )
|
|
{
|
|
unsigned long* inArgs = ((unsigned long*)&formatStr) + 1;
|
|
|
|
return StrVPrintF( s, formatStr, (_Palm_va_list)inArgs );
|
|
} /* StrPrintF */
|
|
|
|
/* from file StringMgr.h */
|
|
Int16
|
|
StrVPrintF( Char* s, const Char* formatStr, _Palm_va_list arg )
|
|
{
|
|
Int16 result;
|
|
unsigned long* argv_arm = (unsigned long*)arg;
|
|
unsigned char argv_68k[48];
|
|
unsigned short done, isLong, innerDone, useArg;
|
|
unsigned char* str = (unsigned char*)formatStr;
|
|
unsigned short offset = 0;
|
|
|
|
for ( done = 0; !done; ) {
|
|
switch( *str++ ) {
|
|
case '\0':
|
|
done = 1;
|
|
break;
|
|
case '%':
|
|
isLong = useArg = 0;
|
|
for( innerDone = 0; !innerDone; ) {
|
|
unsigned char nxt = *str++;
|
|
switch( nxt ) {
|
|
case '%':
|
|
innerDone = 1;
|
|
break;
|
|
case 'l':
|
|
isLong = 1;
|
|
break;
|
|
case 's':
|
|
isLong = 1;
|
|
case 'd':
|
|
case 'x':
|
|
innerDone = 1;
|
|
useArg = 1;
|
|
break;
|
|
default:
|
|
if ( nxt >= '0' && nxt <= '9' ) {
|
|
/* accept %4x */
|
|
} else {
|
|
crash();
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( useArg ) {
|
|
unsigned long param;
|
|
param = *argv_arm++;
|
|
if ( isLong ) {
|
|
write_unaligned32( &argv_68k[offset], param );
|
|
offset += 4;
|
|
} else {
|
|
write_unaligned16( &argv_68k[offset],
|
|
(unsigned short)param );
|
|
offset += 2;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* now call the OS.... */
|
|
{
|
|
PNOState* sp = GET_CALLBACK_STATE();
|
|
STACK_START(unsigned char, stack, 12);
|
|
ADD_TO_STACK4(stack, s, 0);
|
|
ADD_TO_STACK4(stack, formatStr, 4);
|
|
ADD_TO_STACK4(stack, argv_68k, 8);
|
|
STACK_END(stack);
|
|
result = (Int16)
|
|
(*sp->call68KFuncP)( sp->emulStateP,
|
|
// NOT sysTrapStrPrintF !!!!
|
|
PceNativeTrapNo(sysTrapStrVPrintF),
|
|
stack, 12 );
|
|
}
|
|
|
|
return result;
|
|
} /* StrVPrintF */
|
|
|
|
/* Events. Need to translate back and forth since the ARM struct looks
|
|
* different from the 68K version yet we have to be able to come up with a 68K
|
|
* version for the OS at various times. May also need to translate inside
|
|
* event handlers since the OS will pass the 68K struct to us there.
|
|
*/
|
|
#define EVT_DATASIZE_68K 16 /* sez sizeof(event.data) in 68K code */
|
|
void
|
|
evt68k2evtARM( EventType* event, const unsigned char* evt68k )
|
|
{
|
|
event->eType = read_unaligned16( evt68k );
|
|
event->penDown = read_unaligned8( evt68k+2 );
|
|
event->tapCount = read_unaligned8( evt68k+3 );
|
|
event->screenX = read_unaligned16( evt68k+4 );
|
|
event->screenY = read_unaligned16( evt68k+6 );
|
|
|
|
evt68k += 8; /* skip to start of data union */
|
|
|
|
switch ( event->eType ) {
|
|
case frmLoadEvent:
|
|
case frmOpenEvent:
|
|
case frmCloseEvent:
|
|
case frmUpdateEvent:
|
|
XP_ASSERT( &event->data.frmLoad.formID ==
|
|
&event->data.frmClose.formID );
|
|
event->data.frmLoad.formID = read_unaligned16( evt68k );
|
|
event->data.frmUpdate.updateCode = read_unaligned16( evt68k + 2 );
|
|
break;
|
|
case keyDownEvent:
|
|
event->data.keyDown.chr = read_unaligned16( evt68k );
|
|
event->data.keyDown.keyCode = read_unaligned16( evt68k+2 );
|
|
event->data.keyDown.modifiers = read_unaligned16( evt68k+4 );
|
|
break;
|
|
|
|
case ctlSelectEvent:
|
|
event->data.ctlSelect.controlID = read_unaligned16(evt68k);
|
|
event->data.ctlSelect.pControl
|
|
= (ControlType*)read_unaligned32(evt68k+2);
|
|
event->data.ctlSelect.on = (Boolean)read_unaligned8(evt68k+6);
|
|
event->data.ctlSelect.reserved1 = read_unaligned8(evt68k+7);
|
|
event->data.ctlSelect.value = read_unaligned16(evt68k+8);
|
|
break;
|
|
|
|
case winExitEvent:
|
|
case winEnterEvent:
|
|
XP_ASSERT( &event->data.winEnter.enterWindow ==
|
|
&event->data.winExit.enterWindow );
|
|
event->data.winEnter.enterWindow
|
|
= (WinHandle)read_unaligned32( evt68k );
|
|
event->data.winEnter.exitWindow
|
|
= (WinHandle)read_unaligned32( evt68k+4 );
|
|
break;
|
|
|
|
// case penDownEvent: // stuff above is enough
|
|
// case penMoveEvent: // stuff above is enough
|
|
// case penUpEvent: // stuff above is enough
|
|
case menuEvent:
|
|
event->data.menu.itemID = read_unaligned16( evt68k );
|
|
break;
|
|
case sclRepeatEvent:
|
|
event->data.sclRepeat.scrollBarID = read_unaligned16( evt68k );
|
|
event->data.sclRepeat.pScrollBar
|
|
= (ScrollBarType*)read_unaligned32( evt68k+2 );
|
|
event->data.sclRepeat.value = read_unaligned16( evt68k+6 );
|
|
event->data.sclRepeat.newValue = read_unaligned16( evt68k+8 );
|
|
event->data.sclRepeat.time = read_unaligned32( evt68k+10 );
|
|
break;
|
|
/* Crosswords events */
|
|
case newGameCancelEvent:
|
|
break;
|
|
case openSavedGameEvent:
|
|
((OpenSavedGameData*)(&event->data.generic))->newGameIndex =
|
|
read_unaligned16( evt68k );
|
|
break;
|
|
case newGameOkEvent:
|
|
case loadGameEvent:
|
|
break;
|
|
/* case boardRedrawEvt: */
|
|
// doResizeWinEvent
|
|
case prefsChangedEvent:
|
|
break;
|
|
|
|
default: /* copy the data as binary so we can copy it back later */
|
|
memcpy( &event->data, evt68k, EVT_DATASIZE_68K );
|
|
break;
|
|
}
|
|
} /* evt68k2evtARM */
|
|
|
|
void
|
|
evtArm2evt68K( unsigned char* evt68k, const EventType* event )
|
|
{
|
|
write_unaligned16( evt68k, event->eType );
|
|
write_unaligned8( evt68k + 2, event->penDown );
|
|
write_unaligned8( evt68k + 3, event->tapCount );
|
|
write_unaligned16( evt68k + 4, event->screenX );
|
|
write_unaligned16( evt68k + 6, event->screenY );
|
|
|
|
evt68k += 8;
|
|
|
|
switch ( event->eType ) {
|
|
case frmLoadEvent:
|
|
case frmOpenEvent:
|
|
case frmCloseEvent:
|
|
case frmUpdateEvent:
|
|
XP_ASSERT( &event->data.frmLoad.formID
|
|
== &event->data.frmOpen.formID );
|
|
XP_ASSERT( &event->data.frmLoad.formID
|
|
== &event->data.frmClose.formID );
|
|
XP_ASSERT( &event->data.frmLoad.formID
|
|
== &event->data.frmUpdate.formID );
|
|
write_unaligned16( evt68k, event->data.frmLoad.formID );
|
|
write_unaligned16( evt68k + 2, event->data.frmUpdate.updateCode );
|
|
break;
|
|
case keyDownEvent:
|
|
write_unaligned16( evt68k, event->data.keyDown.chr );
|
|
write_unaligned16( evt68k+2, event->data.keyDown.keyCode );
|
|
write_unaligned16( evt68k+4, event->data.keyDown.modifiers );
|
|
break;
|
|
|
|
case ctlSelectEvent:
|
|
write_unaligned16( evt68k, event->data.ctlSelect.controlID );
|
|
write_unaligned32( evt68k+2,
|
|
(unsigned long)event->data.ctlSelect.pControl );
|
|
write_unaligned8( evt68k+6, event->data.ctlSelect.on );
|
|
write_unaligned8( evt68k+7, event->data.ctlSelect.reserved1 );
|
|
write_unaligned16( evt68k+8, event->data.ctlSelect.value );
|
|
break;
|
|
|
|
case winExitEvent:
|
|
case winEnterEvent:
|
|
XP_ASSERT( &event->data.winEnter.enterWindow ==
|
|
&event->data.winExit.enterWindow );
|
|
write_unaligned32( evt68k,
|
|
(unsigned long)event->data.winEnter.enterWindow );
|
|
write_unaligned32( evt68k+4,
|
|
(unsigned long)event->data.winEnter.exitWindow );
|
|
break;
|
|
|
|
// case penDownEvent: // stuff above is enough
|
|
// case penMoveEvent: // stuff above is enough
|
|
// case penUpEvent: // stuff above is enough
|
|
case menuEvent:
|
|
write_unaligned16( evt68k, event->data.menu.itemID );
|
|
break;
|
|
case sclRepeatEvent:
|
|
write_unaligned16( evt68k, event->data.sclRepeat.scrollBarID );
|
|
write_unaligned32( evt68k+2,
|
|
(unsigned long)event->data.sclRepeat.pScrollBar );
|
|
write_unaligned16( evt68k+6, event->data.sclRepeat.value );
|
|
write_unaligned16( evt68k+8, event->data.sclRepeat.newValue );
|
|
write_unaligned32( evt68k+10, event->data.sclRepeat.time );
|
|
break;
|
|
/* Crosswords events */
|
|
case newGameCancelEvent:
|
|
break;
|
|
case openSavedGameEvent:
|
|
write_unaligned16( evt68k,
|
|
((OpenSavedGameData*)
|
|
(&event->data.generic))->newGameIndex );
|
|
break;
|
|
case newGameOkEvent:
|
|
case loadGameEvent:
|
|
break;
|
|
/* case boardRedrawEvt: */
|
|
// doResizeWinEvent
|
|
case prefsChangedEvent:
|
|
break;
|
|
|
|
default: /* copy the data as binary so we can copy it back later */
|
|
memcpy( evt68k, &event->data, EVT_DATASIZE_68K );
|
|
break;
|
|
}
|
|
|
|
} /* evtArm2evt68K */
|
|
|
|
/* from file SystemMgr.h */
|
|
Boolean
|
|
SysHandleEvent( EventPtr eventP )
|
|
{
|
|
Boolean result;
|
|
EventType event68K;
|
|
FUNC_HEADER(SysHandleEvent);
|
|
|
|
evtArm2evt68K( (unsigned char*)&event68K, eventP );
|
|
|
|
{
|
|
PNOState* sp = GET_CALLBACK_STATE();
|
|
STACK_START(unsigned char, stack, 4);
|
|
ADD_TO_STACK4(stack, &event68K, 0);
|
|
STACK_END(stack);
|
|
result = (Boolean)(*sp->call68KFuncP)( sp->emulStateP,
|
|
PceNativeTrapNo(sysTrapSysHandleEvent),
|
|
stack, 4 );
|
|
}
|
|
FUNC_TAIL(SysHandleEvent);
|
|
return result;
|
|
} /* SysHandleEvent */
|
|
|
|
unsigned long
|
|
handlerEntryPoint( const void* emulStateP,
|
|
void* userData68KP,
|
|
Call68KFuncType* call68KFuncP )
|
|
{
|
|
unsigned long* data = (unsigned long*)userData68KP;
|
|
FormEventHandlerType* handler
|
|
= (FormEventHandlerType*)read_unaligned32( (unsigned char*)&data[0] );
|
|
PNOState* state = getStorageLoc();
|
|
unsigned long oldR10;
|
|
EventType evtArm;
|
|
Boolean result;
|
|
|
|
/* set up stack here too? */
|
|
asm( "mov %0, r10" : "=r" (oldR10) );
|
|
asm( "mov r10, %0" : : "r" (state->gotTable) );
|
|
|
|
evt68k2evtARM( &evtArm,
|
|
(unsigned char*)read_unaligned32( (unsigned char*)&data[1]) );
|
|
|
|
result = (*handler)(&evtArm);
|
|
|
|
asm( "mov r10, %0" : : "r" (oldR10) );
|
|
|
|
return (unsigned long)result;
|
|
}
|
|
|
|
/* The stub wants to look like this:
|
|
static Boolean
|
|
FormEventHandlerType( EventType *eventP )
|
|
{
|
|
unsigned long data[] = { armEvtHandler, eventP };
|
|
return (Boolean)PceNativeCall( handlerEntryPoint, (void*)data );
|
|
}
|
|
*/
|
|
static unsigned char*
|
|
makeHandlerStub( FormEventHandlerType* handlerArm )
|
|
{
|
|
unsigned char* stub;
|
|
unsigned char code_68k[] = {
|
|
/* 0:*/ 0x4e, 0x56, 0xff, 0xf8, // linkw %fp,#-8
|
|
/* 4:*/ 0x20, 0x2e, 0x00, 0x08, // movel %fp@(8),%d0
|
|
/* 8:*/ 0x2d, 0x7c, 0x11, 0x22, 0x33, 0x44, // movel #287454020,%fp@(-8)
|
|
/*14:*/ 0xff, 0xf8, // ????? REQUIRED!!!!
|
|
/*16:*/ 0x2d, 0x40, 0xff, 0xfc, // movel %d0,%fp@(-4)
|
|
/*20:*/ 0x48, 0x6e, 0xff, 0xf8, // pea %fp@(-8)
|
|
/*24:*/ 0x2f, 0x3c, 0x55, 0x66, 0x77, 0x88, // movel #1432778632,%sp@-
|
|
/*30:*/ 0x4e, 0x4f, // trap #15
|
|
/*32:*/ 0xa4, 0x5a, // 0122132
|
|
/*34:*/ 0x02, 0x40, 0x00, 0xff, // andiw #255,%d0
|
|
/*38:*/ 0x4e, 0x5e, // unlk %fp
|
|
/*40:*/ 0x4e, 0x75 // rts
|
|
};
|
|
|
|
stub = MemPtrNew( sizeof(code_68k) );
|
|
memcpy( stub, code_68k, sizeof(code_68k) );
|
|
|
|
write_unaligned32( &stub[10],
|
|
/* replace 0x11223344 */
|
|
(unsigned long)handlerArm );
|
|
write_unaligned32( &stub[26],
|
|
/* replace 0x55667788 */
|
|
(unsigned long)handlerEntryPoint );
|
|
/* Need to register this stub so it can be freed (once leaking ceases to
|
|
be ok on PalmOS) */
|
|
|
|
return (unsigned char*)stub;
|
|
} /* makeHandlerStub */
|
|
|
|
void
|
|
FrmSetEventHandler( FormType* formP, FormEventHandlerType* handler )
|
|
{
|
|
FUNC_HEADER(FrmSetEventHandler);
|
|
{
|
|
PNOState* sp = GET_CALLBACK_STATE();
|
|
unsigned char* handlerStub = makeHandlerStub( handler );
|
|
STACK_START(unsigned char, stack, 8);
|
|
ADD_TO_STACK4(stack, formP, 0);
|
|
ADD_TO_STACK4(stack, handlerStub, 4);
|
|
STACK_END(stack);
|
|
(*sp->call68KFuncP)( sp->emulStateP,
|
|
PceNativeTrapNo(sysTrapFrmSetEventHandler),
|
|
stack, 8 );
|
|
}
|
|
FUNC_TAIL(FrmSetEventHandler);
|
|
} /* FrmSetEventHandler */
|
|
|
|
void
|
|
flipRect( RectangleType* rout, const RectangleType* rin )
|
|
{
|
|
rout->topLeft.x = Byte_Swap16(rin->topLeft.x);
|
|
rout->topLeft.y = Byte_Swap16(rin->topLeft.y);
|
|
rout->extent.x = Byte_Swap16(rin->extent.x);
|
|
rout->extent.y = Byte_Swap16(rin->extent.y);
|
|
} /* flipRect */
|
|
|
|
void
|
|
flipFieldAttr( FieldAttrType* fout, const FieldAttrType* fin )
|
|
{
|
|
/* It's a bleeding bitfield */
|
|
} /* flipFieldAttr */
|
|
|
|
void
|
|
flipEngSocketFromArm( unsigned char* sout, const ExgSocketType* sin )
|
|
{
|
|
write_unaligned16( &sout[0], sin->libraryRef ); // UInt16 libraryRef;
|
|
write_unaligned32( &sout[2], sin->socketRef ); // UInt32 socketRef;
|
|
write_unaligned32( &sout[6], sin->target ); // UInt32 target;
|
|
write_unaligned32( &sout[10], sin->count ); // UInt32 count;
|
|
|
|
write_unaligned32( &sout[14], sin->length );// UInt32 length;
|
|
|
|
write_unaligned32( &sout[18], sin->time );// UInt32 time;
|
|
write_unaligned32( &sout[22], sin->appData ); // UInt32 appData;
|
|
write_unaligned32( &sout[26], sin->goToCreator ); // UInt32 goToCreator;
|
|
write_unaligned16( &sout[30], sin->goToParams.dbCardNo ); // UInt16 goToParams.dbCardNo;
|
|
write_unaligned32( &sout[32], sin->goToParams.dbID ); // LocalID goToParams.dbID;
|
|
write_unaligned16( &sout[36], sin->goToParams.recordNum ); // UInt16 goToParams.recordNum;
|
|
write_unaligned32( &sout[38], sin->goToParams.uniqueID ); // UInt32 goToParams.uniqueID;
|
|
write_unaligned32( &sout[42], sin->goToParams.matchCustom ); // UInt32 goToParams.matchCustom;
|
|
/* bitfield. All we can do is copy the whole thing, assuming it's 16
|
|
bits, and pray that no arm code wants to to use it. */
|
|
write_unaligned16( &sout[46], *(UInt16*)((unsigned char*)&sin->goToParams.matchCustom)
|
|
+ sizeof(sin->goToParams.matchCustom) );
|
|
write_unaligned32( &sout[48], (unsigned long)sin->description ); // Char *description;
|
|
write_unaligned32( &sout[52], (unsigned long)sin->type ); // Char *type;
|
|
write_unaligned32( &sout[56], (unsigned long)sin->name ); // Char *name;
|
|
} /* flipEngSocketFromArm */
|
|
|
|
void
|
|
flipEngSocketToArm( ExgSocketType* sout, const unsigned char* sin )
|
|
{
|
|
sout->libraryRef = read_unaligned16( &sin[0] );
|
|
sout->socketRef = read_unaligned32( &sin[2] );
|
|
sout->target = read_unaligned32( &sin[6] );
|
|
sout->count = read_unaligned32( &sin[10] );
|
|
sout->length = read_unaligned32( &sin[14] );
|
|
sout->time = read_unaligned32( &sin[18] );
|
|
sout->appData = read_unaligned32( &sin[22] );
|
|
sout->goToCreator = read_unaligned32( &sin[26] );
|
|
sout->goToParams.dbCardNo = read_unaligned16( &sin[30] );
|
|
sout->goToParams.dbID = read_unaligned32( &sin[32] );
|
|
sout->goToParams.recordNum = read_unaligned16( &sin[36] );
|
|
sout->goToParams.uniqueID = read_unaligned32( &sin[38] );
|
|
sout->goToParams.matchCustom = read_unaligned32( &sin[42] );
|
|
/* bitfield. All we can do is copy the whole thing, assuming it's 16
|
|
bits, and pray that no arm code wants to to use it. */
|
|
*(UInt16*)(((unsigned char*)&sout->goToParams.matchCustom)
|
|
+ sizeof(sout->goToParams.matchCustom)) = read_unaligned16( &sin[46] );
|
|
sout->description = (Char*)read_unaligned32( &sin[48] );
|
|
sout->type = (Char*)read_unaligned32( &sin[52] );
|
|
sout->name = (Char*)read_unaligned32( &sin[56] );
|
|
} /* flipEngSocketToArm */
|
|
|
|
void
|
|
flipFileInfoFromArm( unsigned char* fiout, const FileInfoType* fiin )
|
|
{
|
|
write_unaligned32( &fiout[0], fiin->attributes );
|
|
write_unaligned32( &fiout[4], (unsigned long)fiin->nameP );
|
|
write_unaligned16( &fiout[8], fiin->nameBufLen );
|
|
}
|
|
|
|
void
|
|
flipFileInfoToArm( FileInfoType* fout, const unsigned char* fin )
|
|
{
|
|
fout->attributes = read_unaligned32( &fin[0] );
|
|
fout->nameP = (Char*)read_unaligned32( &fin[4] );
|
|
fout->nameBufLen = read_unaligned16( &fin[8] );
|
|
} /* flipFileInfo */
|
|
|
|
/* from file List.h */
|
|
void
|
|
LstSetListChoices( ListType* listP, Char** itemsText, Int16 numItems )
|
|
{
|
|
FUNC_HEADER(LstSetListChoices);
|
|
/* var decls */
|
|
/* swapIns */
|
|
{
|
|
XP_U16 i;
|
|
PNOState* sp = GET_CALLBACK_STATE();
|
|
STACK_START(unsigned char, stack, 10);
|
|
/* pushes */
|
|
ADD_TO_STACK4(stack, listP, 0);
|
|
ADD_TO_STACK4(stack, itemsText, 4);
|
|
ADD_TO_STACK2(stack, numItems, 8);
|
|
STACK_END(stack);
|
|
|
|
for ( i = 0; i < numItems; ++i ) {
|
|
itemsText[i] = (Char*)Byte_Swap32( (unsigned long)itemsText[i] );
|
|
}
|
|
|
|
(*sp->call68KFuncP)( sp->emulStateP,
|
|
PceNativeTrapNo(sysTrapLstSetListChoices),
|
|
stack, 10 );
|
|
/* swapOuts */
|
|
}
|
|
FUNC_TAIL(LstSetListChoices);
|
|
EMIT_NAME("LstSetListChoices","'L','s','t','S','e','t','L','i','s','t','C','h','o','i','c','e','s'");
|
|
} /* LstSetListChoices */
|
|
|
|
static void
|
|
params68KtoParamsArm( SysNotifyParamType* paramsArm,
|
|
const unsigned char* params68K )
|
|
{
|
|
paramsArm->notifyType = read_unaligned32( ¶ms68K[0] );
|
|
paramsArm->broadcaster = read_unaligned32( ¶ms68K[4] );
|
|
paramsArm->notifyDetailsP = (void*)read_unaligned32( ¶ms68K[8] );
|
|
paramsArm->userDataP = (void*)read_unaligned32( ¶ms68K[12] );
|
|
paramsArm->handled = read_unaligned8( ¶ms68K[16] );
|
|
|
|
/* I don't do anything with the data passed in, so no need to swap it...
|
|
But that'd change for others: make an ARM-corrected copy of the
|
|
contents of notifyDetailsP if your handler will use it. */
|
|
switch( paramsArm->notifyType ) {
|
|
case sysNotifyVolumeUnmountedEvent:
|
|
case sysNotifyVolumeMountedEvent:
|
|
break;
|
|
#ifdef FEATURE_SILK
|
|
case sysNotifyDisplayChangeEvent:
|
|
break;
|
|
#endif
|
|
}
|
|
|
|
} /* params68KtoParamsArm */
|
|
|
|
static void
|
|
paramsArmtoParams68K( unsigned char* params68K,
|
|
const SysNotifyParamType* armParams )
|
|
{
|
|
write_unaligned8( ¶ms68K[16], armParams->handled );
|
|
} /* paramsArmtoParams68K */
|
|
|
|
unsigned long
|
|
notifyEntryPoint( const void* emulStateP,
|
|
void* userData68KP,
|
|
Call68KFuncType* call68KFuncP )
|
|
{
|
|
unsigned long* data = (unsigned long*)userData68KP;
|
|
SysNotifyProcPtr callback
|
|
= (SysNotifyProcPtr)read_unaligned32( (unsigned char*)&data[0] );
|
|
SysNotifyParamType armParams;
|
|
PNOState* state = getStorageLoc();
|
|
unsigned long oldR10;
|
|
unsigned char* params68K;
|
|
Err result;
|
|
|
|
/* set up stack here too? */
|
|
asm( "mov %0, r10" : "=r" (oldR10) );
|
|
asm( "mov r10, %0" : : "r" (state->gotTable) );
|
|
|
|
XP_ASSERT( emulStateP == state->emulStateP );
|
|
XP_ASSERT( call68KFuncP == state->call68KFuncP );
|
|
|
|
params68K = (unsigned char*)read_unaligned32((unsigned char*)&data[1]);
|
|
params68KtoParamsArm( &armParams, params68K );
|
|
|
|
result = (*callback)(&armParams);
|
|
|
|
/* at least need to write 'handled' back out... */
|
|
paramsArmtoParams68K( params68K, &armParams );
|
|
|
|
asm( "mov r10, %0" : : "r" (oldR10) );
|
|
|
|
return (unsigned long)result;
|
|
} /* notifyEntryPoint */
|
|
|
|
/* The stub wants to look like this:
|
|
static Err SysNotifyProc(SysNotifyParamType *notifyParamsP)
|
|
{
|
|
unsigned long data[] = { armNotifyHandler, notifyParamsP };
|
|
return (Err)PceNativeCall( handlerEntryPoint, (void*)data );
|
|
}
|
|
*/
|
|
static unsigned char*
|
|
makeNotifyStub( SysNotifyProcPtr callback )
|
|
{
|
|
unsigned char* stub;
|
|
unsigned char code_68k[] = {
|
|
/* 0:*/ 0x4e, 0x56, 0xff, 0xf8, // linkw %fp,#-8
|
|
/* 4:*/ 0x20, 0x2e, 0x00, 0x08, // movel %fp@(8),%d0
|
|
/* 8:*/ 0x2d, 0x7c, 0x11, 0x22, 0x33, 0x44, // movel #287454020,%fp@(-8)
|
|
/*14:*/ 0xff, 0xf8, // ????? REQUIRED!!!!
|
|
/*16:*/ 0x2d, 0x40, 0xff, 0xfc, // movel %d0,%fp@(-4)
|
|
/*20:*/ 0x48, 0x6e, 0xff, 0xf8, // pea %fp@(-8)
|
|
/*24:*/ 0x2f, 0x3c, 0x55, 0x66, 0x77, 0x88, // movel #1432778632,%sp@-
|
|
/*30:*/ 0x4e, 0x4f, // trap #15
|
|
/*32:*/ 0xa4, 0x5a, // 0122132
|
|
/*34:*/ 0x4e, 0x5e, // unlk %fp
|
|
/*36:*/ 0x4e, 0x75 // rts
|
|
};
|
|
|
|
stub = MemPtrNew( sizeof(code_68k) );
|
|
memcpy( stub, code_68k, sizeof(code_68k) );
|
|
|
|
write_unaligned32( &stub[10],
|
|
/* replace 0x11223344 */
|
|
(unsigned long)callback );
|
|
write_unaligned32( &stub[26],
|
|
/* replace 0x55667788 */
|
|
(unsigned long)notifyEntryPoint );
|
|
/* Need to register this stub so it can be freed (once leaking ceases to
|
|
be ok on PalmOS) */
|
|
|
|
return (unsigned char*)stub;
|
|
} /* makeNotifyStub */
|
|
|
|
/* from file NotifyMgr.h */
|
|
Err
|
|
SysNotifyRegister( UInt16 cardNo, LocalID dbID, UInt32 notifyType,
|
|
SysNotifyProcPtr callbackP, Int8 priority, void* userDataP )
|
|
{
|
|
Err result;
|
|
FUNC_HEADER(SysNotifyRegister);
|
|
/* var decls */
|
|
/* swapIns */
|
|
{
|
|
PNOState* sp = GET_CALLBACK_STATE();
|
|
unsigned char* handlerStub = makeNotifyStub( callbackP );
|
|
STACK_START(unsigned char, stack, 20);
|
|
/* pushes */
|
|
ADD_TO_STACK2(stack, cardNo, 0);
|
|
ADD_TO_STACK4(stack, dbID, 2);
|
|
ADD_TO_STACK4(stack, notifyType, 6);
|
|
ADD_TO_STACK4(stack, handlerStub, 10);
|
|
ADD_TO_STACK1(stack, priority, 14);
|
|
ADD_TO_STACK4(stack, userDataP, 16);
|
|
STACK_END(stack);
|
|
result = (Err)(*sp->call68KFuncP)( sp->emulStateP,
|
|
PceNativeTrapNo(sysTrapSysNotifyRegister),
|
|
stack, 20 );
|
|
/* swapOuts */
|
|
}
|
|
FUNC_TAIL(SysNotifyRegister);
|
|
EMIT_NAME("SysNotifyRegister","'S','y','s','N','o','t','i','f','y','R','e','g','i','s','t','e','r'");
|
|
return result;
|
|
} /* SysNotifyRegister */
|
|
|
|
unsigned long
|
|
listDrawEntryPoint( const void* emulStateP,
|
|
void* userData68KP,
|
|
Call68KFuncType* call68KFuncP )
|
|
{
|
|
unsigned long* data = (unsigned long*)userData68KP;
|
|
ListDrawDataFuncPtr listDrawProc
|
|
= (ListDrawDataFuncPtr)read_unaligned32( (unsigned char*)&data[0] );
|
|
PNOState* state = getStorageLoc();
|
|
unsigned long oldR10;
|
|
Int16 index;
|
|
char** itemsText;
|
|
RectangleType rectArm;
|
|
|
|
/* set up stack here too? */
|
|
asm( "mov %0, r10" : "=r" (oldR10) );
|
|
asm( "mov r10, %0" : : "r" (state->gotTable) );
|
|
|
|
flipRect( &rectArm, (RectanglePtr)read_unaligned32( (unsigned char*)&data[2] ) );
|
|
|
|
XP_ASSERT( emulStateP == state->emulStateP );
|
|
XP_ASSERT( call68KFuncP == state->call68KFuncP );
|
|
|
|
index = (Int16)read_unaligned32( (unsigned char*)&data[1] );
|
|
itemsText = (char**)read_unaligned32( (unsigned char*)&data[3] );
|
|
(*listDrawProc)( index, &rectArm, itemsText );
|
|
|
|
asm( "mov r10, %0" : : "r" (oldR10) );
|
|
|
|
return 0L; /* no result to return */
|
|
} /* listDrawEntryPoint */
|
|
|
|
static unsigned char*
|
|
makeListDrawStub( ListDrawDataFuncPtr func )
|
|
{
|
|
/* called function looks like this:
|
|
void listDrawFunc(Int16 index, RectanglePtr bounds, char** itemsText)
|
|
{
|
|
unsigned long data[] = { func, index,
|
|
bounds, itemsText };
|
|
return (Err)PceNativeCall( listDrawEntryPoint, (void*)data );
|
|
}
|
|
*/
|
|
unsigned char* stub;
|
|
unsigned char code_68k[] = {
|
|
/* 0:*/ 0x4e, 0x56, 0xff, 0xf0, // linkw %fp,#-16
|
|
/* 4:*/ 0x30, 0x2e, 0x00, 0x08, // movew %fp@(8),%d0
|
|
/* 8:*/ 0x22, 0x2e, 0x00, 0x0a, // movel %fp@(10),%d1
|
|
/* c:*/ 0x24, 0x2e, 0x00, 0x0e, // movel %fp@(14),%d2
|
|
/*10:*/ 0x2d, 0x7c, 0x11, 0x22,0x33,0x44,// movel #287454020,%fp@(-16)
|
|
/*16:*/ 0xff, 0xf0,
|
|
/*18:*/ 0x30, 0x40, // moveaw %d0,%a0
|
|
/*1a:*/ 0x2d, 0x48, 0xff, 0xf4, // movel %a0,%fp@(-12)
|
|
/*1e:*/ 0x2d, 0x41, 0xff, 0xf8, // movel %d1,%fp@(-8)
|
|
/*22:*/ 0x2d, 0x42, 0xff, 0xfc, // movel %d2,%fp@(-4)
|
|
/*26:*/ 0x48, 0x6e, 0xff, 0xf0, // pea %fp@(-16)
|
|
/*2a:*/ 0x2f, 0x3c, 0x55, 0x66, 0x77, 0x88, // movel #1432778632,%sp@-
|
|
/*30:*/ 0x4e, 0x4f, // trap #15
|
|
/*32:*/ 0xa4, 0x5a, // 0122132
|
|
/*34:*/ 0x4e, 0x5e, // unlk %fp
|
|
/*36:*/ 0x4e, 0x75 // rts
|
|
};
|
|
stub = MemPtrNew( sizeof(code_68k) );
|
|
memcpy( stub, code_68k, sizeof(code_68k) );
|
|
|
|
write_unaligned32( &stub[0x12],
|
|
/* replace 0x11223344 */
|
|
(unsigned long)func );
|
|
write_unaligned32( &stub[0x2c],
|
|
/* replace 0x55667788 */
|
|
(unsigned long)listDrawEntryPoint );
|
|
|
|
return (unsigned char*)stub;
|
|
} /* makeListDrawStub */
|
|
|
|
/* from file List.h */
|
|
void
|
|
LstSetDrawFunction( ListType* listP, ListDrawDataFuncPtr func )
|
|
{
|
|
FUNC_HEADER(LstSetDrawFunction);
|
|
/* var decls */
|
|
/* swapIns */
|
|
{
|
|
PNOState* sp = GET_CALLBACK_STATE();
|
|
unsigned char* stub = makeListDrawStub( func );
|
|
STACK_START(unsigned char, stack, 8);
|
|
/* pushes */
|
|
ADD_TO_STACK4(stack, listP, 0);
|
|
ADD_TO_STACK4(stack, stub, 4);
|
|
STACK_END(stack);
|
|
(*sp->call68KFuncP)( sp->emulStateP,
|
|
PceNativeTrapNo(sysTrapLstSetDrawFunction),
|
|
stack, 8 );
|
|
/* swapOuts */
|
|
}
|
|
FUNC_TAIL(LstSetDrawFunction);
|
|
EMIT_NAME("LstSetDrawFunction","'L','s','t','S','e','t','D','r','a','w','F','u','n','c','t','i','o','n'");
|
|
} /* LstSetDrawFunction */
|
|
|
|
void
|
|
flipDateTimeToArm( DateTimeType* out, const unsigned char* in )
|
|
{
|
|
const DateTimeType* inp = (DateTimeType*)in;
|
|
out->second = Byte_Swap16( inp->second );
|
|
out->minute = Byte_Swap16( inp->minute );
|
|
out->hour = Byte_Swap16( inp->hour );
|
|
out->day = Byte_Swap16( inp->day );
|
|
out->month = Byte_Swap16( inp->month );
|
|
out->year = Byte_Swap16( inp->year );
|
|
out->weekDay = Byte_Swap16( inp->weekDay );
|
|
}
|
|
|
|
static unsigned long
|
|
exgWriteEntry( const void* emulStateP,
|
|
void* userData68KP,
|
|
Call68KFuncType* call68KFuncP )
|
|
{
|
|
unsigned long* data = (unsigned long*)userData68KP;
|
|
unsigned long oldR10;
|
|
ExgDBWriteProcPtr exgProc
|
|
= (ExgDBWriteProcPtr)read_unaligned32( (unsigned char*)&data[0] );
|
|
PNOState* state = getStorageLoc();
|
|
UInt32* sizeP;
|
|
Err err;
|
|
|
|
/* set up stack here too? */
|
|
asm( "mov %0, r10" : "=r" (oldR10) );
|
|
asm( "mov r10, %0" : : "r" (state->gotTable) );
|
|
|
|
XP_ASSERT( emulStateP == state->emulStateP );
|
|
XP_ASSERT( call68KFuncP == state->call68KFuncP );
|
|
|
|
sizeP = (UInt32*)read_unaligned32( (unsigned char*)&data[2] );
|
|
SWAP4_NON_NULL_OUT(sizeP);
|
|
err = (*exgProc)( (const void*)read_unaligned32((unsigned char*)&data[1]),
|
|
sizeP,
|
|
(void*)read_unaligned32( (unsigned char*)&data[3] ) );
|
|
SWAP4_NON_NULL_IN(sizeP);
|
|
|
|
asm( "mov r10, %0" : : "r" (oldR10) );
|
|
|
|
return (unsigned long)err; /* no result to return */
|
|
} /* exgWriteEntry */
|
|
|
|
static void
|
|
makeExgWriteStub( ExgDBWriteProcPtr proc, unsigned char* stub, XP_U16 stubSize )
|
|
{
|
|
/* Err ExgDBWriteProc( const void *dataP, UInt32 *sizeP, void *userDataP) */
|
|
/* { */
|
|
/* unsigned long data[] = { */
|
|
/* (unsigned long)0x11223344, */
|
|
/* (unsigned long)dataP, */
|
|
/* (unsigned long)sizeP, */
|
|
/* (unsigned long)userDataP */
|
|
/* }; */
|
|
/* return (Err)PceNativeCall( (void*)0x55667788, (void*)data ); */
|
|
/* } */
|
|
unsigned char code_68k[] = {
|
|
/* 0:*/ 0x4e, 0x56, 0xff, 0xf0, /* linkw %fp,#-16 */
|
|
/* 4:*/ 0x20, 0x2e, 0x00, 0x08, /* movel %fp@(8),%d0 */
|
|
/* 8:*/ 0x22, 0x2e, 0x00, 0x0c, /* movel %fp@(12),%d1 */
|
|
/* c:*/ 0x24, 0x2e, 0x00, 0x10, /* movel %fp@(16),%d2 */
|
|
/*10:*/ 0x2d, 0x7c, 0x11, 0x22, 0x33, 0x44,/*movel #287454020,%fp@(-16)*/
|
|
/*16:*/ 0xff, 0xf0,
|
|
/*18:*/ 0x2d, 0x40, 0xff, 0xf4, /* movel %d0,%fp@(-12) */
|
|
/*1c:*/ 0x2d, 0x41, 0xff, 0xf8, /* movel %d1,%fp@(-8) */
|
|
/*20:*/ 0x2d, 0x42, 0xff, 0xfc, /* movel %d2,%fp@(-4) */
|
|
/*24:*/ 0x48, 0x6e, 0xff, 0xf0, /* pea %fp@(-16) */
|
|
/*28:*/ 0x2f, 0x3c, 0x55, 0x66, 0x77, 0x88, /* movel #1432778632,%sp@- */
|
|
/*2e:*/ 0x4e, 0x4f, /* trap #15 */
|
|
/*30:*/ 0xa4, 0x5a, /* 0122132 */
|
|
/*32:*/ 0x4e, 0x5e, /* unlk %fp */
|
|
/*34:*/ 0x4e, 0x75 /* rts */
|
|
};
|
|
XP_ASSERT( sizeof(code_68k) <= stubSize );
|
|
memcpy( stub, code_68k, sizeof(code_68k) );
|
|
|
|
write_unaligned32( &stub[0x12],
|
|
/* replace 0x11223344 */
|
|
(unsigned long)proc );
|
|
write_unaligned32( &stub[0x2a],
|
|
/* replace 0x55667788 */
|
|
(unsigned long)exgWriteEntry );
|
|
} /* makeExgWriteStub */
|
|
|
|
/* from file ExgMgr.h */
|
|
Err
|
|
ExgDBWrite( ExgDBWriteProcPtr writeProcP, void* userDataP,
|
|
const char* nameP, LocalID dbID, UInt16 cardNo )
|
|
{
|
|
Err result;
|
|
FUNC_HEADER(ExgDBWrite);
|
|
/* var decls */
|
|
/* swapIns */
|
|
{
|
|
PNOState* sp = GET_CALLBACK_STATE();
|
|
unsigned char stub[0x36];
|
|
STACK_START(unsigned char, stack, 18);
|
|
makeExgWriteStub( writeProcP, stub, sizeof(stub) );
|
|
|
|
/* pushes */
|
|
ADD_TO_STACK4(stack, stub, 0);
|
|
ADD_TO_STACK4(stack, userDataP, 4);
|
|
ADD_TO_STACK4(stack, nameP, 8);
|
|
ADD_TO_STACK4(stack, dbID, 12);
|
|
ADD_TO_STACK2(stack, cardNo, 16);
|
|
STACK_END(stack);
|
|
result = (Err)(*sp->call68KFuncP)( sp->emulStateP,
|
|
PceNativeTrapNo(sysTrapExgDBWrite),
|
|
stack, 18 );
|
|
/* swapOuts */
|
|
}
|
|
FUNC_TAIL(ExgDBWrite);
|
|
EMIT_NAME("ExgDBWrite","'E','x','g','D','B','W','r','i','t','e'");
|
|
return result;
|
|
} /* ExgDBWrite */
|