extensions/workben/pythontest.cxx

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