| /************************************************************** |
| * |
| * 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. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_extensions.hxx" |
| |
| #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> |
| |
| using namespace rtl; |
| using namespace vos; |
| using namespace usr; |
| |
| #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() |
| { |
| OSL_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; |
| } |
| |