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