#if !defined(_INLINE)
static char cvsid[] = "@(#)$Id$";
static char debugFileId[] = __FILE__;
#endif
#include <errno.h>
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <limits.h>
extern int errno;
#include "platform/MinimalPlatform.hpp"
#include "platform/ANSICPlatform.hpp"
#include "String.hpp"
#include "Debug.hpp"
#include "exceptions/OutOfMemory.hpp"
#include "exceptions/InvalidArgument.hpp"
MinimalPlatform::MinimalPlatform()
{}
MinimalPlatform::~MinimalPlatform()
{}
char *MinimalPlatform::getErrorDescription( int )
{
return ( char * ) "Error";
}
void MinimalPlatform::sprintf( char *s, const char * format, ...)
{
va_list args;
va_start( args, format );
this -> vsprintf( s, format, args );
va_end(args);
}
void MinimalPlatform::vsprintf( char *s, const char *format, va_list raw )
{
::vsprintf( s, format, raw );
}
void MinimalPlatform::rawErrorPrintf( const char * format, ... )
{
va_list args;
va_start( args, format );
this -> rawErrorVPrintf( format, args );
va_end(args);
}
void MinimalPlatform::rawErrorVPrintf( const char * format, va_list raw )
{
vfprintf( stderr, format, raw );
}
void MinimalPlatform::exitImmediate( long status )
{
this -> rawErrorPrintf
( "Program exits with status %li. Terminate it by OS means.", status );
while( true )
{}
}
void MinimalPlatform::suicide()
{
this -> rawErrorPrintf
( "Program abnormally exits. Terminate it by OS means." );
while( true )
{}
}
void MinimalPlatform::attachDebugger()
{
this -> rawErrorPrintf
( "Please, attach debugger to this image." );
while( true )
{}
}
void MinimalPlatform::setImageName( const char *aName )
{
imageName = aName;
}
const char *MinimalPlatform::getImageName() const
{
return imageName;
}
char *MinimalPlatform::getTimeStampString()
{
return ( char * ) "YYYY/MM/DD hh:mm:ss";
}
char *MinimalPlatform::strcpy( char *dst, const char *src )
{
char *point;
point = dst;
for( ; ( * ( point++ ) = * ( src++ ) ) ; )
{}
return dst;
}
int MinimalPlatform::strcmp( const char *s1, const char *s2 )
{
for( ; *s1 == *s2 ; ++s1, ++s2 )
{
if( *s1 == 0 )
{
return 0;
}
}
return( ( * ( const unsigned char * ) s1 ) -
( * ( const unsigned char * ) s2 ) );
}
Index MinimalPlatform::strlen( const char *s )
{
char *point;
for( point = ( char * ) s ; *point ; ++point )
{}
return( point - s );
}
char *MinimalPlatform::strcat( char *dst, const char *src )
{
return this -> strcpy( dst + this -> strlen( dst ), src );
}
char *MinimalPlatform::strchr( const char *s, int c )
{
for( ; *s ; ++s )
{
if( *s == c )
{
return ( char * ) s;
}
}
return NIL;
}
long MinimalPlatform::strtol( const char *nptr, char **endptr, int base )
{
const char *s = nptr;
unsigned long acc;
unsigned char c;
unsigned long cutoff;
int neg = 0, any, cutlim;
do
{
c = *s++;
}
while ( ( c == ' ' ) || ( c == '\t' ) || ( c == '\n' ) || ( c == '\r' ) );
if (c == '-')
{
neg = 1;
c = *s++;
}
else
{
if (c == '+')
{
c = *s++;
}
}
if ( ( base == 0 || base == 16) &&
c == '0' && (*s == 'x' || *s == 'X' ) )
{
c = s[1];
s += 2;
base = 16;
}
if (base == 0)
{
base = c == '0' ? 8 : 10;
}
cutoff = neg ? - ( unsigned long ) LONG_MIN : LONG_MAX;
cutlim = cutoff % ( unsigned long ) base;
cutoff /= ( unsigned long ) base;
for( acc = 0, any = 0 ; ; c = *s++ )
{
if( c > 0177 )
{
break;
}
if( ( c >= '0' ) && ( c <= '9' ) )
{
c -= '0';
}
else
{
if( ( ( c >= 'a' ) && ( c <= 'z' ) ) ||
( ( c >= 'A' ) && ( c <= 'Z' ) ) )
{
c -= ( ( c >= 'A' ) && ( c <= 'Z' ) ) ? 'A' - 10 : 'a' - 10;
}
else
{
break;
}
}
if(c >= base)
{
break;
}
if(any < 0 || acc > cutoff || ( acc == cutoff && c > cutlim ) )
{
any = -1;
}
else
{
any = 1;
acc *= base;
acc += c;
}
}
if( any < 0 )
{
acc = neg ? LONG_MIN : LONG_MAX;
errno = ERANGE;
}
else
{
if( neg )
{
acc = -acc;
}
}
if( endptr != 0 )
{
*endptr = ( char * )( any ? s - 1 : nptr );
if( **endptr != ( char ) 0 )
{
throw new
InvalidArgument( "strtol: garbage detected",
( Top * ) nil );
}
}
if( errno == ERANGE )
{
throw new
InvalidArgument( "strtol: value is outside the range of representable values",
( Top * ) nil );
}
return acc;
}
int MinimalPlatform::memcmp( void *s1, const void *s2, Index n )
{
char *c1 = ( char * ) s1;
char *c2 = ( char * ) s2;
for( Index scan = 0 ;
( scan < n ) && ( *c1 == *c2 ) ;
++c1, ++c2, ++scan )
{}
return( ( * ( const unsigned char * ) s1 ) -
( * ( const unsigned char * ) s2 ) );
}
void *MinimalPlatform::memchr( const void *s, int c, Index n )
{
char *cc = ( char * ) s;
for( Index scan = 0 ; scan < n ; ++cc )
{
if( *cc == c )
{
return ( void * ) cc;
}
}
return NIL;
}
void *MinimalPlatform::memcpy( void *s1, const void *s2, Index n )
{
for( Index scan = 0 ; scan < n ; ++scan )
{
( ( unsigned char * ) s1 )[ scan ] = ( ( unsigned char * ) s2 )[ scan ];
}
return s1;
}
void *MinimalPlatform::memset( void *s, int c, Index n )
{
for( Index scan = 0 ; scan < n ; ++scan )
{
( ( unsigned char * ) s )[ scan ] = ( unsigned char ) c;
}
return s;
}
void *MinimalPlatform::allocateMemory( Index aSize )
{
char *arena;
arena = ( char * ) malloc( aSize );
if( arena == NULL )
{
throw ANSICPlatform::getOutOfMemory();
}
this -> memset( arena, 0, aSize );
return arena;
}
void MinimalPlatform::deallocateMemory( void *aPointer )
{
if( aPointer != NIL )
{
free( aPointer );
}
}
boolean MinimalPlatform::equals( const Top *anOther ) const
{
return( DCAST( anOther, MinimalPlatform ) == this );
}
Top *MinimalPlatform::clone() const
{
return ( Top * ) this;
}
String MinimalPlatform::getClassName() const
{
return "MinimalPlatform";
}
#if defined(_INLINE)
#include "../src/Debug.ipp"
#endif