diff options
Diffstat (limited to 'extensions/workben/pythontest.cxx')
| -rw-r--r-- | extensions/workben/pythontest.cxx | 591 |
1 files changed, 591 insertions, 0 deletions
diff --git a/extensions/workben/pythontest.cxx b/extensions/workben/pythontest.cxx new file mode 100644 index 000000000000..1862bec6c943 --- /dev/null +++ b/extensions/workben/pythontest.cxx @@ -0,0 +1,591 @@ +/************************************************************************* + * + * $RCSfile: pythontest.cxx,v $ + * + * $Revision: 1.1.1.1 $ + * + * last change: $Author: hr $ $Date: 2000-09-18 16:16:56 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (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.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#include <stdio.h> +#include <stardiv/uno/repos/implementationregistration.hxx> +#include <stardiv/uno/script/script.hxx> +#include <stardiv/uno/beans/exactname.hxx> + +#include <rtl/ustring.hxx> +#include <vos/dynload.hxx> +#include <vos/diagnose.hxx> +#include <usr/services.hxx> +#include <vcl/svapp.hxx> +#include <usr/ustring.hxx> +#include <usr/weak.hxx> +#include <tools/string.hxx> +#include <vos/conditn.hxx> +#include <assert.h> + +#ifdef _USE_NAMESPACE +using namespace rtl; +using namespace vos; +using namespace usr; +#endif + +#define PCHAR_TO_USTRING(x) StringToOUString(String(x),CHARSET_SYSTEM) + + + +class NullEngineListenerRef : public XEngineListenerRef +{ + virtual void interrupt(const InterruptEngineEvent& Evt) THROWS( (UsrSystemException) ) {} + virtual void running(const EventObject& Evt) THROWS( (UsrSystemException) ) {} + virtual void finished(const FinishEngineEvent& Evt) THROWS( (UsrSystemException) ) {} +}; + +#define USTRING_TO_PCHAR(x) OUStringToString(x , CHARSET_DONTKNOW ).GetCharStr() + +class CmdDebugger : + public XEngineListener, + public OWeakObject +{ +public: + + CmdDebugger() + { + m_pDebuggingRef = 0; + m_pEngineRef = 0; + m_bIsTerminating = FALSE; + m_bIsRunning = FALSE; + } + + + CmdDebugger( XDebuggingRef *p, XEngineRef *pEngine , XInvokationRef *pInvokation) + { + attach( p , pEngine , pInvokation ); + } + + ~CmdDebugger() + { + if( m_pDebuggingRef ) { + detach(); + } + } + + BOOL queryInterface( Uik aUik, XInterfaceRef & rOut ); + void acquire() { OWeakObject::acquire(); } + void release() { OWeakObject::release(); } + void* getImplementation(Reflection *p) { return OWeakObject::getImplementation(p); } + + + void attach( XDebuggingRef *p , XEngineRef *pEngine , XInvokationRef *pInvokation ) + { + m_pDebuggingRef = p; + m_pEngineRef = pEngine; + m_pInvokationRef = pInvokation; + m_bIsRunning = FALSE; + m_bIsTerminating = FALSE; + } + + void detach( ); + + + virtual void disposing( const EventObject &o ) + { + if( m_pDebuggingRef ) { + detach(); + } + } + virtual void interrupt(const InterruptEngineEvent& Evt) THROWS( (UsrSystemException) ) + { + if( m_pDebuggingRef && ! m_bIsTerminating ) { + (*m_pDebuggingRef)->stop(); + fprintf( stderr, "%s\n" , USTRING_TO_PCHAR(Evt.ErrorMessage ) ); + fprintf( stderr, "%s.%s (%d)\n", USTRING_TO_PCHAR(Evt.SourceCode), + USTRING_TO_PCHAR(Evt.Name ), + Evt.StartLine ); + m_aDebugCondition.set(); + m_bIsRunning = TRUE; + } + } + + virtual void running(const EventObject& Evt) THROWS( (UsrSystemException) ) + { + if( m_pDebuggingRef && ! m_bIsTerminating ) { + (*m_pDebuggingRef)->stop(); + + m_aDebugCondition.set(); + m_bIsRunning = TRUE; + fprintf( stderr, "%s\n" , "Script starts\n" ); + } + } + + virtual void finished(const FinishEngineEvent& Evt) THROWS( (UsrSystemException) ) + { + if( m_pDebuggingRef && ! m_bIsTerminating ) { + m_aDebugCondition.set(); + m_bIsRunning = FALSE; + fprintf( stderr , "%s\n", USTRING_TO_PCHAR( Evt.ErrorMessage ) ); + } + } + + void dumpIntrospectionToStream( const XIntrospectionAccessRef &, FILE *f ); + void dumpVarToStream( const char *pcName, const UsrAny &any, FILE *f ); + + + void cmdLine(); +protected: + + OCondition m_aDebugCondition; + XDebuggingRef *m_pDebuggingRef; + XEngineRef *m_pEngineRef; + XInvokationRef *m_pInvokationRef; + int m_bIsRunning; + int m_bIsTerminating; // The listeners ignore everything when set +}; + + + +void CmdDebugger::cmdLine() +{ + char pcLine[80]; + fprintf( stderr, "entering debugger\n" ); + while( TRUE ) { + + m_aDebugCondition.wait(); + + fprintf( stderr , "(debug %d) : " , m_bIsRunning ); + fflush( stderr); + fgets( pcLine , 79 , stdin ); + + if( strlen( pcLine) ) pcLine[strlen(pcLine)-1] =0; + String sLine( pcLine ); + + if( ! strcmp( pcLine , "g" ) ) { + if( m_bIsRunning ) { + m_aDebugCondition.reset(); + (*m_pDebuggingRef)->doContinue(); + } + else fprintf( stderr,"no script running !\n" ); + } + else if( ! strcmp( pcLine , "s" ) ) { + if( m_bIsRunning ) { + m_aDebugCondition.reset(); + (*m_pDebuggingRef)->stepOver(); + } + else fprintf(stderr, "no script running !\n" ); + } + else if( ! strcmp( pcLine , "so" ) ) { + if( m_bIsRunning ) { + m_aDebugCondition.reset(); + (*m_pDebuggingRef)->stepOut(); + } + else fprintf(stderr, "no script running !\n" ); + } + else if( ! strcmp( pcLine , "si" ) ) { + if( m_bIsRunning ) { + m_aDebugCondition.reset(); + (*m_pDebuggingRef)->stepIn(); + } + else fprintf(stderr, "no script running !\n" ); + } + else if( ! strncmp( pcLine , "sbp" , 3 ) ){ + if( m_bIsRunning ) { + (*m_pDebuggingRef)->setBreakPoint( UString( L"<string>" ), + atoi(&pcLine[3]) , TRUE ); + } + } + else if( ! strncmp( pcLine , "rbp" , 3 ) ){ + if( m_bIsRunning ) { + (*m_pDebuggingRef)->setBreakPoint( UString( L"<string>" ), + atoi(&pcLine[3]) , FALSE ); + } + } + else if( ! strncmp( pcLine , "dv " , 3 ) ) { + if( m_bIsRunning ) { + int nCallstack = 0; + if( sLine.GetQuotedTokenCount( String("''"),' ' ) == 3 ) { + nCallstack = atoi( sLine.GetQuotedToken( 3 , String("''"), ' ' ).GetCharStr() ); + } + + UString str = (*m_pDebuggingRef)->dumpVariable( + PCHAR_TO_USTRING( &pcLine[3]),nCallstack); + fprintf( stderr, "%s\n" , USTRING_TO_PCHAR( str ) ); + } + } + else if( ! strncmp( pcLine , "sv " , 3 ) ) { + int nCallstack = 0; + if( sLine.GetQuotedTokenCount( String("''"),' ' ) == 3 ) { + nCallstack = atoi( sLine.GetQuotedToken( 3 , String("''"), ' ' ).GetCharStr() ); + } + (*m_pDebuggingRef)->setVariable( + StringToOUString( sLine.GetQuotedToken( 1 , String("''"), ' ' ), CHARSET_SYSTEM ), + StringToOUString( sLine.GetQuotedToken( 2 , String("''"), ' ' ), CHARSET_SYSTEM ), + nCallstack ); + + } + else if( ! strncmp( pcLine , "ci" ,2 ) ) { + if( m_bIsRunning ) { + UString *aUString ; + ContextInformation ci = (*m_pDebuggingRef)->getContextInformation(atoi(&pcLine[2])); + int i,iMax; + + fprintf( stderr, "File %s (%d)\n", USTRING_TO_PCHAR(ci.Name), + ci.StartLine ); + fprintf( stderr, "Available variables : \n" ); + aUString = ci.LocalVariableNames.getArray(); + iMax = ci.LocalVariableNames.getLen(); + + for( i = 0 ; i < iMax ; i++ ) { + fprintf( stderr, " %s\n" , USTRING_TO_PCHAR( aUString[i]) ); + } + } + } + else if ( !strcmp( pcLine , "d" ) ) { + if( m_bIsRunning ) { + UString * aUString ; + Sequence<UString> seq = (*m_pDebuggingRef)->getStackTrace(); + + aUString = seq.getArray(); + int iMax = seq.getLen(); + for( int i = 0; i < iMax ; i++ ) { + fprintf( stderr , "%s\n" , USTRING_TO_PCHAR( aUString[i] ) ); + } + } + } + else if( !strcmp( pcLine , "c" ) ) { + if( m_bIsRunning ) { + (*m_pEngineRef)->cancel(); + m_aDebugCondition.reset(); + } + else fprintf( stderr,"no script running !\n" ); + } + else if( !strcmp( pcLine , "q" ) ) { + if( m_bIsRunning ) { + m_aDebugCondition.reset(); + (*m_pEngineRef)->cancel(); + } + else { + m_bIsTerminating = TRUE; + fprintf(stderr, "Debugger terminates\n" ); + break; + } + } + else if( ! strcmp( pcLine , "id" ) ) { + + XIntrospectionAccessRef ref = (*m_pInvokationRef)->getIntrospection(); + + dumpIntrospectionToStream( ref , stderr ); + + + } + else if( ! strncmp( pcLine , "idv" , 3) ) { + TRY { + UsrAny any = (*m_pInvokationRef)->getValue( PCHAR_TO_USTRING( &(pcLine[4]) ) ); + dumpVarToStream( &(pcLine[4]) , any , stderr ); + } + CATCH(UnknownPropertyException,e) { + fprintf( stderr, "UnknownPropertyException\n" ); + } + CATCH(IllegalArgumentException,e) { + fprintf( stderr, "IllegalArgumentException\n" ); + } + } + else if( !strcmp( pcLine , "t" ) ) { + } + else if( !strcmp( pcLine , "h" ) ) { + fprintf( stderr , "\nvalid commands :\n" + "Go : g\n" + "StepOver : s\n" + "StepIn : si\n" + "StepOut : so\n" + "Set BreakPoint : sbp Line [ModuleName]\n" + "Remove BreakPoint : rbp [Line] [ModuleName]\n" + "via XDebugging Interface :\n" + " dump Variable : dv varname [CallStack]\n" + " set Variable : sv varname value [CallStack]\n" + "globals via XInvokation Interface :\n" + " dump Global vars : id\n" + " dump Variable : idv varname\n" + " set Variable : isv varname value\n" + "ContextInformation : ci\n" + "Dump callstack : d\n" + "Cancel : c (stops actual script)\n" + "Quit : q (exits debugger)\n" + ); + } + else if( ! strlen( pcLine ) ) { + } + else { + fprintf( stderr , "unknown command %s\n" , pcLine ); + } + } +} + +void CmdDebugger::dumpIntrospectionToStream( const XIntrospectionAccessRef &ref, FILE *f ) +{ + int i,iMax; + fprintf( stderr, "Callable Attributes (Methods) :\n" ); + Sequence<XIdlMethodRef> seq = ref->getMethods( 0 ); + iMax = seq.getLen(); + XIdlMethodRef *aRef = seq.getArray(); + for( i = 0; i < iMax ; i++ ) { + fprintf( f, " %s\n" , USTRING_TO_PCHAR( aRef[i]->getName( ) ) ); + } + + fprintf( stderr, "Other attributes\n" ); + Sequence<Property> seqProp = ref->getProperties( 0 ); + iMax = seqProp.getLen(); + Property *aProp = seqProp.getArray(); + for( i = 0; i < iMax ; i ++ ) { + fprintf( f, " %s %s\n" , USTRING_TO_PCHAR( aProp[i].Type->getName() ), + USTRING_TO_PCHAR( aProp[i].Name ) ); + } + +} + +void CmdDebugger::dumpVarToStream( const char *pc , const UsrAny &aValue, FILE *f ) +{ + TypeClass type = aValue.getReflection()->getTypeClass(); + + if( TypeClass_INT == type ) { + fprintf( f, "INT32 %s : %d\n" , pc , aValue.getINT32() ); + } + else if( TypeClass_ENUM == type ) { + fprintf( f, "ENUM %s : %d\n", pc , aValue.getEnumAsINT32() ); + } + else if( TypeClass_STRING == type ) { + fprintf( f, "STRING %s : %s\n" , pc , USTRING_TO_PCHAR( aValue.getString()) ); + } + else if( TypeClass_BOOLEAN == type ) { + fprintf( f, "BOOL %s : %d\n", pc , aValue.getBOOL() ); + } + else if( TypeClass_CHAR == type ) { + fprintf( f, "char %s : %d\n", pc , ( INT32) aValue.getChar() ); + } + else if( TypeClass_SHORT == type ) { + fprintf( f, "INT16 %s : %d\n", pc , (INT32) aValue.getINT16()); + } + else if( TypeClass_LONG == type ) { + fprintf( f, "LONG %s : %d\n", pc , (INT32) aValue.getINT32()); + } + else if( TypeClass_UNSIGNED_SHORT == type ) { + fprintf( f, "UINT16 %s : %d\n", pc , (INT32) aValue.getUINT16() ); + } + else if( TypeClass_UNSIGNED_BYTE == type ) { + fprintf( f, "Byte %s : %d\n", pc , (INT32) aValue.getBYTE() ); + } + else if( TypeClass_UNSIGNED_INT == type ) { + fprintf( f, "UINT32 %s : %d\n", pc , aValue.getUINT32() ); + } + else if( TypeClass_FLOAT == type ) { + fprintf( f, "float %s : %f\n" , pc , aValue.getFloat() ); + } + else if( TypeClass_DOUBLE == type ) { + fprintf( f, "double %s : %f\n" , pc , aValue.getDouble() ); + } + else if( TypeClass_VOID == type ) { + fprintf( f, "void %s :\n" , pc ); + } + else if( TypeClass_INTERFACE == type ) { + // Check, what has been put in + if( aValue.getReflection() == XPropertySet_getReflection() ) { + // XPropertySet ! + XPropertySetRef *pRef = ( XPropertySetRef * ) aValue.get(); + XPropertySetInfoRef refInfo = (*pRef)->getPropertySetInfo(); + Sequence< Property > seq = refInfo->getProperties(); + int i,iMax = seq.getLen(); + + Property *pArray; + pArray = seq.getArray(); + fprintf( stderr, "Property List :\n" ); + for( i = 0; i < iMax ; i ++ ) { + fprintf( f, "%s\t %s\n" , USTRING_TO_PCHAR(pArray[i].Type->getName()), + USTRING_TO_PCHAR( pArray[i].Name ) ); + } + } + else if( aValue.getReflection() == XInvokation_getReflection() ) { + XInvokationRef *pRef = ( XInvokationRef * ) aValue.get(); + XIntrospectionAccessRef refIntro = (*pRef)->getIntrospection(); + + dumpIntrospectionToStream( refIntro, stderr ); + } + } + else if( TypeClass_SEQUENCE == type ) { + fprintf( f , "%s Sequence \n" , pc ); + String s( " " ); + s += pc; + SequenceReflection *pSeqRefl = ( SequenceReflection * ) aValue.getReflection(); + + int i,iMax = pSeqRefl->getLen( aValue ); + + for( i = 0 ; i < iMax ; i ++ ) { + dumpVarToStream( s.GetCharStr() , pSeqRefl->get( aValue , i ) , stderr ); + } + } + else { + fprintf( f, "%s : unknown %d\n" , pc , type ); + } + +} + +void CmdDebugger::detach() +{ + assert( m_pDebuggingRef ); + + m_bIsRunning = FALSE; + m_pDebuggingRef = 0; + m_pEngineRef = 0; + m_pInvokationRef = 0; +} + +// Methoden von XInterface +BOOL CmdDebugger::queryInterface( Uik aUik, XInterfaceRef & rOut ) +{ + if( aUik == XEngineListener::getSmartUik() ) + rOut = (XEngineListener*)this; + else + return OWeakObject::queryInterface( aUik, rOut ); + return TRUE; +} + + + + + + +/* + * main. + */ +int __LOADONCALLAPI main (int argc, char **argv) +{ + XMultiServiceFactoryRef xSMgr = createRegistryServiceManager(); + registerUsrServices( xSMgr ); + setProcessServiceManager( xSMgr ); + + XInterfaceRef x = xSMgr->createInstance( L"stardiv.uno.repos.ImplementationRegistration" ); + XImplementationRegistrationRef xReg( x, USR_QUERY ); + sal_Char szBuf[1024]; + + ORealDynamicLoader::computeModuleName( "pythonengine", szBuf, 1024 ); + UString aDllName( StringToOUString( szBuf, CHARSET_SYSTEM ) ); + xReg->registerImplementation( L"stardiv.loader.SharedLibrary", aDllName, XSimpleRegistryRef() ); + + ORealDynamicLoader::computeModuleName( "aps", szBuf, 1024 ); + aDllName = UString( StringToOUString( szBuf, CHARSET_SYSTEM ) ); + xReg->registerImplementation( L"stardiv.loader.SharedLibrary", aDllName, XSimpleRegistryRef() ); + + XInterfaceRef y = xSMgr->createInstance( L"stardiv.script.Python" ); + XEngineRef yEngine( y, USR_QUERY ); + + x = xSMgr->createInstance( L"stardiv.script.Python" ); + XEngineRef xEngine( x, USR_QUERY ); + + + UString Script; + + Sequence<UsrAny> args(3); + UsrAny *pArray = args.getArray(); + pArray[0].setString( L"Arg_0" ); + pArray[1].setString( L"Arg_1" ); + pArray[2].setString( L"Arg_2" ); + + if( argc > 2) { + Script = StringToOUString( String( argv[2] ) , CHARSET_DONTKNOW ); + } + + XInvokationRef xInvokation( x , USR_QUERY ); + XDebuggingRef xDebug( x , USR_QUERY ); + + CmdDebugger *pDbg = new CmdDebugger( &xDebug , &xEngine , &xInvokation ); + + XEngineListenerRef xDebugRef( (XEngineListener *) pDbg , USR_QUERY); + xEngine->addEngineListener( xDebugRef ); + + + if( argc >1 && ! strcmp( argv[1] , "1" ) ) { + fprintf( stderr, "one thread only\n" ); + Script = UString( L"print 'Hello World'\n" ); + xEngine->runAsync( Script , XInterfaceRef(), args , XEngineListenerRef() ); + } + else if( argc >1 && ! strcmp( argv[1] , "2" ) ) { + + xEngine->runAsync( UString( L"x=1\nprint 1\n") , XInterfaceRef(), args , XEngineListenerRef() ); + xEngine->runAsync( UString( L"x=x+1\nprint 2\n") , XInterfaceRef(), args , XEngineListenerRef() ); + xEngine->runAsync( UString( L"x=x+1\nprint 3\n") , XInterfaceRef(), args , XEngineListenerRef()); + xEngine->runAsync( UString( L"x=x+1\nprint 4\n") , XInterfaceRef(), args , XEngineListenerRef() ); + + + + } + else if( argc >1 && ! strcmp( argv[1] , "3" ) ) { + + fprintf( stderr , "1st thread in engine y, next 5 threads in engine x\n" ); + yEngine->runAsync( UString( L"print 1\n") , XInterfaceRef(), args , XEngineListenerRef() ); + xEngine->runAsync( UString( L"print 2\n") , XInterfaceRef(), args , XEngineListenerRef() ); + xEngine->runAsync( UString( L"print 3\n") , XInterfaceRef(), args , XEngineListenerRef() ); + xEngine->runAsync( UString( L"print 4\n") , XInterfaceRef(), args , XEngineListenerRef()); + xEngine->runAsync( UString( L"print 5\n") , XInterfaceRef(), args , XEngineListenerRef()); + xEngine->runAsync( UString( L"print 6\n") , XInterfaceRef(), args , XEngineListenerRef()); + + + } + pDbg->cmdLine(); + + xEngine->removeEngineListener( xDebugRef ); + + xReg->revokeImplementation( aDllName, XSimpleRegistryRef() ); + + fprintf( stderr, "main terminates\n" ); + return 0; +} + |