AOO410/main/tools/workben/solar.c - openoffice - Git at Google

 /**************************************************************
  *
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  *
  *************************************************************/


 #include <stdio.h>
 #include <stdlib.h>

 typedef enum { t_char, t_short, t_int, t_long, t_double } Type;
 typedef int (*TestFunc)( Type, void* );

 struct Description;

 int IsBigEndian(void);
 int IsStackGrowingDown_2( int * pI );
 int IsStackGrowingDown(void);
 int GetStackAlignment_3( char*p, long l, int i, short s, char b, char c, ... );
 int GetStackAlignment_2( char*p, long l, int i, short s, char b, char c );
 int GetStackAlignment(void);
 void PrintArgs( int p, ... );
 int check( TestFunc func, Type eT, void* p );

 #if defined (UNX) || defined (WNT) || defined (OS2)

 #ifdef UNX
 #include <unistd.h>
 #endif
 #include <sys/types.h>

 #define I_STDARG
 #ifdef I_STDARG
 #include <stdarg.h>
 #else
 #include <varargs.h>
 #endif

 #define NO_USE_FORK_TO_CHECK
 #ifdef USE_FORK_TO_CHECK
 #include <sys/wait.h>
 #else
 #include <signal.h>
 #include <setjmp.h>
 #endif

 #else
 #endif

 #define printTypeSize(Type,Name)	printf(	"sizeof(%s)\t= %d\n", Name,	\
 				sizeof (Type) )

 #define isSignedType(Type)	(((Type)-1) < 0)
 #define printTypeSign(Type,Name)	printf(	"%s\t= %s %s\n", Name,		\
 				( isSignedType(Type) ? "unsigned" : "signed" ), Name )


 int IsBigEndian()
 {
   long l = 1;
   return ! *(char*)&l;
 }

 int IsStackGrowingDown_2( int * pI )
 {
   int i = 1;
   return ((unsigned long)&i) < (unsigned long)pI;
 }

 int IsStackGrowingDown()
 {
   int i = 1;
   return IsStackGrowingDown_2(&i);
 }

 int GetStackAlignment_3( char*p, long l, int i, short s, char b, char c, ... )
 {
   (void) p; (void) l; (void) i; (void) s; /* unused */
   if ( IsStackGrowingDown() )
 	return &c - &b;
   else
 	return &b - &c;
 }

 int GetStackAlignment_2( char*p, long l, int i, short s, char b, char c )
 {
   (void) p; (void) l; (void) i; (void) s; /* unused */
   if ( IsStackGrowingDown() )
 	return &c - &b;
   else
 	return &b - &c;
 }

 int GetStackAlignment()
 {
   int nStackAlignment = GetStackAlignment_3(0,1,2,3,4,5);
   if ( nStackAlignment != GetStackAlignment_2(0,1,2,3,4,5) )
 	printf( "Pascal calling convention\n" );
   return nStackAlignment;
 }


 #if defined (UNX) || defined (WNT) || defined (OS2)

 #ifdef I_STDARG
 void PrintArgs( int p, ... )
 #else
 void PrintArgs( p, va_alist )
 int p;
 va_dcl
 #endif
 {
 	int value;
 	va_list ap;

 #ifdef I_STDARG
     va_start( ap, p );
 #else
     va_start( ap );
 #endif

 	printf( "value = %d", p );

 	while ( ( value = va_arg(ap, int) ) != 0 )
 	  printf( " %d", value );

 	printf( "\n" );
 	va_end(ap);
 }

 #ifndef USE_FORK_TO_CHECK
 static jmp_buf check_env;
 static int bSignal;
 #if defined (UNX) || defined (OS2)
 void SignalHandler( int sig )
 #else
 void __cdecl SignalHandler( int sig )
 #endif
 {
   bSignal = 1;
   /*
   fprintf( stderr, "Signal %d caught\n", sig );
   signal( sig,	SignalHandler );
   */
   longjmp( check_env, sig );
 }
 #endif

 int check( TestFunc func, Type eT, void* p )
 {
 #ifdef USE_FORK_TO_CHECK
   pid_t nChild = fork();
   if ( nChild )
   {
     int exitVal;
     wait( &exitVal );
     if ( exitVal & 0xff )
       return -1;
     else
       return exitVal >> 8;
   }
   else
   {
     exit( func( eT, p ) );
   }
 #else
   int result;

   bSignal = 0;

   if ( !setjmp( check_env ) )
   {
 	signal( SIGSEGV,	SignalHandler );
 #ifdef UNX
 	signal( SIGBUS,	SignalHandler );
 #else
 #endif
 	result = func( eT, p );
 	signal( SIGSEGV,	SIG_DFL );
 #ifdef UNX
 	signal( SIGBUS,	SIG_DFL );
 #else
 #endif
   }

   if ( bSignal )
 	return -1;
   else
 	return 0;
 #endif
 }

 #endif


 int GetAtAddress( Type eT, void* p )
 {
   switch ( eT )
   {
   case t_char:		return *((char*)p);
   case t_short:		return *((short*)p);
   case t_int:		return *((int*)p);
   case t_long:		return *((long*)p);
   case t_double:	return *((double*)p);
   }
   abort();
 }

 int SetAtAddress( Type eT, void* p )
 {
   switch ( eT )
   {
   case t_char:		return *((char*)p)	= 0;
   case t_short:		return *((short*)p)	= 0;
   case t_int:		return *((int*)p)	= 0;
   case t_long:		return *((long*)p)	= 0;
   case t_double:	return *((double*)p)= 0;
   }
   abort();
 }

 char* TypeName( Type eT )
 {
   switch ( eT )
   {
   case t_char:		return "char";
   case t_short:		return "short";
   case t_int:		return "int";
   case t_long:		return "long";
   case t_double:	return "double";
   }
   abort();
 }

 int CheckGetAccess( Type eT, void* p )
 {
   int b;
   b = -1 != check( (TestFunc)GetAtAddress, eT, p );
 #if OSL_DEBUG_LEVEL > 1
   fprintf( stderr,
 		   "%s read %s at %p\n",
 		   (b? "can" : "can not" ), TypeName(eT), p );
 #endif
   return b;
 }
 int CheckSetAccess( Type eT, void* p )
 {
   int b;
   b = -1 != check( (TestFunc)SetAtAddress, eT, p );
 #if OSL_DEBUG_LEVEL > 1
   fprintf( stderr,
 		   "%s write %s at %p\n",
 		   (b? "can" : "can not" ), TypeName(eT), p );
 #endif
   return b;
 }

 int GetAlignment( Type eT )
 {
   char	a[ 16*8 ];
   int	p = (int)(void*)&a;
   int	i;
   p = ( p + 0xF ) & ~0xF;
   for ( i = 1; i < 16; i++ )
 	if ( CheckGetAccess( eT, (void*)(p+i) ) )
 	  return i;
   return 0;
 }

 int CheckCharAccess( char* p )
 {
   if ( CheckGetAccess( t_char, p ) )
     printf( "can read address %p\n", p );
   else
     printf( "can not read address %p\n", p );

   if ( CheckSetAccess( t_char, p ) )
     printf( "can write address %p\n", p );
   else
     printf( "can not write address %p\n", p );

   return 0;
 }

 struct Description
 {
   int	bBigEndian;
   int	bStackGrowsDown;
   int	nStackAlignment;
   int	nAlignment[3];	/* 2,4,8 */
 };

 void Description_Ctor( struct Description* pThis )
 {
   pThis->bBigEndian			= IsBigEndian();
   pThis->bStackGrowsDown	= IsStackGrowingDown();
   pThis->nStackAlignment	= GetStackAlignment();

   if ( sizeof(short) != 2 )
 	abort();
   pThis->nAlignment[0] = GetAlignment( t_short );
   if ( sizeof(int) != 4 )
 	abort();
   pThis->nAlignment[1] = GetAlignment( t_int );
   if ( sizeof(double) != 8 )
 	abort();
   pThis->nAlignment[2] = GetAlignment( t_double );
 }

 void Description_Print( struct Description* pThis, char* name )
 {
   int i;
   FILE* f = fopen( name, "w" );
   fprintf( f, "#define __%s\n",
 		   pThis->bBigEndian ? "BIGENDIAN" : "LITTLEENDIAN" );
   for ( i = 0; i < 3; i++ )
 	fprintf( f, "#define __ALIGNMENT%d\t%d\n",
 			 1 << (i+1), pThis->nAlignment[i] );
   fprintf( f, "#define __STACKALIGNMENT wird nicht benutzt\t%d\n", pThis->nStackAlignment );
   fprintf( f, "#define __STACKDIRECTION\t%d\n",
 		   pThis->bStackGrowsDown ? -1 : 1 );
   fprintf( f, "#define __SIZEOFCHAR\t%d\n", sizeof( char ) );
   fprintf( f, "#define __SIZEOFSHORT\t%d\n", sizeof( short ) );
   fprintf( f, "#define __SIZEOFINT\t%d\n", sizeof( int ) );
   fprintf( f, "#define __SIZEOFLONG\t%d\n", sizeof( long ) );
   fprintf( f, "#define __SIZEOFPOINTER\t%d\n", sizeof( void* ) );
   fprintf( f, "#define __SIZEOFDOUBLE\t%d\n", sizeof( double ) );
   fprintf( f, "#define __IEEEDOUBLE\n" );
   fprintf( f, "#define _SOLAR_NODESCRIPTION\n" );

   fclose(f);
 }

 int
 #ifdef WNT
 __cdecl
 #endif
 main( int argc, char* argv[] )
 {
   printTypeSign( char, "char" );
   printTypeSign( short, "short" );
   printTypeSign( int, "int" );
   printTypeSign( long, "long" );

   printTypeSize( char, "char" );
   printTypeSize( short, "short" );
   printTypeSize( int, "int" );
   printTypeSize( long, "long" );
   printTypeSize( float, "float" );
   printTypeSize( double, "double" );
   printTypeSize( void *, "void *" );

   if ( IsBigEndian() )
     printf( "BIGENDIAN (Sparc, MC680x0, RS6000)\n" );
   else
     printf( "LITTLEENDIAN (Intel, VAX, PowerPC)\n" );

   if( IsStackGrowingDown() )
     printf( "Stack waechst nach unten\n" );
   else
     printf( "Stack waechst nach oben\n" );

   printf( "STACKALIGNMENT   : %d\n", GetStackAlignment() );

   PrintArgs( 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 );

   {
 	char  a[64];
 	int   i = 56;
 	do
 	{
 	  printf( "Zugriff long auf %i-Aligned Adresse : ", i / 7 );
 	  printf( ( CheckGetAccess( t_long, (long*)&a[i] ) ? "OK\n" : "ERROR\n" ) );
 	  i >>= 1;
 	} while( i >= 7 );
   }

   {
 	char  a[64];
 	int   i = 56;
 	do
 	{
 	  printf( "Zugriff double auf %i-Aligned Adresse : ", i / 7 );
 	  printf( ( CheckGetAccess( t_double, (double*)&a[i] ) ? "OK\n" : "ERROR\n" ) );
 	  i >>= 1;
 	} while( i >= 7 );
   }

   {
 	char* p = NULL;
 	CheckCharAccess( p );
 	p = (char*)&p;
 	CheckCharAccess( p );
   }

   if ( argc > 1 )
   {
 	struct Description description;
 	Description_Ctor( &description );
 	Description_Print( &description, argv[1] );
   }

   exit( 0 );
   return 0;
 }
	/**************************************************************
	*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*
	*************************************************************/



	#include <stdio.h>
	#include <stdlib.h>

	typedef enum { t_char, t_short, t_int, t_long, t_double } Type;
	typedef int (TestFunc)( Type, void );

	struct Description;

	int IsBigEndian(void);
	int IsStackGrowingDown_2( int * pI );
	int IsStackGrowingDown(void);
	int GetStackAlignment_3( char*p, long l, int i, short s, char b, char c, ... );
	int GetStackAlignment_2( char*p, long l, int i, short s, char b, char c );
	int GetStackAlignment(void);
	void PrintArgs( int p, ... );
	int check( TestFunc func, Type eT, void* p );

	#if defined (UNX) \|\| defined (WNT) \|\| defined (OS2)

	#ifdef UNX
	#include <unistd.h>
	#endif
	#include <sys/types.h>

	#define I_STDARG
	#ifdef I_STDARG
	#include <stdarg.h>
	#else
	#include <varargs.h>
	#endif

	#define NO_USE_FORK_TO_CHECK
	#ifdef USE_FORK_TO_CHECK
	#include <sys/wait.h>
	#else
	#include <signal.h>
	#include <setjmp.h>
	#endif

	#else
	#endif

	#define printTypeSize(Type,Name) printf( "sizeof(%s)\t= %d\n", Name, \
	sizeof (Type) )

	#define isSignedType(Type) (((Type)-1) < 0)
	#define printTypeSign(Type,Name) printf( "%s\t= %s %s\n", Name, \
	( isSignedType(Type) ? "unsigned" : "signed" ), Name )


	int IsBigEndian()
	{
	long l = 1;
	return ! (char)&l;
	}

	int IsStackGrowingDown_2( int * pI )
	{
	int i = 1;
	return ((unsigned long)&i) < (unsigned long)pI;
	}

	int IsStackGrowingDown()
	{
	int i = 1;
	return IsStackGrowingDown_2(&i);
	}

	int GetStackAlignment_3( char*p, long l, int i, short s, char b, char c, ... )
	{
	(void) p; (void) l; (void) i; (void) s; /* unused */
	if ( IsStackGrowingDown() )
	return &c - &b;
	else
	return &b - &c;
	}

	int GetStackAlignment_2( char*p, long l, int i, short s, char b, char c )
	{
	(void) p; (void) l; (void) i; (void) s; /* unused */
	if ( IsStackGrowingDown() )
	return &c - &b;
	else
	return &b - &c;
	}

	int GetStackAlignment()
	{
	int nStackAlignment = GetStackAlignment_3(0,1,2,3,4,5);
	if ( nStackAlignment != GetStackAlignment_2(0,1,2,3,4,5) )
	printf( "Pascal calling convention\n" );
	return nStackAlignment;
	}




	#if defined (UNX) \|\| defined (WNT) \|\| defined (OS2)

	#ifdef I_STDARG
	void PrintArgs( int p, ... )
	#else
	void PrintArgs( p, va_alist )
	int p;
	va_dcl
	#endif
	{
	int value;
	va_list ap;

	#ifdef I_STDARG
	va_start( ap, p );
	#else
	va_start( ap );
	#endif

	printf( "value = %d", p );

	while ( ( value = va_arg(ap, int) ) != 0 )
	printf( " %d", value );

	printf( "\n" );
	va_end(ap);
	}

	#ifndef USE_FORK_TO_CHECK
	static jmp_buf check_env;
	static int bSignal;
	#if defined (UNX) \|\| defined (OS2)
	void SignalHandler( int sig )
	#else
	void __cdecl SignalHandler( int sig )
	#endif
	{
	bSignal = 1;
	/*
	fprintf( stderr, "Signal %d caught\n", sig );
	signal( sig, SignalHandler );
	*/
	longjmp( check_env, sig );
	}
	#endif

	int check( TestFunc func, Type eT, void* p )
	{
	#ifdef USE_FORK_TO_CHECK
	pid_t nChild = fork();
	if ( nChild )
	{
	int exitVal;
	wait( &exitVal );
	if ( exitVal & 0xff )
	return -1;
	else
	return exitVal >> 8;
	}
	else
	{
	exit( func( eT, p ) );
	}
	#else
	int result;

	bSignal = 0;

	if ( !setjmp( check_env ) )
	{
	signal( SIGSEGV, SignalHandler );
	#ifdef UNX
	signal( SIGBUS, SignalHandler );
	#else
	#endif
	result = func( eT, p );
	signal( SIGSEGV, SIG_DFL );
	#ifdef UNX
	signal( SIGBUS, SIG_DFL );
	#else
	#endif
	}

	if ( bSignal )
	return -1;
	else
	return 0;
	#endif
	}

	#endif


	int GetAtAddress( Type eT, void* p )
	{
	switch ( eT )
	{
	case t_char: return ((char)p);
	case t_short: return ((short)p);
	case t_int: return ((int)p);
	case t_long: return ((long)p);
	case t_double: return ((double)p);
	}
	abort();
	}

	int SetAtAddress( Type eT, void* p )
	{
	switch ( eT )
	{
	case t_char: return ((char)p) = 0;
	case t_short: return ((short)p) = 0;
	case t_int: return ((int)p) = 0;
	case t_long: return ((long)p) = 0;
	case t_double: return ((double)p)= 0;
	}
	abort();
	}

	char* TypeName( Type eT )
	{
	switch ( eT )
	{
	case t_char: return "char";
	case t_short: return "short";
	case t_int: return "int";
	case t_long: return "long";
	case t_double: return "double";
	}
	abort();
	}

	int CheckGetAccess( Type eT, void* p )
	{
	int b;
	b = -1 != check( (TestFunc)GetAtAddress, eT, p );
	#if OSL_DEBUG_LEVEL > 1
	fprintf( stderr,
	"%s read %s at %p\n",
	(b? "can" : "can not" ), TypeName(eT), p );
	#endif
	return b;
	}
	int CheckSetAccess( Type eT, void* p )
	{
	int b;
	b = -1 != check( (TestFunc)SetAtAddress, eT, p );
	#if OSL_DEBUG_LEVEL > 1
	fprintf( stderr,
	"%s write %s at %p\n",
	(b? "can" : "can not" ), TypeName(eT), p );
	#endif
	return b;
	}

	int GetAlignment( Type eT )
	{
	char a[ 16*8 ];
	int p = (int)(void*)&a;
	int i;
	p = ( p + 0xF ) & ~0xF;
	for ( i = 1; i < 16; i++ )
	if ( CheckGetAccess( eT, (void*)(p+i) ) )
	return i;
	return 0;
	}

	int CheckCharAccess( char* p )
	{
	if ( CheckGetAccess( t_char, p ) )
	printf( "can read address %p\n", p );
	else
	printf( "can not read address %p\n", p );

	if ( CheckSetAccess( t_char, p ) )
	printf( "can write address %p\n", p );
	else
	printf( "can not write address %p\n", p );

	return 0;
	}

	struct Description
	{
	int bBigEndian;
	int bStackGrowsDown;
	int nStackAlignment;
	int nAlignment[3]; /* 2,4,8 */
	};

	void Description_Ctor( struct Description* pThis )
	{
	pThis->bBigEndian = IsBigEndian();
	pThis->bStackGrowsDown = IsStackGrowingDown();
	pThis->nStackAlignment = GetStackAlignment();

	if ( sizeof(short) != 2 )
	abort();
	pThis->nAlignment[0] = GetAlignment( t_short );
	if ( sizeof(int) != 4 )
	abort();
	pThis->nAlignment[1] = GetAlignment( t_int );
	if ( sizeof(double) != 8 )
	abort();
	pThis->nAlignment[2] = GetAlignment( t_double );
	}

	void Description_Print( struct Description* pThis, char* name )
	{
	int i;
	FILE* f = fopen( name, "w" );
	fprintf( f, "#define __%s\n",
	pThis->bBigEndian ? "BIGENDIAN" : "LITTLEENDIAN" );
	for ( i = 0; i < 3; i++ )
	fprintf( f, "#define __ALIGNMENT%d\t%d\n",
	1 << (i+1), pThis->nAlignment[i] );
	fprintf( f, "#define __STACKALIGNMENT wird nicht benutzt\t%d\n", pThis->nStackAlignment );
	fprintf( f, "#define __STACKDIRECTION\t%d\n",
	pThis->bStackGrowsDown ? -1 : 1 );
	fprintf( f, "#define __SIZEOFCHAR\t%d\n", sizeof( char ) );
	fprintf( f, "#define __SIZEOFSHORT\t%d\n", sizeof( short ) );
	fprintf( f, "#define __SIZEOFINT\t%d\n", sizeof( int ) );
	fprintf( f, "#define __SIZEOFLONG\t%d\n", sizeof( long ) );
	fprintf( f, "#define __SIZEOFPOINTER\t%d\n", sizeof( void* ) );
	fprintf( f, "#define __SIZEOFDOUBLE\t%d\n", sizeof( double ) );
	fprintf( f, "#define __IEEEDOUBLE\n" );
	fprintf( f, "#define _SOLAR_NODESCRIPTION\n" );

	fclose(f);
	}

	int
	#ifdef WNT
	__cdecl
	#endif
	main( int argc, char* argv[] )
	{
	printTypeSign( char, "char" );
	printTypeSign( short, "short" );
	printTypeSign( int, "int" );
	printTypeSign( long, "long" );

	printTypeSize( char, "char" );
	printTypeSize( short, "short" );
	printTypeSize( int, "int" );
	printTypeSize( long, "long" );
	printTypeSize( float, "float" );
	printTypeSize( double, "double" );
	printTypeSize( void , "void " );

	if ( IsBigEndian() )
	printf( "BIGENDIAN (Sparc, MC680x0, RS6000)\n" );
	else
	printf( "LITTLEENDIAN (Intel, VAX, PowerPC)\n" );

	if( IsStackGrowingDown() )
	printf( "Stack waechst nach unten\n" );
	else
	printf( "Stack waechst nach oben\n" );

	printf( "STACKALIGNMENT : %d\n", GetStackAlignment() );

	PrintArgs( 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 );

	{
	char a[64];
	int i = 56;
	do
	{
	printf( "Zugriff long auf %i-Aligned Adresse : ", i / 7 );
	printf( ( CheckGetAccess( t_long, (long*)&a[i] ) ? "OK\n" : "ERROR\n" ) );
	i >>= 1;
	} while( i >= 7 );
	}

	{
	char a[64];
	int i = 56;
	do
	{
	printf( "Zugriff double auf %i-Aligned Adresse : ", i / 7 );
	printf( ( CheckGetAccess( t_double, (double*)&a[i] ) ? "OK\n" : "ERROR\n" ) );
	i >>= 1;
	} while( i >= 7 );
	}

	{
	char* p = NULL;
	CheckCharAccess( p );
	p = (char*)&p;
	CheckCharAccess( p );
	}

	if ( argc > 1 )
	{
	struct Description description;
	Description_Ctor( &description );
	Description_Print( &description, argv[1] );
	}

	exit( 0 );
	return 0;
	}