extensions/workben/pythontest.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include <stdio.h>
  22 #include <stardiv/uno/repos/implementationregistration.hxx>
  23 #include <stardiv/uno/script/script.hxx>
  24 #include <stardiv/uno/beans/exactname.hxx>
  25
  26 #include <rtl/ustring.hxx>
  27 #include <osl/diagnose.h>
  28 #include <usr/services.hxx>
  29 #include <vcl/svapp.hxx>
  30 #include <usr/ustring.hxx>
  31 #include <usr/weak.hxx>
  32 #include <tools/string.hxx>
  33 #include <osl/conditn.hxx>
  34
  35 using namespace usr;
  36
  37 using ::rtl::StringToOUString;
  38
  39
  40 #define PCHAR_TO_USTRING(x) StringToOUString(String(x),CHARSET_SYSTEM)
  41
  42
  43
  44 class NullEngineListenerRef : public XEngineListenerRef
  45 {
  46     virtual void interrupt(const InterruptEngineEvent& Evt) THROWS( (UsrSystemException) ) {}
  47     virtual void running(const EventObject& Evt) THROWS( (UsrSystemException) ) {}
  48     virtual void finished(const FinishEngineEvent& Evt) THROWS( (UsrSystemException) ) {}
  49 };
  50
  51 #define USTRING_TO_PCHAR(x) OUStringToString(x , CHARSET_DONTKNOW ).GetCharStr()
  52
  53 class CmdDebugger :
  54     public XEngineListener,
  55     public OWeakObject
  56 {
  57 public:
  58
  59     CmdDebugger()
  60     {
  61         m_pDebuggingRef = 0;
  62         m_pEngineRef = 0;
  63         m_bIsTerminating = FALSE;
  64         m_bIsRunning = FALSE;
  65     }
  66
  67
  68     CmdDebugger( XDebuggingRef *p, XEngineRef *pEngine , XInvokationRef *pInvokation)
  69     {
  70         attach( p , pEngine , pInvokation );
  71     }
  72
  73     ~CmdDebugger()
  74     {
  75         if( m_pDebuggingRef ) {
  76             detach();
  77         }
  78     }
  79
  80     BOOL                queryInterface( Uik aUik, XInterfaceRef & rOut );
  81     void                acquire()                        { OWeakObject::acquire(); }
  82     void                release()                        { OWeakObject::release(); }
  83     void*               getImplementation(Reflection *p) { return OWeakObject::getImplementation(p); }
  84
  85
  86     void attach( XDebuggingRef *p , XEngineRef *pEngine , XInvokationRef *pInvokation )
  87     {
  88         m_pDebuggingRef = p;
  89         m_pEngineRef = pEngine;
  90         m_pInvokationRef = pInvokation;
  91         m_bIsRunning = FALSE;
  92         m_bIsTerminating = FALSE;
  93     }
  94
  95     void detach( );
  96
  97
  98     virtual void disposing( const EventObject &o )
  99     {
 100         if( m_pDebuggingRef ) {
 101             detach();
 102         }
 103     }
 104     virtual void interrupt(const InterruptEngineEvent& Evt) THROWS( (UsrSystemException) )
 105     {
 106         if( m_pDebuggingRef && ! m_bIsTerminating ) {
 107                (*m_pDebuggingRef)->stop();
 108                fprintf( stderr, "%s\n" , USTRING_TO_PCHAR(Evt.ErrorMessage ) );
 109             fprintf( stderr, "%s.%s (%d)\n",  USTRING_TO_PCHAR(Evt.SourceCode),
 110                                               USTRING_TO_PCHAR(Evt.Name ),
 111                                               Evt.StartLine );
 112                m_aDebugCondition.set();
 113             m_bIsRunning = TRUE;
 114            }
 115     }
 116
 117     virtual void running(const EventObject& Evt) THROWS( (UsrSystemException) )
 118        {
 119         if( m_pDebuggingRef && ! m_bIsTerminating ) {
 120                (*m_pDebuggingRef)->stop();
 121
 122             m_aDebugCondition.set();
 123             m_bIsRunning = TRUE;
 124             fprintf( stderr, "%s\n" , "Script starts\n" );
 125         }
 126     }
 127
 128     virtual void finished(const FinishEngineEvent& Evt) THROWS( (UsrSystemException) )
 129     {
 130         if( m_pDebuggingRef && ! m_bIsTerminating  ) {
 131             m_aDebugCondition.set();
 132             m_bIsRunning = FALSE;
 133             fprintf( stderr , "%s\n", USTRING_TO_PCHAR( Evt.ErrorMessage ) );
 134         }
 135     }
 136
 137     void dumpIntrospectionToStream( const XIntrospectionAccessRef &, FILE *f );
 138     void dumpVarToStream( const char *pcName, const UsrAny &any, FILE *f );
 139
 140
 141     void cmdLine();
 142 protected:
 143
 144     osl::Condition m_aDebugCondition;
 145     XDebuggingRef *m_pDebuggingRef;
 146     XEngineRef  *m_pEngineRef;
 147     XInvokationRef *m_pInvokationRef;
 148     int m_bIsRunning;
 149     int m_bIsTerminating;       // The listeners ignore everything when set
 150 };
 151
 152
 153
 154 void CmdDebugger::cmdLine()
 155 {
 156         char pcLine[80];
 157         fprintf( stderr, "entering debugger\n" );
 158         while( TRUE ) {
 159
 160             m_aDebugCondition.wait();
 161
 162             fprintf( stderr , "(debug %d) : " , m_bIsRunning );
 163             fflush( stderr);
 164             fgets( pcLine ,  79 , stdin );
 165
 166             if( strlen( pcLine) ) pcLine[strlen(pcLine)-1] =0;
 167             String sLine( pcLine );
 168
 169             if( ! strcmp( pcLine , "g" ) ) {
 170                 if( m_bIsRunning ) {
 171                     m_aDebugCondition.reset();
 172                     (*m_pDebuggingRef)->doContinue();
 173                 }
 174                 else fprintf( stderr,"no script running !\n" );
 175             }
 176             else if( ! strcmp( pcLine , "s" ) ) {
 177                 if( m_bIsRunning ) {
 178                     m_aDebugCondition.reset();
 179                     (*m_pDebuggingRef)->stepOver();
 180                 }
 181                 else fprintf(stderr, "no script running !\n" );
 182             }
 183             else if( ! strcmp( pcLine , "so" ) ) {
 184                 if( m_bIsRunning ) {
 185                     m_aDebugCondition.reset();
 186                     (*m_pDebuggingRef)->stepOut();
 187                 }
 188                 else fprintf(stderr, "no script running !\n" );
 189             }
 190             else if( ! strcmp( pcLine , "si" ) ) {
 191                 if( m_bIsRunning ) {
 192                     m_aDebugCondition.reset();
 193                     (*m_pDebuggingRef)->stepIn();
 194                 }
 195                 else fprintf(stderr, "no script running !\n" );
 196             }
 197             else if( ! strncmp( pcLine , "sbp" , 3 ) ){
 198                 if( m_bIsRunning ) {
 199                     (*m_pDebuggingRef)->setBreakPoint(  UString( L"<string>" ),
 200                                                         atoi(&pcLine[3]) , TRUE );
 201                 }
 202             }
 203             else if( ! strncmp( pcLine , "rbp" , 3 ) ){
 204                 if( m_bIsRunning ) {
 205                     (*m_pDebuggingRef)->setBreakPoint(  UString( L"<string>" ),
 206                                                         atoi(&pcLine[3]) , FALSE );
 207                 }
 208             }
 209             else if( ! strncmp( pcLine , "dv " , 3 ) ) {
 210                 if( m_bIsRunning ) {
 211                     int nCallstack = 0;
 212                     if( sLine.GetQuotedTokenCount( String("''"),' ' ) == 3 ) {
 213                         nCallstack = atoi( sLine.GetQuotedToken( 3 , String("''"), ' ' ).GetCharStr() );
 214                     }
 215
 216                     UString str = (*m_pDebuggingRef)->dumpVariable(
 217                                                     PCHAR_TO_USTRING( &pcLine[3]),nCallstack);
 218                     fprintf( stderr, "%s\n" , USTRING_TO_PCHAR( str ) );
 219                 }
 220             }
 221             else if( ! strncmp( pcLine , "sv " , 3 ) ) {
 222                 int nCallstack = 0;
 223                 if( sLine.GetQuotedTokenCount( String("''"),' ' ) == 3 ) {
 224                     nCallstack = atoi( sLine.GetQuotedToken( 3 , String("''"), ' ' ).GetCharStr() );
 225                 }
 226                 (*m_pDebuggingRef)->setVariable(
 227                         StringToOUString( sLine.GetQuotedToken( 1 , String("''"), ' ' ), CHARSET_SYSTEM ),
 228                         StringToOUString( sLine.GetQuotedToken( 2 , String("''"), ' ' ), CHARSET_SYSTEM ),
 229                         nCallstack );
 230
 231             }
 232             else if( ! strncmp( pcLine , "ci" ,2 ) ) {
 233                 if( m_bIsRunning ) {
 234                     UString *aUString ;
 235                     ContextInformation ci = (*m_pDebuggingRef)->getContextInformation(atoi(&pcLine[2]));
 236                     int i,iMax;
 237
 238                     fprintf( stderr, "File %s (%d)\n", USTRING_TO_PCHAR(ci.Name),
 239                                                        ci.StartLine );
 240                     fprintf( stderr, "Available variables : \n" );
 241                     aUString = ci.LocalVariableNames.getArray();
 242                     iMax = ci.LocalVariableNames.getLen();
 243
 244                     for( i = 0 ; i < iMax ; i++ ) {
 245                         fprintf( stderr, "      %s\n" , USTRING_TO_PCHAR( aUString[i]) );
 246                     }
 247                 }
 248             }
 249             else if ( !strcmp( pcLine , "d" ) ) {
 250                 if( m_bIsRunning ) {
 251                     UString * aUString ;
 252                     Sequence<UString> seq =  (*m_pDebuggingRef)->getStackTrace();
 253
 254                     aUString = seq.getArray();
 255                     int iMax = seq.getLen();
 256                     for( int i = 0; i < iMax ; i++ ) {
 257                         fprintf( stderr , "%s\n" , USTRING_TO_PCHAR( aUString[i] ) );
 258                     }
 259                 }
 260             }
 261             else if( !strcmp( pcLine , "c" ) ) {
 262                 if( m_bIsRunning ) {
 263                     (*m_pEngineRef)->cancel();
 264                     m_aDebugCondition.reset();
 265                 }
 266                 else fprintf( stderr,"no script running !\n" );
 267             }
 268             else if( !strcmp( pcLine , "q" ) ) {
 269                 if( m_bIsRunning ) {
 270                     m_aDebugCondition.reset();
 271                     (*m_pEngineRef)->cancel();
 272                 }
 273                 else {
 274                     m_bIsTerminating = TRUE;
 275                     fprintf(stderr,  "Debugger terminates\n" );
 276                     break;
 277                 }
 278             }
 279             else if( ! strcmp( pcLine , "id" ) ) {
 280
 281                 XIntrospectionAccessRef ref = (*m_pInvokationRef)->getIntrospection();
 282
 283                 dumpIntrospectionToStream( ref , stderr );
 284
 285
 286             }
 287             else if( ! strncmp( pcLine , "idv" , 3) ) {
 288                 try {
 289                     UsrAny any = (*m_pInvokationRef)->getValue( PCHAR_TO_USTRING( &(pcLine[4]) ) );
 290                     dumpVarToStream( &(pcLine[4]) , any , stderr );
 291                 }
 292                 catch(UnknownPropertyException& e ) {
 293                     fprintf( stderr, "UnknownPropertyException\n" );
 294                 }
 295                 catch(IllegalArgumentException& e ) {
 296                     fprintf( stderr, "IllegalArgumentException\n" );
 297                 }
 298             }
 299             else if( !strcmp( pcLine , "t" ) ) {
 300             }
 301             else if( !strcmp( pcLine , "h" ) ) {
 302                 fprintf( stderr ,  "\nvalid commands :\n"
 303                                    "Go                 : g\n"
 304                                    "StepOver           : s\n"
 305                                    "StepIn             : si\n"
 306                                    "StepOut            : so\n"
 307                                    "Set BreakPoint     : sbp Line [ModuleName]\n"
 308                                    "Remove BreakPoint  : rbp [Line] [ModuleName]\n"
 309                                    "via XDebugging Interface :\n"
 310                                    "    dump Variable      : dv varname [CallStack]\n"
 311                                    "    set Variable       : sv varname value [CallStack]\n"
 312                                    "globals via XInvokation Interface :\n"
 313                                    "    dump Global vars   : id\n"
 314                                    "    dump Variable      : idv varname\n"
 315                                    "    set Variable       : isv varname value\n"
 316                                    "ContextInformation : ci\n"
 317                                    "Dump callstack     : d\n"
 318                                    "Cancel             : c (stops actual script)\n"
 319                                    "Quit               : q (exits debugger)\n"
 320                                    );
 321             }
 322             else if( ! strlen( pcLine ) ) {
 323             }
 324             else {
 325                 fprintf( stderr , "unknown command %s\n" , pcLine );
 326             }
 327         }
 328 }
 329
 330 void CmdDebugger::dumpIntrospectionToStream( const XIntrospectionAccessRef &ref, FILE *f )
 331 {
 332     int i,iMax;
 333     fprintf( stderr, "Callable Attributes (Methods) :\n" );
 334     Sequence<XIdlMethodRef> seq = ref->getMethods( 0 );
 335     iMax = seq.getLen();
 336     XIdlMethodRef *aRef = seq.getArray();
 337     for( i = 0; i < iMax ; i++ ) {
 338         fprintf( f, "  %s\n" , USTRING_TO_PCHAR( aRef[i]->getName( ) ) );
 339     }
 340
 341     fprintf( stderr, "Other attributes\n"  );
 342     Sequence<Property> seqProp = ref->getProperties( 0 );
 343     iMax = seqProp.getLen();
 344     Property *aProp = seqProp.getArray();
 345     for( i = 0; i < iMax ; i ++ ) {
 346         fprintf( f, "  %s %s\n" ,   USTRING_TO_PCHAR( aProp[i].Type->getName() ),
 347                                         USTRING_TO_PCHAR( aProp[i].Name ) );
 348     }
 349
 350 }
 351
 352 void CmdDebugger::dumpVarToStream( const char *pc , const UsrAny &aValue, FILE *f )
 353 {
 354     TypeClass type = aValue.getReflection()->getTypeClass();
 355
 356     if( TypeClass_INT == type ) {
 357         fprintf( f, "INT32 %s : %d\n" , pc , aValue.getINT32() );
 358     }
 359     else if( TypeClass_ENUM == type ) {
 360         fprintf( f, "ENUM %s : %d\n", pc ,  aValue.getEnumAsINT32() );
 361     }
 362     else if( TypeClass_STRING == type ) {
 363         fprintf( f, "STRING %s : %s\n" , pc ,  USTRING_TO_PCHAR( aValue.getString())     );
 364     }
 365     else if( TypeClass_BOOLEAN == type ) {
 366         fprintf( f, "BOOL %s : %d\n", pc , aValue.getBOOL() );
 367     }
 368     else if( TypeClass_CHAR == type  ) {
 369         fprintf( f, "char %s : %d\n", pc , ( INT32) aValue.getChar() );
 370     }
 371     else if( TypeClass_SHORT == type ) {
 372         fprintf( f, "INT16 %s : %d\n", pc , (INT32) aValue.getINT16());
 373     }
 374     else if( TypeClass_LONG == type ) {
 375         fprintf( f, "LONG %s : %d\n", pc , (INT32) aValue.getINT32());
 376     }
 377     else if( TypeClass_UNSIGNED_SHORT == type ) {
 378         fprintf( f, "UINT16 %s : %d\n", pc , (INT32) aValue.getUINT16() );
 379     }
 380     else if( TypeClass_UNSIGNED_BYTE == type ) {
 381         fprintf( f, "Byte %s : %d\n", pc ,  (INT32) aValue.getBYTE() );
 382     }
 383     else if( TypeClass_UNSIGNED_INT == type ) {
 384         fprintf( f, "UINT32 %s : %d\n", pc , aValue.getUINT32() );
 385     }
 386     else if( TypeClass_FLOAT == type ) {
 387         fprintf( f, "float %s : %f\n" , pc , aValue.getFloat() );
 388     }
 389     else if( TypeClass_DOUBLE == type ) {
 390         fprintf( f, "double %s : %f\n" , pc , aValue.getDouble() );
 391     }
 392     else if( TypeClass_VOID == type ) {
 393         fprintf( f, "void %s :\n" , pc );
 394     }
 395     else if( TypeClass_INTERFACE == type ) {
 396         // Check, what has been put in
 397         if( aValue.getReflection() == XPropertySet_getReflection() ) {
 398             // XPropertySet !
 399             XPropertySetRef *pRef = ( XPropertySetRef * ) aValue.get();
 400             XPropertySetInfoRef refInfo = (*pRef)->getPropertySetInfo();
 401             Sequence< Property > seq = refInfo->getProperties();
 402             int i,iMax = seq.getLen();
 403
 404             Property *pArray;
 405             pArray = seq.getArray();
 406             fprintf( stderr, "Property List :\n" );
 407             for( i = 0; i < iMax ; i ++ ) {
 408                 fprintf( f, "%s\t %s\n" , USTRING_TO_PCHAR(pArray[i].Type->getName()),
 409                                                  USTRING_TO_PCHAR( pArray[i].Name ) );
 410             }
 411         }
 412         else if( aValue.getReflection() == XInvokation_getReflection() ) {
 413             XInvokationRef *pRef = ( XInvokationRef * ) aValue.get();
 414             XIntrospectionAccessRef refIntro = (*pRef)->getIntrospection();
 415
 416             dumpIntrospectionToStream( refIntro, stderr );
 417         }
 418     }
 419     else if( TypeClass_SEQUENCE == type ) {
 420         fprintf( f , "%s Sequence \n" , pc  );
 421         String s( "   " );
 422         s += pc;
 423         SequenceReflection *pSeqRefl = ( SequenceReflection * ) aValue.getReflection();
 424
 425         int i,iMax = pSeqRefl->getLen( aValue );
 426
 427         for( i = 0 ; i < iMax ; i ++ ) {
 428             dumpVarToStream( s.GetCharStr() , pSeqRefl->get( aValue , i ) , stderr );
 429         }
 430     }
 431     else {
 432         fprintf( f, "%s : unknown %d\n" , pc , type  );
 433     }
 434
 435 }
 436
 437 void CmdDebugger::detach()
 438 {
 439     OSL_ASSERT( m_pDebuggingRef );
 440
 441        m_bIsRunning = FALSE;
 442        m_pDebuggingRef = 0;
 443     m_pEngineRef = 0;
 444     m_pInvokationRef = 0;
 445 }
 446
 447 // Methoden von XInterface
 448 BOOL CmdDebugger::queryInterface( Uik aUik, XInterfaceRef & rOut )
 449 {
 450     if( aUik == XEngineListener::getSmartUik() )
 451         rOut = (XEngineListener*)this;
 452     else
 453         return OWeakObject::queryInterface( aUik, rOut );
 454     return TRUE;
 455 }
 456
 457
 458
 459
 460
 461
 462 /*
 463  * main.
 464  */
 465 int SAL_CALL main (int argc, char **argv)
 466 {
 467     XMultiServiceFactoryRef xSMgr = createRegistryServiceManager();
 468     registerUsrServices( xSMgr );
 469     setProcessServiceManager( xSMgr );
 470
 471     XInterfaceRef x = xSMgr->createInstance( L"stardiv.uno.repos.ImplementationRegistration" );
 472     XImplementationRegistrationRef xReg( x, USR_QUERY );
 473     sal_Char szBuf[1024];
 474
 475     ORealDynamicLoader::computeModuleName( "pythonengine", szBuf, 1024 );
 476     UString aDllName( StringToOUString( szBuf, CHARSET_SYSTEM ) );
 477     xReg->registerImplementation( L"stardiv.loader.SharedLibrary", aDllName, XSimpleRegistryRef() );
 478
 479     ORealDynamicLoader::computeModuleName( "aps", szBuf, 1024 );
 480     aDllName = UString( StringToOUString( szBuf, CHARSET_SYSTEM ) );
 481     xReg->registerImplementation( L"stardiv.loader.SharedLibrary", aDllName, XSimpleRegistryRef() );
 482
 483     XInterfaceRef y = xSMgr->createInstance( L"stardiv.script.Python" );
 484     XEngineRef yEngine( y, USR_QUERY );
 485
 486     x = xSMgr->createInstance( L"stardiv.script.Python" );
 487     XEngineRef xEngine( x, USR_QUERY );
 488
 489
 490     UString Script;
 491
 492     Sequence<UsrAny> args(3);
 493     UsrAny *pArray = args.getArray();
 494     pArray[0].setString( L"Arg_0" );
 495     pArray[1].setString( L"Arg_1" );
 496     pArray[2].setString( L"Arg_2" );
 497
 498     if( argc > 2) {
 499         Script = StringToOUString( String( argv[2] ) ,  CHARSET_DONTKNOW );
 500     }
 501
 502     XInvokationRef xInvokation( x , USR_QUERY );
 503     XDebuggingRef xDebug( x , USR_QUERY );
 504
 505     CmdDebugger *pDbg = new CmdDebugger( &xDebug , &xEngine , &xInvokation );
 506
 507     XEngineListenerRef xDebugRef( (XEngineListener *) pDbg , USR_QUERY);
 508     xEngine->addEngineListener( xDebugRef );
 509
 510
 511     if( argc >1 && ! strcmp( argv[1] , "1" ) ) {
 512         fprintf( stderr, "one thread only\n" );
 513         Script = UString(   L"print 'Hello World'\n" );
 514         xEngine->runAsync( Script ,  XInterfaceRef(), args , XEngineListenerRef() );
 515     }
 516     else if( argc >1 && ! strcmp( argv[1] , "2" ) )  {
 517
 518         xEngine->runAsync( UString( L"x=1\nprint 1\n") ,  XInterfaceRef(), args , XEngineListenerRef() );
 519         xEngine->runAsync( UString( L"x=x+1\nprint 2\n") ,  XInterfaceRef(), args , XEngineListenerRef() );
 520         xEngine->runAsync( UString( L"x=x+1\nprint 3\n") ,  XInterfaceRef(), args , XEngineListenerRef());
 521         xEngine->runAsync( UString( L"x=x+1\nprint 4\n") ,  XInterfaceRef(), args , XEngineListenerRef() );
 522
 523
 524
 525     }
 526     else if( argc >1 && ! strcmp( argv[1] , "3" ) ) {
 527
 528         fprintf( stderr , "1st thread in engine y, next 5 threads in engine x\n" );
 529         yEngine->runAsync( UString( L"print 1\n") ,  XInterfaceRef(), args , XEngineListenerRef() );
 530         xEngine->runAsync( UString( L"print 2\n") ,  XInterfaceRef(), args , XEngineListenerRef() );
 531         xEngine->runAsync( UString( L"print 3\n") ,  XInterfaceRef(), args , XEngineListenerRef() );
 532         xEngine->runAsync( UString( L"print 4\n") ,  XInterfaceRef(), args , XEngineListenerRef());
 533         xEngine->runAsync( UString( L"print 5\n") ,  XInterfaceRef(), args , XEngineListenerRef());
 534         xEngine->runAsync( UString( L"print 6\n") ,  XInterfaceRef(), args , XEngineListenerRef());
 535
 536
 537     }
 538     pDbg->cmdLine();
 539
 540     xEngine->removeEngineListener( xDebugRef );
 541
 542     xReg->revokeImplementation( aDllName, XSimpleRegistryRef() );
 543
 544     fprintf( stderr, "main terminates\n" );
 545     return 0;
 546 }
 547
 548 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */