int main(void)
{
#ifdef __Z88DK
intrinsic_di();
#endif
PRINTF1("\nFilling the array with numbers.\n\n");
/* FILL ARRAY WITH NUMBERS */
for (i = 0; i < NUM; ++i)
#if STYLE == 0
numbers[i] = g_rand();
#else
#if STYLE == 1
numbers[i] = i;
#else
#if STYLE == 2
numbers[i] = NUM - i - 1;
#else
numbers[i] = NUM/2;
#endif
#endif
#endif
/* PRINT FIRST FEW NUMBERS TO DEMONSTRATE ALL IS GOOD */
for (i = 0; i < 10; ++i)
PRINTF2("%u, ", numbers[i]);
/* SORT */
PRINTF1("\n\nQSORT!!\n\n");
perform_sort();
/* VERIFY RESULT */
for (i = 0; i < NUM; ++i)
{
PRINTF2("%u, ", numbers[i]);
if ((i > 0) && (numbers[i] < numbers[i-1]))
{
PRINTF1("\n\nFAIL");
break;
}
}
PRINTF1("\n\n\n");
return 0;
}
TBool CTestObjectManager::ObjectL( const TDesC& aSuid, CMTPObjectMetaData& aObject ) const
{
PRINTF1( ">CTestObjectManager::ObjectL suid = %S", &aSuid );
for ( TInt i = 0; i < iMTPObjects.Count(); i++ )
{
if ( ( iMTPObjects[i]->DesC(CMTPObjectMetaData::ESuid ) ).Match( aSuid ) == 0)
{
PRINTF1( "<CTestObjectManager::ObjectL, index = %d", i );
CopyObjectMetadataL( *( iMTPObjects[i] ), aObject );
return ETrue;
}
}
PRINTF0( "<CTestObjectManager::ObjectL, object not found" );
return EFalse;
}
TInt64 CTestObjectManager::ObjectUidL( const TDesC& aSuid ) const
{
PRINTF1( ">CTestObjectManager::ObjectUidL suid = %S", &aSuid );
TUint handle = 0;
for ( TInt i = 0; i < iMTPObjects.Count(); i++ )
{
if ( ( iMTPObjects[i]->DesC( CMTPObjectMetaData::ESuid ) ).Match( aSuid ) == 0 )
{
handle = iMTPObjects[i]->Uint( CMTPObjectMetaData::EHandle );
break;
}
}
PRINTF1( "<CTestObjectManager::ObjectUidL, handle = %d", handle );
return handle;
}
TBool CTestObjectManager::ObjectL( const TMTPTypeUint32& aHandle, CMTPObjectMetaData& aObject ) const
{
TUint32 handle = aHandle.Value();
PRINTF1( ">CTestObjectManager::ObjectL handle = %d", handle );
for ( TInt i = 0; i < iMTPObjects.Count(); i++ )
{
if ( iMTPObjects[i]->Uint( CMTPObjectMetaData::EHandle ) == handle )
{
PRINTF1( "<CTestObjectManager::ObjectL, index = %d", i );
CopyObjectMetadataL( *iMTPObjects[i], aObject );
return ETrue;
}
}
PRINTF0( "<CTestObjectManager::ObjectL, object not found" );
return EFalse;
}
void CTestObjectManager::ModifyObjectL( const CMTPObjectMetaData& aObject )
{
TUint32 handle = aObject.Uint( CMTPObjectMetaData::EHandle );
PRINTF1( ">CTestObjectManager::ModifyObjectL handle = %d", handle );
for ( TInt i = 0; i < iMTPObjects.Count(); i++ )
{
if ( iMTPObjects[i]->Uint( CMTPObjectMetaData::EHandle ) == handle )
{
PRINTF1( "<CTestObjectManager::ModifyObjectL, index = %d", i );
CopyObjectMetadataL( aObject, *iMTPObjects[i] );
return;
}
}
PRINTF0( "<CTestObjectManager::ModifyObjectL, object not found" );
User::Leave( KErrNotFound );
}
TMTPTypeUint128 CTestObjectManager::PuidL( const TDesC& aSuid ) const
{
PRINTF1( "<>CTestObjectManager::PuidL suid = %S", &aSuid );
TMTPTypeUint128 returnValue;
PRINTE0( "NOT IMPLEMENTED" );
return returnValue;
}
TMTPTypeUint128 CTestObjectManager::PuidL( TInt64 aObjectUid ) const
{
PRINTF1( "<>CTestObjectManager::PuidL uid = %Ld", aObjectUid );
TMTPTypeUint128 returnValue;
PRINTE0( "NOT IMPLEMENTED" );
return returnValue;
}
/*---------------------------------------------------------------------*/
obj_t
bgl_write_socket( obj_t o, obj_t op ) {
if( BGL_SOCKET_UNIXP( o ) ) {
PRINTF1( op,
40 + (STRINGP( SOCKET( o ).hostname ) ?
STRING_LENGTH( SOCKET( o ).hostname ) :
sizeof( "localhost" )),
"#<unix-socket:%s>",
STRINGP( SOCKET( o ).hostname ) ?
BSTRING_TO_STRING( SOCKET( o ).hostname ) :
"localhost" );
} else {
PRINTF2( op,
40 + (STRINGP( SOCKET( o ).hostname ) ?
STRING_LENGTH( SOCKET( o ).hostname ) :
sizeof( "localhost" )),
"#<socket:%s.%d>",
STRINGP( SOCKET( o ).hostname ) ?
BSTRING_TO_STRING( SOCKET( o ).hostname ) :
"localhost",
SOCKET( o ).portnum );
}
return op;
}
/*---------------------------------------------------------------------*/
obj_t
bgl_write_process( obj_t o, obj_t op ) {
PUTS( op, "#<process:" );
PRINTF1( op, 20, "%d>", PROCESS_PID( o ) );
return op;
}
/*---------------------------------------------------------------------*/
obj_t
bgl_write_dynamic_env( obj_t o, obj_t op ) {
PUTS( op, "#<dynamic-env:" );
PRINTF1( op, 16, ":%p>", o );
return op;
}
/*---------------------------------------------------------------------*/
obj_t
bgl_write_foreign( obj_t o, obj_t op ) {
PUTS( op, "#<foreign:" );
bgl_display_obj( FOREIGN_ID( o ), op );
PRINTF1( op, 16, ":%lx>", (long)FOREIGN_TO_COBJ( o ) );
return op;
}
/*---------------------------------------------------------------------*/
obj_t
bgl_write_input_port( obj_t o, obj_t op ) {
PUTS( op, "#<input_port:" );
bgl_display_obj( PORT( o ).name, op );
PRINTF1( op, 10, ".%ld>", (long)BGL_INPUT_PORT_BUFSIZ( o ) );
return op;
}
/*---------------------------------------------------------------------*/
obj_t
bgl_write_output_port( obj_t o, obj_t op ) {
PRINTF1( op, 20 + STRING_LENGTH( PORT( o ).name ),
"#<output_port:%s>",
BSTRING_TO_STRING( PORT( o ).name ) );
return op;
}
/*---------------------------------------------------------------------*/
obj_t
bgl_write_ucs2( obj_t o, obj_t op ) {
void *ostream = PORT_STREAM( op );
PRINTF1( op, 7, "#u%04x", CUCS2( o ) );
return op;
}
/*---------------------------------------------------------------------*/
obj_t
bgl_write_mmap( obj_t o, obj_t op ) {
PUTS( op, "#<mmap:" );
bgl_display_obj( BGL_MMAP( o ).name, op );
PRINTF1( op, 16, ":%ld>", (long)BGL_MMAP( o ).length );
return op;
}
/*---------------------------------------------------------------------*/
BGL_RUNTIME_DEF
obj_t
bgl_display_fixnum( obj_t o, obj_t op ) {
void *ostream = PORT_STREAM( op );
PRINTF1( op, 32, "%ld", CINT( o ) );
return op;
}
void CTestObjectManager::InsertObjectL( CMTPObjectMetaData& aObject )
{
TUint handle = aObject.Uint( CMTPObjectMetaData::EHandle );
PRINTF1( ">CTestObjectManager::InsertObjectL handle = %d", handle );
CMTPObjectMetaData* newObject = CMTPObjectMetaData::NewL(
aObject.DesC( CMTPObjectMetaData::ESuid ), 0, 0, 0 );
CleanupStack::PushL( newObject );
iHandle++;
aObject.SetUint( CMTPObjectMetaData::EHandle, iHandle );
newObject->SetUint( CMTPObjectMetaData::EHandle, iHandle );
CopyObjectMetadataL( aObject, *newObject );
CleanupStack::Pop( newObject );
iMTPObjects.Append( newObject );
PRINTF1( "New object inserted with handle %d", iHandle );
}
/*---------------------------------------------------------------------*/
obj_t
bgl_write_unknown( obj_t o, obj_t op ) {
if( POINTERP( o ) ) {
PRINTF2( op, 40, "#<???:%ld:%08lx>", TYPE( o ), (unsigned long)o );
} else {
PRINTF1( op, 40, "#<???:%08lx>", (unsigned long)o );
}
return op;
}
TUint CTestObjectManager::ObjectOwnerId( const TMTPTypeUint32& aHandle ) const
{
TUint32 handle = aHandle.Value();
PRINTF1( ">CTestObjectManager::ObjectOwnerId handle = %d", handle );
TUint ownerId = KErrNotFound;
for ( TInt i = 0; i < iMTPObjects.Count(); i++ )
{
if ( handle == iMTPObjects[i]->Uint( CMTPObjectMetaData::EHandle ) )
{
ownerId = iMTPObjects[i]->Uint( CMTPObjectMetaData::EDataProviderId );
break;
}
}
if ( ownerId == KErrNotFound )
{
PRINTE1( "<CTestObjectManager::ObjectOwnerId, object not found: %d", handle );
User::Leave( KErrNotFound );
}
PRINTF1( "<CTestObjectManager::ObjectOwnerId, owner id = %d", ownerId );
return ownerId;
}
TMTPTypeUint128 CTestObjectManager::PuidL( TUint32 aHandle ) const
{
PRINTF1( ">CTestObjectManager::PuidL handle = %d", aHandle );
TMTPTypeUint128 returnValue;
for ( TInt i = 0; i < iMTPObjects.Count(); i++)
{
TUint handle = iMTPObjects[i]->Uint( CMTPObjectMetaData::EHandle );
if ( handle == aHandle )
{
returnValue.Set( handle, handle );
break;
}
}
return returnValue;
}
void CTestObjectManager::UnreserveObjectHandleL( const CMTPObjectMetaData& aObject )
{
TUint reservedHandle = aObject.Uint( CMTPObjectMetaData::EHandle );
PRINTF1( ">CTestObjectManager::UnreserveObjectHandleL handle = %d", reservedHandle );
for ( TInt i = 0; i < iMTPObjects.Count(); i++)
{
TUint handle = iMTPObjects[i]->Uint( CMTPObjectMetaData::EHandle );
if ( reservedHandle == handle )
{
CMTPObjectMetaData* object = iMTPObjects[i];
iMTPObjects.Remove( i );
delete object;
break;
}
}
PRINTF0( "<CTestObjectManager::UnreserveObjectHandleL" );
}
void CTestObjectManager::ReserveObjectHandleL( CMTPObjectMetaData& aObject, TUint64 aSpaceRequired )
{
TUint handle = aObject.Uint( CMTPObjectMetaData::EHandle );
PRINTF2( ">CTestObjectManager::ReserveObjectHandleL handle = %d, space = %Ld", handle, aSpaceRequired );
CMTPObjectMetaData* newObject = CMTPObjectMetaData::NewL(
aObject.DesC( CMTPObjectMetaData::ESuid ), 0, 0, 0 );
CleanupStack::PushL( newObject );
iHandle++;
aObject.SetUint( CMTPObjectMetaData::EHandle, iHandle );
newObject->SetUint( CMTPObjectMetaData::EHandle, iHandle );
CopyObjectMetadataL( aObject, *newObject );
CleanupStack::Pop( newObject );
iMTPObjects.Append( newObject );
PRINTF1( "<CTestObjectManager::ReserveObjectHandleL handle = %d", iHandle );
}
/*---------------------------------------------------------------------*/
obj_t
bgl_write_char( obj_t o, obj_t op ) {
int c = CCHAR( o );
void *ostream = PORT_STREAM( op );
if( (c > 0) && (c < 128) && char_name[ c ][ 0 ] ) {
unsigned char *name = char_name[ c ];
PUTC( op, '#' );
PUTC( op, '\\' );
bgl_write( op, name, strlen( name ) );
} else {
PUTC( op, '#' );
PUTC( op, 'a' );
PRINTF1( op, 4, "%03d", (unsigned char)(c) );
}
return op;
}
TUint CTestObjectManager::CountL( const TMTPObjectMgrQueryParams& aParams ) const
{
PRINTF3( ">CTestObjectManager::CountL storage = 0x%x parent = 0x%x format = 0x%x", aParams.iStorageId, aParams.iParentHandle, aParams.iFormatCode );
TUint count = 0;
for ( TInt i = 0; i < iMTPObjects.Count(); i++ )
{
TUint handle = iMTPObjects[i]->Uint( CMTPObjectMetaData::EHandle );
TUint formatCode = iMTPObjects[i]->Uint( CMTPObjectMetaData::EFormatCode );
TUint storageId = iMTPObjects[i]->Uint( CMTPObjectMetaData::EStorageId );
TInt parentId = iMTPObjects[i]->Int( CMTPObjectMetaData::EParentId );
if ( ( ( aParams.iStorageId == storageId ) || ( aParams.iStorageId == KMTPStorageAll ) )
&&
( ( aParams.iFormatCode == formatCode ) || ( aParams.iFormatCode == KMTPFormatsAll ) )
&&
( ( aParams.iParentHandle == parentId ) || ( aParams.iParentHandle == KMTPHandleNone ) || ( ( aParams.iParentHandle == KMTPHandleNoParent ) && ( parentId == KErrNotFound ) ) ) )
{
PRINTV1( "Adding handle %d to count", handle );
count++;
}
}
PRINTF1( "<CTestObjectManager::CountL, count = %d", count );
return count;
}
int main(void)
{
/* int c = 0;*/
/* int i = 0;*/
/* int data = 0;*/
/* IntVector *vec;*/
/* IntList *lst;*/
/* INTR_DISABLE;*/
init();
/* INTR_ENABLE;*/
puts("Hello, World!\n");
/* printval();*/
/* puts("overwrite variables.\n");*/
/* global_data++;*/
/* global_bss++;*/
/* static_data++;*/
/* static_bss++;*/
/* printval();*/
cmd_map();
#if 0
vec = IntVector_new();
/* lst = IntList_new();*/
while (1) {
static char buf[32];
char *p;
PRINTF0(">");
gets(buf, sizeof buf);
p = strpbrk(buf, "\r\n");
if (p) *p = '\0';
PRINTF1("%s\n", buf);
if (sw_is_on(SW1)) {
led_on(LED1);
i++;
if (i > 100) {
i = 0;
if (IntVector_push_back(vec, data)) {
PRINTF1("IntVector_push_back: %d", data);
/* putdval(data, 0);*/
data++;
PRINTF1(", IntVector_size: %d\n", IntVector_size(vec));
/* putdval(IntVector_size(vec), 0);*/
/* puts("\n");*/
} else {
puts("IntVector_push_back: failed\n");
puts("IntVector_capacity: ");
putdval(IntVector_capacity(vec), 0);
puts(", IntVector_size: ");
putdval(IntVector_size(vec), 0);
puts("\n");
}
}
} else {
led_off(LED1);
}
if (sw_is_on(SW2)) {
if (!IntVector_empty(vec)) {
puts("IntVector_back: ");
putdval(*IntVector_back(vec), 0);
puts(", IntVector_pop_back");
IntVector_pop_back(vec);
puts("\n");
}
}
if (sw_is_on(SW5_8)) {
led_on(LED2);
} else {
led_off(LED2);
}
if (sw_is_on(SW3)) {
putxval(c++, 0);
puts("\n");
}
if (sw_is_on(SW4)) {
putdval(c++, 0);
puts("\n");
}
}
#endif
return 0;
}
void CTestObjectManager::CommitReservedObjectHandleL( CMTPObjectMetaData& aObject )
{
TUint handle = aObject.Uint( CMTPObjectMetaData::EHandle );
PRINTF1( "<>CTestObjectManager::CommitReservedObjectHandleL handle = %d", handle );
}
void CTestObjectManager::RemoveObjectsL( TUint aDataProviderId )
{
PRINTF1( "<>CTestObjectManager::RemoveObjectsL data provider id = %d", aDataProviderId );
PRINTE0( "NOT IMPLEMENTED" );
}
void CTestObjectManager::RemoveObjectL( const TDesC& aSuid )
{
PRINTF1( "<>CTestObjectManager::RemoveObjectL suid = %S", &aSuid );
PRINTE0( "NOT IMPLEMENTED" );
}
void CTestObjectManager::RemoveObjectL( const TMTPTypeUint32& aHandle )
{
TUint handle = aHandle.Value();
PRINTF1( "<>CTestObjectManager::RemoveObjectL handle = %d", handle );
PRINTE0( "NOT IMPLEMENTED" );
}
TInt64 CTestObjectManager::ObjectUidL( TUint32 aHandle ) const
{
PRINTF1( "<>CTestObjectManager::ObjectUidL handle = %d", aHandle );
return aHandle;
}
