basic/source/comp/sbcomp.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 <basic/sbx.hxx>
  22 #include "parser.hxx"
  23 #include "image.hxx"
  24 #include "sbobjmod.hxx"
  25 #include <svtools/miscopt.hxx>
  26 #include <stdio.h>
  27 #include <boost/scoped_ptr.hpp>
  28 #include <rtl/character.hxx>
  29
  30 // To activate tracing enable in sbtrace.hxx
  31 #ifdef DBG_TRACE_BASIC
  32
  33 // Trace ini file (set NULL to ignore)
  34 // can be overridden with the environment variable OOO_BASICTRACEINI
  35 static char     GpTraceIniFile[] = "~/BasicTrace.ini";
  36 //static char*  GpTraceIniFile = NULL;
  37
  38 // Trace Settings, used if no ini file / not found in ini file
  39 static char     GpTraceFileNameDefault[] = "~/BasicTrace.txt";
  40 static char*    GpTraceFileName = GpTraceFileNameDefault;
  41
  42 // GbTraceOn:
  43 // true = tracing is active, false = tracing is disabled, default = true
  44 // Set to false initially if you want to activate tracing on demand with
  45 // TraceCommand( "TraceOn" ), see below
  46 static bool GbTraceOn = true;
  47
  48 // GbIncludePCodes:
  49 // true = PCodes are written to trace, default = false, correspondents
  50 // with TraceCommand( "PCodeOn" / "PCodeOff" ), see below
  51 static bool GbIncludePCodes = false;
  52
  53 // GbInitOnlyAtOfficeStart:
  54 // true = Tracing is only intialized onces after Office start when
  55 // Basic runs the first time. Further calls to Basic, e.g. via events
  56 // use the same output file. The trace ini file is not read again.
  57 static bool GbInitOnlyAtOfficeStart = false;
  58
  59 static int  GnIndentPerCallLevel = 4;
  60 static int  GnIndentForPCode = 2;
  61
  62 /*
  63     With trace enabled the runtime function TraceCommand
  64     can be used to influence the trace functionality
  65     from within the running Basic macro.
  66
  67     Format: TraceCommand( command as String [, param as Variant] )
  68
  69     Supported commands (command is NOT case sensitive):
  70     TraceCommand "TraceOn"          sets GbTraceOn = true
  71     TraceCommand "TraceOff"         sets GbTraceOn = false
  72
  73     TraceCommand "PCodeOn"          sets GbIncludePCodes = true
  74     TraceCommand "PCodeOff"         sets GbIncludePCodes = false
  75
  76     TraceCommand "Print", aVal      writes aVal into the trace file as
  77                                     long as it can be converted to string
  78 */
  79
  80 #ifdef DBG_TRACE_PROFILING
  81
  82 #include <algorithm>
  83 #include <stack>
  84 #include <canvas/elapsedtime.hxx>
  85
  86 //*** Profiling ***
  87 // GbTimerOn:
  88 // true = including time stamps
  89 static bool GbTimerOn = true;
  90
  91 // GbTimeStampForEachStep:
  92 // true = prints time stamp after each command / pcode (very slow)
  93 static bool GbTimeStampForEachStep = false;
  94
  95 // GbBlockAllAfterFirstFunctionUsage:
  96 // true = everything (commands, pcodes, functions) is only printed
  97 // for the first usage (improves performance when tracing / pro-
  98 // filing large macros)
  99 static bool GbBlockAllAfterFirstFunctionUsage = false;
 100
 101 // GbBlockStepsAfterFirstFunctionUsage:
 102 // true = commands / pcodes are only printed for the first time
 103 // a function is executed. Afterwards only the entering/leaving
 104 // messages are logged (improves performance when tracing / pro-
 105 // filing large macros)
 106 static bool GbBlockStepsAfterFirstFunctionUsage = false;
 107
 108 #endif
 109
 110
 111 static void lcl_skipWhites( char*& rpc )
 112 {
 113     while( *rpc == ' ' || *rpc == '\t' )
 114         ++rpc;
 115 }
 116
 117 inline void lcl_findNextLine( char*& rpc, char* pe )
 118 {
 119     // Find line end
 120     while( rpc < pe && *rpc != 13 && *rpc != 10 )
 121         ++rpc;
 122
 123     // Read all
 124     while( rpc < pe && (*rpc == 13 || *rpc == 10) )
 125         ++rpc;
 126 }
 127
 128 static void lcl_ReadIniFile( const char* pIniFileName )
 129 {
 130     const int BUF_SIZE = 1000;
 131     static sal_Char TraceFileNameBuffer[BUF_SIZE];
 132     sal_Char Buffer[BUF_SIZE];
 133     sal_Char VarNameBuffer[BUF_SIZE];
 134     sal_Char ValBuffer[BUF_SIZE];
 135
 136     FILE* pFile = fopen( pIniFileName ,"rb" );
 137     if( pFile == NULL )
 138         return;
 139
 140     size_t nRead = fread( Buffer, 1, BUF_SIZE, pFile );
 141
 142     // Scan
 143     char* pc = Buffer;
 144     char* pe = Buffer + nRead;
 145     while( pc < pe )
 146     {
 147         lcl_skipWhites( pc ); if( pc == pe ) break;
 148
 149         // Read variable
 150         char* pVarStart = pc;
 151         while( pc < pe && rtl::isAsciiAlpha( *pc ) )
 152             ++pc;
 153         int nVarLen = pc - pVarStart;
 154         if( nVarLen == 0 )
 155         {
 156             lcl_findNextLine( pc, pe );
 157             continue;
 158         }
 159         strncpy( VarNameBuffer, pVarStart, nVarLen );
 160         VarNameBuffer[nVarLen] = '\0';
 161
 162         // Check =
 163         lcl_skipWhites( pc ); if( pc == pe ) break;
 164         if( *pc != '=' )
 165             continue;
 166         ++pc;
 167         lcl_skipWhites( pc ); if( pc == pe ) break;
 168
 169         // Read value
 170         char* pValStart = pc;
 171         while( pc < pe && *pc != 13 && *pc != 10 )
 172             ++pc;
 173         int nValLen = pc - pValStart;
 174         if( nValLen == 0 )
 175         {
 176             lcl_findNextLine( pc, pe );
 177             continue;
 178         }
 179         strncpy( ValBuffer, pValStart, nValLen );
 180         ValBuffer[nValLen] = '\0';
 181
 182         // Match variables
 183         if( strcmp( VarNameBuffer, "GpTraceFileName") == 0 )
 184         {
 185             strcpy( TraceFileNameBuffer, ValBuffer );
 186             GpTraceFileName = TraceFileNameBuffer;
 187         }
 188         else
 189         if( strcmp( VarNameBuffer, "GbTraceOn") == 0 )
 190             GbTraceOn = (strcmp( ValBuffer, "true" ) == 0);
 191         else
 192         if( strcmp( VarNameBuffer, "GbIncludePCodes") == 0 )
 193             GbIncludePCodes = (strcmp( ValBuffer, "true" ) == 0);
 194         else
 195         if( strcmp( VarNameBuffer, "GbInitOnlyAtOfficeStart") == 0 )
 196             GbInitOnlyAtOfficeStart = (strcmp( ValBuffer, "true" ) == 0);
 197         else
 198         if( strcmp( VarNameBuffer, "GnIndentPerCallLevel") == 0 )
 199             GnIndentPerCallLevel = strtol( ValBuffer, NULL, 10 );
 200         else
 201         if( strcmp( VarNameBuffer, "GnIndentForPCode") == 0 )
 202             GnIndentForPCode = strtol( ValBuffer, NULL, 10 );
 203 #ifdef DBG_TRACE_PROFILING
 204         else
 205         if( strcmp( VarNameBuffer, "GbTimerOn") == 0 )
 206             GbTimerOn = (strcmp( ValBuffer, "true" ) == 0);
 207         else
 208         if( strcmp( VarNameBuffer, "GbTimeStampForEachStep") == 0 )
 209             GbTimeStampForEachStep = (strcmp( ValBuffer, "true" ) == 0);
 210         else
 211         if( strcmp( VarNameBuffer, "GbBlockAllAfterFirstFunctionUsage") == 0 )
 212             GbBlockAllAfterFirstFunctionUsage = (strcmp( ValBuffer, "true" ) == 0);
 213         else
 214         if( strcmp( VarNameBuffer, "GbBlockStepsAfterFirstFunctionUsage") == 0 )
 215             GbBlockStepsAfterFirstFunctionUsage = (strcmp( ValBuffer, "true" ) == 0);
 216 #endif
 217     }
 218     fclose( pFile );
 219 }
 220
 221 struct TraceTextData
 222 {
 223     OString m_aTraceStr_STMNT;
 224     OString m_aTraceStr_PCode;
 225 };
 226 typedef std::hash_map< sal_Int32, TraceTextData > PCToTextDataMap;
 227 typedef std::hash_map< OUString, PCToTextDataMap*, OUStringHash, ::std::equal_to< OUString > > ModuleTraceMap;
 228
 229 ModuleTraceMap      GaModuleTraceMap;
 230 ModuleTraceMap&     rModuleTraceMap = GaModuleTraceMap;
 231
 232 static FILE* GpGlobalFile = NULL;
 233
 234 static void lcl_lineOut( const char* pStr, const char* pPreStr = NULL, const char* pPostStr = NULL )
 235 {
 236     if( GpGlobalFile != NULL )
 237     {
 238         fprintf( GpGlobalFile, "%s%s%s\n", pPreStr ? pPreStr : "", pStr, pPostStr ? pPostStr : "" );
 239         fflush( GpGlobalFile );
 240     }
 241 }
 242
 243 const char* lcl_getSpaces( int nSpaceCount )
 244 {
 245     static const sal_Char Spaces[] = "                                                                                                    "
 246         "                                                                                                    "
 247         "                                                                                                    ";
 248     static const int nAvailableSpaceCount = strlen( Spaces );
 249     static const sal_Char* pSpacesEnd = Spaces + nAvailableSpaceCount;
 250
 251     if( nSpaceCount > nAvailableSpaceCount )
 252         nSpaceCount = nAvailableSpaceCount;
 253
 254     return pSpacesEnd - nSpaceCount;
 255 }
 256
 257 static OString lcl_toOStringSkipLeadingWhites( const OUString& aStr )
 258 {
 259     OString aOStr = OUStringToOString( OUString( aStr ), RTL_TEXTENCODING_ASCII_US );
 260     const sal_Char* pStr = aOStr.getStr();
 261
 262     // Skip whitespace
 263     sal_Char c = *pStr;
 264     while( c == ' ' || c == '\t' )
 265     {
 266         pStr++;
 267         c = *pStr;
 268     }
 269
 270     OString aORetStr( pStr, strlen(pStr) );
 271     return aORetStr;
 272 }
 273
 274 OUString lcl_dumpMethodParameters( SbMethod* pMethod )
 275 {
 276     OUString aStr;
 277     if( pMethod == NULL )
 278     {
 279         return aStr;
 280     }
 281     SbxError eOld = SbxBase::GetError();
 282
 283     SbxArray* pParams = pMethod->GetParameters();
 284     SbxInfo* pInfo = pMethod->GetInfo();
 285     if ( pParams )
 286     {
 287         aStr += '(';
 288         // 0 is sub itself
 289         for ( sal_uInt16 nParam = 1; nParam < pParams->Count(); nParam++ )
 290         {
 291             SbxVariable* pVar = pParams->Get( nParam );
 292             DBG_ASSERT( pVar, "Parameter?!" );
 293             if ( !pVar->GetName().isEmpty() )
 294             {
 295                 aStr += pVar->GetName();
 296             }
 297             else if ( pInfo )
 298             {
 299                 const SbxParamInfo* pParam = pInfo->GetParam( nParam );
 300                 if ( pParam )
 301                 {
 302                     aStr += pParam->aName;
 303                 }
 304             }
 305             aStr += '=';
 306             SbxDataType eType = pVar->GetType();
 307             if( eType & SbxARRAY )
 308             {
 309                 aStr += "...";
 310             }
 311             else if( eType != SbxOBJECT )
 312             {
 313                 aStr += pVar->GetString();
 314             }
 315             if ( nParam < ( pParams->Count() - 1 ) )
 316             {
 317                 aStr += ", ";
 318             }
 319         }
 320         aStr += ')';
 321     }
 322
 323     SbxBase::ResetError();
 324     if( eOld != SbxERR_OK )
 325     {
 326         SbxBase::SetError( eOld );
 327     }
 328     return aStr;
 329 }
 330
 331
 332 // Public functions
 333 static bool GbSavTraceOn = false;
 334
 335 #ifdef DBG_TRACE_PROFILING
 336 static canvas::tools::ElapsedTime* GpTimer = NULL;
 337 static double GdStartTime = 0.0;
 338 static double GdLastTime = 0.0;
 339 static bool GbBlockSteps = false;
 340 static bool GbBlockAll = false;
 341
 342 struct FunctionItem
 343 {
 344     OUString    m_aCompleteFunctionName;
 345     double      m_dTotalTime;
 346     double      m_dNetTime;
 347     int         m_nCallCount;
 348     bool        m_bBlockAll;
 349     bool        m_bBlockSteps;
 350
 351     FunctionItem()
 352         : m_dTotalTime( 0.0 )
 353         , m_dNetTime( 0.0 )
 354         , m_nCallCount( 0 )
 355         , m_bBlockAll( false )
 356         , m_bBlockSteps( false )
 357     {}
 358 };
 359 typedef std::hash_map< OUString, FunctionItem*, OUStringHash, ::std::equal_to< OUString > > FunctionItemMap;
 360
 361 static std::stack< double >             GaCallEnterTimeStack;
 362 static std::stack< FunctionItem* >      GaFunctionItemStack;
 363 static FunctionItemMap                  GaFunctionItemMap;
 364
 365 bool compareFunctionNetTime( FunctionItem* p1, FunctionItem* p2 )
 366 {
 367     return (p1->m_dNetTime > p2->m_dNetTime);
 368 }
 369
 370 void lcl_printTimeOutput()
 371 {
 372     // Overall time output
 373     lcl_lineOut( "" );
 374     lcl_lineOut( "***** Time Output *****" );
 375     char TimeBuffer[500];
 376     double dTotalTime = GpTimer->getElapsedTime() - GdStartTime;
 377     sprintf( TimeBuffer, "Total execution time = %f ms", dTotalTime*1000.0 );
 378     lcl_lineOut( TimeBuffer );
 379     lcl_lineOut( "" );
 380
 381     if( GbTimerOn )
 382     {
 383         lcl_lineOut( "Functions:" );
 384
 385         std::vector<FunctionItem*> avFunctionItems;
 386
 387         FunctionItemMap::iterator it;
 388         for( it = GaFunctionItemMap.begin() ; it != GaFunctionItemMap.end() ; ++it )
 389         {
 390             FunctionItem* pFunctionItem = it->second;
 391             if( pFunctionItem != NULL )
 392             {
 393                 avFunctionItems.push_back( pFunctionItem );
 394             }
 395         }
 396
 397         std::sort( avFunctionItems.begin(), avFunctionItems.end(), compareFunctionNetTime );
 398
 399         std::vector<FunctionItem*>::iterator itv;
 400         for( itv = avFunctionItems.begin() ; itv != avFunctionItems.end() ; ++itv )
 401         {
 402             FunctionItem* pFunctionItem = *itv;
 403             if( pFunctionItem != NULL )
 404             {
 405                 OUString aCompleteFunctionName = pFunctionItem->m_aCompleteFunctionName;
 406                 OString aName = OUStringToOString( aCompleteFunctionName, RTL_TEXTENCODING_ASCII_US );
 407                 int nNameLen = aCompleteFunctionName.getLength();
 408
 409                 double dFctTotalTime = pFunctionItem->m_dTotalTime;
 410                 double dFctNetTime = pFunctionItem->m_dNetTime;
 411                 double dFctTotalTimePercent = 100.0 * dFctTotalTime / dTotalTime;
 412                 double dFctNetTimePercent = 100.0 * dFctNetTime / dTotalTime;
 413                 int nSpaceCount = 30 - nNameLen;
 414                 if( nSpaceCount < 0 )
 415                 {
 416                     nSpaceCount = 2;
 417                 }
 418                 sprintf( TimeBuffer, "%s:%sCalled %d times\t%f ms (%f%%) / net %f (%f%%) ms",
 419                          aName.getStr(), lcl_getSpaces( nSpaceCount ), pFunctionItem->m_nCallCount,
 420                          dFctTotalTime*1000.0, dFctTotalTimePercent, dFctNetTime*1000.0, dFctNetTimePercent );
 421                 lcl_lineOut( TimeBuffer );
 422             }
 423         }
 424     }
 425 }
 426 #endif
 427
 428
 429 static bool GbInitTraceAlreadyCalled = false;
 430
 431 void dbg_InitTrace()
 432 {
 433     if( GbInitOnlyAtOfficeStart && GbInitTraceAlreadyCalled )
 434     {
 435 #ifdef DBG_TRACE_PROFILING
 436         if( GbTimerOn )
 437         {
 438             GpTimer->continueTimer();
 439         }
 440 #endif
 441         GpGlobalFile = fopen( GpTraceFileName, "a+" );
 442         return;
 443     }
 444     GbInitTraceAlreadyCalled = true;
 445
 446     if( const sal_Char* pcIniFileName = ::getenv( "OOO_BASICTRACEINI" ) )
 447     {
 448         lcl_ReadIniFile( pcIniFileName );
 449     }
 450     else if( GpTraceIniFile != NULL )
 451     {
 452         lcl_ReadIniFile( GpTraceIniFile );
 453     }
 454     GpGlobalFile = fopen( GpTraceFileName, "w" );
 455     GbSavTraceOn = GbTraceOn;
 456     if( !GbTraceOn )
 457     {
 458         lcl_lineOut( "### Program started with trace off ###" );
 459     }
 460 #ifdef DBG_TRACE_PROFILING
 461     GpTimer = new canvas::tools::ElapsedTime();
 462     GdStartTime = GpTimer->getElapsedTime();
 463     GdLastTime = GdStartTime;
 464     GbBlockSteps = false;
 465     GbBlockAll = false;
 466 #endif
 467 }
 468
 469 void dbg_DeInitTrace()
 470 {
 471     GbTraceOn = GbSavTraceOn;
 472
 473 #ifdef DBG_TRACE_PROFILING
 474     while( !GaCallEnterTimeStack.empty() )
 475     {
 476         GaCallEnterTimeStack.pop();
 477     }
 478     while( !GaFunctionItemStack.empty() )
 479     {
 480         GaFunctionItemStack.pop();
 481     }
 482     lcl_printTimeOutput();
 483
 484     for( FunctionItemMap::iterator it = GaFunctionItemMap.begin() ; it != GaFunctionItemMap.end() ; ++it )
 485     {
 486         delete it->second;
 487     }
 488     GaFunctionItemMap.clear();
 489
 490     if( GpGlobalFile )
 491     {
 492         fclose( GpGlobalFile );
 493         GpGlobalFile = NULL;
 494     }
 495
 496     if( GbInitOnlyAtOfficeStart )
 497     {
 498         if( GbTimerOn )
 499         {
 500             GpTimer->pauseTimer();
 501         }
 502     }
 503     else
 504     {
 505         delete GpTimer;
 506     }
 507 #endif
 508 }
 509
 510 static sal_Int32 GnLastCallLvl = 0;
 511
 512 void dbg_tracePrint( const OUString& aStr, sal_Int32 nCallLvl, bool bCallLvlRelativeToCurrent )
 513 {
 514     if( bCallLvlRelativeToCurrent )
 515     {
 516         nCallLvl += GnLastCallLvl;
 517     }
 518     int nIndent = nCallLvl * GnIndentPerCallLevel;
 519     lcl_lineOut( OUStringToOString( OUString( aStr ), RTL_TEXTENCODING_ASCII_US ).getStr(), lcl_getSpaces( nIndent ) );
 520 }
 521
 522 void dbg_traceStep( SbModule* pModule, sal_uInt32 nPC, sal_Int32 nCallLvl )
 523 {
 524     if( !GbTraceOn )
 525     {
 526         return;
 527     }
 528 #ifdef DBG_TRACE_PROFILING
 529     if( GbBlockSteps || GbBlockAll )
 530     {
 531         return;
 532     }
 533     double dCurTime = 0.0;
 534     bool bPrintTimeStamp = false;
 535     if( GbTimerOn )
 536     {
 537         GpTimer->pauseTimer();
 538         dCurTime = GpTimer->getElapsedTime();
 539         bPrintTimeStamp = GbTimeStampForEachStep;
 540     }
 541 #else
 542     bool bPrintTimeStamp = false;
 543 #endif
 544
 545     GnLastCallLvl = nCallLvl;
 546
 547     SbModule* pTraceMod = pModule;
 548     if( pTraceMod->ISA(SbClassModuleObject) )
 549     {
 550         SbClassModuleObject* pClassModuleObj = (SbClassModuleObject*)(SbxBase*)pTraceMod;
 551         pTraceMod = pClassModuleObj->getClassModule();
 552     }
 553
 554     OUString aModuleName = pTraceMod->GetName();
 555     ModuleTraceMap::iterator it = rModuleTraceMap.find( aModuleName );
 556     if( it == rModuleTraceMap.end() )
 557     {
 558         OString aModuleNameStr = OUStringToOString( OUString( aModuleName ), RTL_TEXTENCODING_ASCII_US );
 559         char Buffer[200];
 560         sprintf( Buffer, "TRACE ERROR: Unknown module \"%s\"", aModuleNameStr.getStr() );
 561         lcl_lineOut( Buffer );
 562         return;
 563     }
 564
 565     PCToTextDataMap* pInnerMap = it->second;
 566     if( pInnerMap == NULL )
 567     {
 568         lcl_lineOut( "TRACE INTERNAL ERROR: No inner map" );
 569         return;
 570     }
 571
 572     PCToTextDataMap::iterator itInner = pInnerMap->find( nPC );
 573     if( itInner == pInnerMap->end() )
 574     {
 575         OString aModuleNameStr = OUStringToOString( OUString( aModuleName ), RTL_TEXTENCODING_ASCII_US );
 576         char Buffer[200];
 577         sprintf( Buffer, "TRACE ERROR: No info for PC = %d in module \"%s\"", (int)nPC, aModuleNameStr.getStr() );
 578         lcl_lineOut( Buffer );
 579         return;
 580     }
 581
 582     int nIndent = nCallLvl * GnIndentPerCallLevel;
 583
 584     const TraceTextData& rTraceTextData = itInner->second;
 585     const OString& rStr_STMNT = rTraceTextData.m_aTraceStr_STMNT;
 586     bool bSTMT = false;
 587     if( !rStr_STMNT.isEmpty() )
 588     {
 589         bSTMT = true;
 590     }
 591     char TimeBuffer[200];
 592     memset (TimeBuffer, 0, size(TimeBuffer));
 593 #ifdef DBG_TRACE_PROFILING
 594     if( bPrintTimeStamp )
 595     {
 596         double dDiffTime = dCurTime - GdLastTime;
 597         GdLastTime = dCurTime;
 598         sprintf( TimeBuffer, "\t\t// Time = %f ms / += %f ms", dCurTime*1000.0, dDiffTime*1000.0 );
 599     }
 600 #endif
 601
 602     if( bSTMT )
 603     {
 604         lcl_lineOut( rStr_STMNT.getStr(), lcl_getSpaces( nIndent ),
 605                      (bPrintTimeStamp && !GbIncludePCodes) ? TimeBuffer : NULL );
 606     }
 607
 608     if( !GbIncludePCodes )
 609     {
 610 #ifdef DBG_TRACE_PROFILING
 611         if( GbTimerOn )
 612         {
 613             GpTimer->continueTimer();
 614         }
 615 #endif
 616         return;
 617     }
 618
 619     nIndent += GnIndentForPCode;
 620     const OString& rStr_PCode = rTraceTextData.m_aTraceStr_PCode;
 621     if( !rStr_PCode.isEmpty() )
 622     {
 623         lcl_lineOut( rStr_PCode.getStr(), lcl_getSpaces( nIndent ),
 624                      bPrintTimeStamp ? TimeBuffer : NULL );
 625     }
 626
 627 #ifdef DBG_TRACE_PROFILING
 628     if( GbTimerOn )
 629     {
 630         GpTimer->continueTimer();
 631     }
 632 #endif
 633 }
 634
 635
 636 void dbg_traceNotifyCall( SbModule* pModule, SbMethod* pMethod, sal_Int32 nCallLvl, bool bLeave )
 637 {
 638
 639     if( !GbTraceOn )
 640     {
 641         return;
 642     }
 643 #ifdef DBG_TRACE_PROFILING
 644     double dCurTime = 0.0;
 645     double dExecutionTime = 0.0;
 646     if( GbTimerOn )
 647     {
 648         dCurTime = GpTimer->getElapsedTime();
 649         GpTimer->pauseTimer();
 650     }
 651 #endif
 652
 653     GnLastCallLvl = nCallLvl;
 654
 655     SbModule* pTraceMod = pModule;
 656     SbClassModuleObject* pClassModuleObj = NULL;
 657     if( pTraceMod->ISA(SbClassModuleObject) )
 658     {
 659         pClassModuleObj = (SbClassModuleObject*)(SbxBase*)pTraceMod;
 660         pTraceMod = pClassModuleObj->getClassModule();
 661     }
 662
 663     OUString aCompleteFunctionName = pTraceMod->GetName();
 664     if( pMethod != NULL )
 665     {
 666         aCompleteFunctionName +=  "::";
 667         OUString aMethodName = pMethod->GetName();
 668         aCompleteFunctionName += aMethodName;
 669     }
 670     else
 671     {
 672         aCompleteFunctionName += "/RunInit";
 673     }
 674
 675     bool bOwnBlockSteps = false;
 676 #ifdef DBG_TRACE_PROFILING
 677     bool bOwnBlockAll = false;
 678     FunctionItem* pFunctionItem = NULL;
 679     if( GbTimerOn )
 680     {
 681         FunctionItemMap::iterator itFunctionItem = GaFunctionItemMap.find( aCompleteFunctionName );
 682         if( itFunctionItem != GaFunctionItemMap.end() )
 683         {
 684             pFunctionItem = itFunctionItem->second;
 685         }
 686         if( pFunctionItem == NULL )
 687         {
 688             DBG_ASSERT( !bLeave, "No FunctionItem in leave!" );
 689
 690             pFunctionItem = new FunctionItem();
 691             pFunctionItem->m_aCompleteFunctionName = aCompleteFunctionName;
 692             GaFunctionItemMap[ aCompleteFunctionName ] = pFunctionItem;
 693         }
 694         else if( GbBlockAllAfterFirstFunctionUsage && !bLeave )
 695         {
 696             pFunctionItem->m_bBlockAll = true;
 697         }
 698         else if( GbBlockStepsAfterFirstFunctionUsage && !bLeave )
 699         {
 700             pFunctionItem->m_bBlockSteps = true;
 701         }
 702
 703         if( bLeave )
 704         {
 705             bOwnBlockAll = GbBlockAll;
 706             bOwnBlockSteps = GbBlockSteps;
 707             GbBlockAll = false;
 708             GbBlockSteps = false;
 709
 710             dExecutionTime = dCurTime - GaCallEnterTimeStack.top();
 711             GaCallEnterTimeStack.pop();
 712
 713             pFunctionItem->m_dTotalTime += dExecutionTime;
 714             pFunctionItem->m_dNetTime += dExecutionTime;
 715             pFunctionItem->m_nCallCount++;
 716
 717             GaFunctionItemStack.pop();
 718             if( !GaFunctionItemStack.empty() )
 719             {
 720                 FunctionItem* pParentItem = GaFunctionItemStack.top();
 721                 if( pParentItem != NULL )
 722                 {
 723                     pParentItem->m_dNetTime -= dExecutionTime;
 724
 725                     GbBlockSteps = pParentItem->m_bBlockSteps;
 726                     GbBlockAll = pParentItem->m_bBlockAll;
 727                 }
 728             }
 729         }
 730         else
 731         {
 732             GbBlockSteps = bOwnBlockSteps = pFunctionItem->m_bBlockSteps;
 733             GbBlockAll = bOwnBlockAll = pFunctionItem->m_bBlockAll;
 734
 735             GaCallEnterTimeStack.push( dCurTime );
 736             GaFunctionItemStack.push( pFunctionItem );
 737         }
 738     }
 739
 740     if( bOwnBlockAll )
 741     {
 742         if( GbTimerOn )
 743         {
 744             GpTimer->continueTimer();
 745         }
 746         return;
 747     }
 748 #endif
 749
 750     if( nCallLvl > 0 )
 751     {
 752         nCallLvl--;
 753     }
 754     int nIndent = nCallLvl * GnIndentPerCallLevel;
 755     if( !bLeave && !bOwnBlockSteps )
 756     {
 757         static const char* pSeparator = "' ================================================================================";
 758         lcl_lineOut( "" );
 759         lcl_lineOut( pSeparator, lcl_getSpaces( nIndent ) );
 760     }
 761
 762     OUString aStr;
 763     if( bLeave )
 764     {
 765         if( !bOwnBlockSteps )
 766         {
 767             lcl_lineOut( "}", lcl_getSpaces( nIndent ) );
 768             aStr = "' Leaving ";
 769         }
 770     }
 771     else
 772     {
 773         aStr = "Entering " ;
 774     }
 775     if( !bLeave || !bOwnBlockSteps )
 776     {
 777         aStr += aCompleteFunctionName;
 778     }
 779     if( !bOwnBlockSteps && pClassModuleObj != NULL )
 780     {
 781         aStr += "[this=";
 782         aStr += pClassModuleObj->GetName();
 783         aStr += "]" ;
 784     }
 785     if( !bLeave )
 786     {
 787         aStr += lcl_dumpMethodParameters( pMethod );
 788     }
 789     const char* pPostStr = NULL;
 790 #ifdef DBG_TRACE_PROFILING
 791     char TimeBuffer[200];
 792     if( GbTimerOn && bLeave )
 793     {
 794         sprintf( TimeBuffer, "    // Execution Time = %f ms", dExecutionTime*1000.0 );
 795         pPostStr = TimeBuffer;
 796     }
 797 #endif
 798     lcl_lineOut( (!bLeave || !bOwnBlockSteps) ? OUStringToOString( OUString( aStr ), RTL_TEXTENCODING_ASCII_US ).getStr() : "}",
 799                  lcl_getSpaces( nIndent ), pPostStr );
 800     if( !bLeave )
 801     {
 802         lcl_lineOut( "{", lcl_getSpaces( nIndent ) );
 803     }
 804     if( bLeave && !bOwnBlockSteps )
 805     {
 806         lcl_lineOut( "" );
 807     }
 808 #ifdef DBG_TRACE_PROFILING
 809     if( GbTimerOn )
 810     {
 811         GpTimer->continueTimer();
 812     }
 813 #endif
 814 }
 815
 816 void dbg_traceNotifyError( SbError nTraceErr, const OUString& aTraceErrMsg,
 817                            bool bTraceErrHandled, sal_Int32 nCallLvl )
 818 {
 819     if( !GbTraceOn )
 820     {
 821         return;
 822     }
 823 #ifdef DBG_TRACE_PROFILING
 824     if( GbBlockSteps || GbBlockAll )
 825     {
 826         return;
 827     }
 828 #endif
 829     GnLastCallLvl = nCallLvl;
 830
 831     OString aOTraceErrMsg = OUStringToOString( OUString( aTraceErrMsg ), RTL_TEXTENCODING_ASCII_US );
 832
 833     char Buffer[200];
 834     const char* pHandledStr = bTraceErrHandled ? " / HANDLED" : "";
 835     sprintf( Buffer, "*** ERROR%s, Id = %d, Msg = \"%s\" ***", pHandledStr, (int)nTraceErr, aOTraceErrMsg.getStr() );
 836     int nIndent = nCallLvl * GnIndentPerCallLevel;
 837     lcl_lineOut( Buffer, lcl_getSpaces( nIndent ) );
 838 }
 839
 840 void dbg_RegisterTraceTextForPC( SbModule* pModule, sal_uInt32 nPC,
 841                                  const OUString& aTraceStr_STMNT, const OUString& aTraceStr_PCode )
 842 {
 843     OUString aModuleName = pModule->GetName();
 844     ModuleTraceMap::iterator it = rModuleTraceMap.find( aModuleName );
 845     PCToTextDataMap* pInnerMap;
 846     if( it == rModuleTraceMap.end() )
 847     {
 848         pInnerMap = new PCToTextDataMap();
 849         rModuleTraceMap[ aModuleName ] = pInnerMap;
 850     }
 851     else
 852     {
 853         pInnerMap = it->second;
 854     }
 855
 856     TraceTextData aData;
 857
 858     OString aOTraceStr_STMNT = lcl_toOStringSkipLeadingWhites( aTraceStr_STMNT );
 859     aData.m_aTraceStr_STMNT = aOTraceStr_STMNT;
 860
 861     OString aOTraceStr_PCode = lcl_toOStringSkipLeadingWhites( aTraceStr_PCode );
 862     aData.m_aTraceStr_PCode = aOTraceStr_PCode;
 863
 864     (*pInnerMap)[nPC] = aData;
 865 }
 866
 867 void RTL_Impl_TraceCommand( StarBASIC* pBasic, SbxArray& rPar, sal_Bool bWrite )
 868 {
 869     (void)pBasic;
 870     (void)bWrite;
 871
 872     if ( rPar.Count() < 2 )
 873     {
 874         StarBASIC::Error( SbERR_BAD_ARGUMENT );
 875         return;
 876     }
 877
 878     OUString aCommand = rPar.Get(1)->GetString();
 879
 880     if( aCommand.equalsIngoreAsciiCase( "TraceOn" ) )
 881     {
 882         GbTraceOn = true;
 883     }
 884     else if( aCommand.equalsIngoreAsciiCase( "TraceOff" ) )
 885     {
 886         GbTraceOn = false;
 887     }
 888     else if( aCommand.equalsIngoreAsciiCase( "PCodeOn" ) )
 889     {
 890         GbIncludePCodes = true;
 891     }
 892     else if( aCommand.equalsIngoreAsciiCase( "PCodeOff" ) )
 893     {
 894         GbIncludePCodes = false;
 895     }
 896     else if( aCommand.equalsIngoreAsciiCase( "Print" ) )
 897     {
 898         if ( rPar.Count() < 3 )
 899         {
 900             StarBASIC::Error( SbERR_BAD_ARGUMENT );
 901             return;
 902         }
 903
 904         SbxError eOld = SbxBase::GetError();
 905         if( eOld != SbxERR_OK )
 906             SbxBase::ResetError();
 907
 908         OUString aValStr = rPar.Get(2)->GetString();
 909         SbxError eErr = SbxBase::GetError();
 910         if( eErr != SbxERR_OK )
 911         {
 912             aValStr = "<ERROR converting value to String>";
 913             SbxBase::ResetError();
 914         }
 915
 916         char Buffer[500];
 917
 918         sprintf( Buffer, "### TRACE_PRINT: %s ###", OUStringToOString( OUString( aValStr ), RTL_TEXTENCODING_ASCII_US ).getStr() );
 919         int nIndent = GnLastCallLvl * GnIndentPerCallLevel;
 920         lcl_lineOut( Buffer, lcl_getSpaces( nIndent ) );
 921
 922         if( eOld != SbxERR_OK )
 923         {
 924             SbxBase::SetError( eOld );
 925         }
 926     }
 927 }
 928
 929 #endif
 930
 931 // This routine is defined here, so that the
 932 // compiler can be loaded as a discrete segment.
 933
 934 bool SbModule::Compile()
 935 {
 936     if( pImage )
 937         return true;
 938     StarBASIC* pBasic = PTR_CAST(StarBASIC,GetParent());
 939     if( !pBasic )
 940         return false;
 941     SbxBase::ResetError();
 942
 943     SbModule* pOld = GetSbData()->pCompMod;
 944     GetSbData()->pCompMod = this;
 945
 946     boost::scoped_ptr<SbiParser> pParser(new SbiParser( static_cast<StarBASIC*>(GetParent()), this ));
 947     while( pParser->Parse() ) {}
 948     if( !pParser->GetErrors() )
 949         pParser->aGen.Save();
 950     pParser.reset();
 951     // for the disassembler
 952     if( pImage )
 953         pImage->aOUSource = aOUSource;
 954
 955     GetSbData()->pCompMod = pOld;
 956
 957     // compiling a module, the module-global
 958     // variables of all modules become invalid
 959     bool bRet = IsCompiled();
 960     if( bRet )
 961     {
 962         if( !this->ISA(SbObjModule) )
 963             pBasic->ClearAllModuleVars();
 964         RemoveVars(); // remove 'this' Modules variables
 965         // clear all method statics
 966         for( sal_uInt16 i = 0; i < pMethods->Count(); i++ )
 967         {
 968             SbMethod* p = PTR_CAST(SbMethod,pMethods->Get( i ) );
 969             if( p )
 970                 p->ClearStatics();
 971         }
 972
 973         // #i31510 Init other libs only if Basic isn't running
 974         if( GetSbData()->pInst == NULL )
 975         {
 976             SbxObject* pParent_ = pBasic->GetParent();
 977             if( pParent_ )
 978                 pBasic = PTR_CAST(StarBASIC,pParent_);
 979             if( pBasic )
 980                 pBasic->ClearAllModuleVars();
 981         }
 982     }
 983
 984     return bRet;
 985 }
 986 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */