int main() { LogSetLevel(NULL, Info); LogTrace("This should compile away"); LogDebug("This should not show"); LogInfo("This should show on stderr"); LogSetOutputFile(NULL, stdout); LogTrace("This should compile away"); LogDebug("This should not show"); LogInfo("This should show on stdout"); LogSetLevel(NULL, Warn); LogInfo("Generate a compile time warning: %s", 5); LogInit(); return 0; }
void Init() { LogInit(); LogSetLevel(LOG_DEBUG); SDL_Init(SDL_INIT_EVERYTHING); /* Initialize SDL */ window = SDL_CreateWindow("SDL_Shownn", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, WINDOW_WIDTH, WINDOW_HEIGHT, 0); renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED|SDL_RENDERER_PRESENTVSYNC); NetInit(WINDOW_WIDTH, WINDOW_HEIGHT); RenderInit(renderer, WINDOW_WIDTH, WINDOW_HEIGHT); LogDebug("Init complete"); }
/** * MAIN function * Generates samples of B-stat and F-stat according to their pdfs for given signal-params. */ int main(int argc,char *argv[]) { UserInput_t XLAL_INIT_DECL(uvar); ConfigVariables XLAL_INIT_DECL(cfg); /**< various derived configuration settings */ vrbflg = 1; /* verbose error-messages */ LogSetLevel(lalDebugLevel); /* turn off default GSL error handler */ gsl_set_error_handler_off (); /* ----- register and read all user-variables ----- */ LogSetLevel(lalDebugLevel); if ( XLALInitUserVars( &uvar ) != XLAL_SUCCESS ) { LogPrintf ( LOG_CRITICAL, "%s: XLALInitUserVars() failed with errno=%d\n", __func__, xlalErrno ); return 1; } /* do ALL cmdline and cfgfile handling */ if ( XLALUserVarReadAllInput ( argc, argv ) != XLAL_SUCCESS ) { LogPrintf ( LOG_CRITICAL, "%s: XLALUserVarReadAllInput() failed with errno=%d\n", __func__, xlalErrno ); return 1; } if (uvar.help) /* if help was requested, we're done here */ return 0; if ( uvar.version ) { /* output verbose VCS version string if requested */ CHAR *vcs; if ( (vcs = XLALGetVersionString (lalDebugLevel)) == NULL ) { LogPrintf ( LOG_CRITICAL, "%s:XLALGetVersionString(%d) failed with errno=%d.\n", __func__, lalDebugLevel, xlalErrno ); return 1; } printf ( "%s\n", vcs ); XLALFree ( vcs ); return 0; } /* ---------- Initialize code-setup ---------- */ if ( XLALInitCode( &cfg, &uvar ) != XLAL_SUCCESS ) { LogPrintf (LOG_CRITICAL, "%s: XLALInitCode() failed with error = %d\n", __func__, xlalErrno ); XLAL_ERROR ( XLAL_EFUNC ); } /* ----- prepare stats output ----- */ FILE *fpTransientStats = NULL; if ( uvar.outputStats ) { if ( (fpTransientStats = fopen (uvar.outputStats, "wb")) == NULL) { LogPrintf (LOG_CRITICAL, "Error opening file '%s' for writing..\n\n", uvar.outputStats ); XLAL_ERROR ( XLAL_EIO ); } fprintf (fpTransientStats, "%s", cfg.logString ); /* write search log comment */ if ( write_transientCandidate_to_fp ( fpTransientStats, NULL ) != XLAL_SUCCESS ) { /* write header-line comment */ XLAL_ERROR ( XLAL_EFUNC ); } } /* if outputStats */ /* ----- prepare injection params output ----- */ FILE *fpInjParams = NULL; if ( uvar.outputInjParams ) { if ( (fpInjParams = fopen (uvar.outputInjParams, "wb")) == NULL) { LogPrintf (LOG_CRITICAL, "Error opening file '%s' for writing..\n\n", uvar.outputInjParams ); XLAL_ERROR ( XLAL_EIO ); } fprintf (fpInjParams, "%s", cfg.logString ); /* write search log comment */ if ( write_InjParams_to_fp ( fpInjParams, NULL, 0, 0, 0 ) != XLAL_SUCCESS ) { /* write header-line comment - options outputMmunuX and numDetectors not supported here, so pass defaults to deactivate them */ XLAL_ERROR ( XLAL_EFUNC ); } } /* if outputInjParams */ /* ----- main MC loop over numDraws trials ---------- */ multiAMBuffer_t XLAL_INIT_DECL(multiAMBuffer); /* prepare AM-buffer */ INT4 i; for ( i=0; i < uvar.numDraws; i ++ ) { InjParams_t XLAL_INIT_DECL(injParamsDrawn); /* ----- generate signal random draws from ranges and generate Fstat atoms */ MultiFstatAtomVector *multiAtoms; multiAtoms = XLALSynthesizeTransientAtoms ( &injParamsDrawn, cfg.skypos, cfg.AmpPrior, cfg.transientInjectRange, cfg.multiDetStates, cfg.SignalOnly, &multiAMBuffer, cfg.rng, -1, NULL ); // options lineX and noise_weights not supported here, so pass defaults to deactivate them if ( multiAtoms ==NULL ) { LogPrintf ( LOG_CRITICAL, "%s: XLALSynthesizeTransientAtoms() failed with xlalErrno = %d\n", __func__, xlalErrno ); XLAL_ERROR ( XLAL_EFUNC ); } /* ----- if requested, output signal injection parameters into file */ if ( fpInjParams && (write_InjParams_to_fp ( fpInjParams, &injParamsDrawn, uvar.dataStartGPS, 0, 0 ) ) != XLAL_SUCCESS ) { // options outputMmunuX and numDetectors not supported here, so pass defaults to deactivate them XLAL_ERROR ( XLAL_EFUNC ); } /* if fpInjParams & failure*/ /* ----- add meta-info on current transient-CW candidate */ transientCandidate_t XLAL_INIT_DECL(cand); cand.doppler.Alpha = multiAMBuffer.skypos.longitude; cand.doppler.Delta = multiAMBuffer.skypos.latitude; cand.windowRange = cfg.transientSearchRange; /* ----- if needed: compute transient-Bstat search statistic on these atoms */ if ( fpTransientStats || uvar.outputFstatMap || uvar.outputPosteriors ) { /* compute Fstat map F_mn over {t0, tau} */ if ( (cand.FstatMap = XLALComputeTransientFstatMap ( multiAtoms, cand.windowRange, uvar.useFReg)) == NULL ) { XLALPrintError ("%s: XLALComputeTransientFstatMap() failed with xlalErrno = %d.\n", __func__, xlalErrno ); XLAL_ERROR ( XLAL_EFUNC ); } } /* if we'll need the Fstat-map F_mn */ /* ----- if requested compute marginalized Bayes factor */ if ( fpTransientStats ) { cand.logBstat = XLALComputeTransientBstat ( cand.windowRange, cand.FstatMap ); UINT4 err = xlalErrno; if ( err ) { XLALPrintError ("%s: XLALComputeTransientBstat() failed with xlalErrno = %d\n", __func__, err ); XLAL_ERROR ( XLAL_EFUNC ); } if ( uvar.SignalOnly ) { cand.FstatMap->maxF += 2; cand.logBstat += 2; } } /* if Bstat requested */ /* ----- if requested, compute parameter posteriors for {t0, tau} */ pdf1D_t *pdf_t0 = NULL; pdf1D_t *pdf_tau = NULL; if ( fpTransientStats || uvar.outputPosteriors ) { if ( (pdf_t0 = XLALComputeTransientPosterior_t0 ( cand.windowRange, cand.FstatMap )) == NULL ) { XLALPrintError ("%s: failed to compute t0-posterior\n", __func__ ); XLAL_ERROR ( XLAL_EFUNC ); } if ( (pdf_tau = XLALComputeTransientPosterior_tau ( cand.windowRange, cand.FstatMap )) == NULL ) { XLALPrintError ("%s: failed to compute tau-posterior\n", __func__ ); XLAL_ERROR ( XLAL_EFUNC ); } /* get maximum-posterior estimate (MP) from the modes of these pdfs */ cand.t0_MP = XLALFindModeOfPDF1D ( pdf_t0 ); if ( xlalErrno ) { XLALPrintError ("%s: mode-estimation failed for pdf_t0. xlalErrno = %d\n", __func__, xlalErrno ); XLAL_ERROR ( XLAL_EFUNC ); } cand.tau_MP = XLALFindModeOfPDF1D ( pdf_tau ); if ( xlalErrno ) { XLALPrintError ("%s: mode-estimation failed for pdf_tau. xlalErrno = %d\n", __func__, xlalErrno ); XLAL_ERROR ( XLAL_EFUNC ); } } // if posteriors required /* ----- if requested, compute Ftotal over full data-span */ if ( uvar.computeFtotal ) { transientFstatMap_t *FtotalMap; /* prepare special window to cover all the data with one F-stat calculation == Ftotal */ transientWindowRange_t XLAL_INIT_DECL(winRangeAll); winRangeAll.type = TRANSIENT_NONE; BOOLEAN useFReg = false; if ( (FtotalMap = XLALComputeTransientFstatMap ( multiAtoms, winRangeAll, useFReg)) == NULL ) { XLALPrintError ("%s: XLALComputeTransientFstatMap() failed with xlalErrno = %d.\n", __func__, xlalErrno ); XLAL_ERROR ( XLAL_EFUNC ); } /* we only use twoFtotal = 2 * maxF from this single-Fstat calculation */ REAL8 twoFtotal = 2.0 * FtotalMap->maxF; if ( uvar.SignalOnly ) twoFtotal += 4; /* ugly hack: lacking a good container for twoFtotal, we borrow fkdot[3] for this here ;) [only used for paper-MCs] */ cand.doppler.fkdot[3] = twoFtotal; /* good riddance .. */ XLALDestroyTransientFstatMap ( FtotalMap ); } /* if computeFtotal */ /* ----- if requested, output atoms-vector into file */ if ( uvar.outputAtoms ) { FILE *fpAtoms; char *fnameAtoms; UINT4 len = strlen ( uvar.outputAtoms ) + 20; if ( (fnameAtoms = XLALCalloc ( 1, len )) == NULL ) { XLALPrintError ("%s: failed to XLALCalloc ( 1, %d )\n", __func__, len ); XLAL_ERROR ( XLAL_EFUNC ); } sprintf ( fnameAtoms, "%s_%04d_of_%04d.dat", uvar.outputAtoms, i + 1, uvar.numDraws ); if ( ( fpAtoms = fopen ( fnameAtoms, "wb" )) == NULL ) { XLALPrintError ("%s: failed to open atoms-output file '%s' for writing.\n", __func__, fnameAtoms ); XLAL_ERROR ( XLAL_EFUNC ); } fprintf ( fpAtoms, "%s", cfg.logString ); /* output header info */ if ( write_MultiFstatAtoms_to_fp ( fpAtoms, multiAtoms ) != XLAL_SUCCESS ) { XLALPrintError ("%s: failed to write atoms to output file '%s'. xlalErrno = %d\n", __func__, fnameAtoms, xlalErrno ); XLAL_ERROR ( XLAL_EFUNC ); } XLALFree ( fnameAtoms ); fclose (fpAtoms); } /* if outputAtoms */ /* ----- if requested, output Fstat-map over {t0, tau} */ if ( uvar.outputFstatMap ) { FILE *fpFstatMap; char *fnameFstatMap; UINT4 len = strlen ( uvar.outputFstatMap ) + 20; if ( (fnameFstatMap = XLALCalloc ( 1, len )) == NULL ) { XLALPrintError ("%s: failed to XLALCalloc ( 1, %d )\n", __func__, len ); XLAL_ERROR ( XLAL_EFUNC ); } sprintf ( fnameFstatMap, "%s_%04d_of_%04d.dat", uvar.outputFstatMap, i + 1, uvar.numDraws ); if ( ( fpFstatMap = fopen ( fnameFstatMap, "wb" )) == NULL ) { XLALPrintError ("%s: failed to open Fstat-map output file '%s' for writing.\n", __func__, fnameFstatMap ); XLAL_ERROR ( XLAL_EFUNC ); } fprintf ( fpFstatMap, "%s", cfg.logString ); /* output header info */ fprintf (fpFstatMap, "\nFstat_mn = \\\n" ); if ( XLALfprintfGSLmatrix ( fpFstatMap, "%.9g", cand.FstatMap->F_mn ) != XLAL_SUCCESS ) { XLALPrintError ("%s: XLALfprintfGSLmatrix() failed.\n", __func__ ); XLAL_ERROR ( XLAL_EFUNC ); } XLALFree ( fnameFstatMap ); fclose (fpFstatMap); } /* if outputFstatMap */ /* ----- if requested, output posterior pdfs on transient params {t0, tau} into a file */ if ( uvar.outputPosteriors ) { FILE *fpPosteriors; char *fnamePosteriors; UINT4 len = strlen ( uvar.outputPosteriors ) + 20; if ( (fnamePosteriors = XLALCalloc ( 1, len )) == NULL ) { XLALPrintError ("%s: failed to XLALCalloc ( 1, %d )\n", __func__, len ); XLAL_ERROR ( XLAL_EFUNC ); } sprintf ( fnamePosteriors, "%s_%04d_of_%04d.dat", uvar.outputPosteriors, i + 1, uvar.numDraws ); if ( ( fpPosteriors = fopen ( fnamePosteriors, "wb" )) == NULL ) { XLALPrintError ("%s: failed to open posteriors-output file '%s' for writing.\n", __func__, fnamePosteriors ); XLAL_ERROR ( XLAL_EFUNC ); } fprintf ( fpPosteriors, "%s", cfg.logString ); /* output header info */ /* write them to file, using pdf-method */ if ( XLALOutputPDF1D_to_fp ( fpPosteriors, pdf_t0, "pdf_t0" ) != XLAL_SUCCESS ) { XLALPrintError ("%s: failed to output t0-posterior to file '%s'.\n", __func__, fnamePosteriors ); XLAL_ERROR ( XLAL_EFUNC ); } if ( XLALOutputPDF1D_to_fp ( fpPosteriors, pdf_tau, "pdf_tau" ) != XLAL_SUCCESS ) { XLALPrintError ("%s: failed to output tau-posterior to file '%s'.\n", __func__, fnamePosteriors ); XLAL_ERROR ( XLAL_EFUNC ); } /* free mem, close file */ XLALFree ( fnamePosteriors ); fclose (fpPosteriors); } /* if outputPosteriors */ /* ----- if requested, output transient-cand statistics */ if ( fpTransientStats && write_transientCandidate_to_fp ( fpTransientStats, &cand ) != XLAL_SUCCESS ) { XLALPrintError ( "%s: write_transientCandidate_to_fp() failed.\n", __func__ ); XLAL_ERROR ( XLAL_EFUNC ); } /* ----- free Memory */ XLALDestroyTransientFstatMap ( cand.FstatMap ); XLALDestroyMultiFstatAtomVector ( multiAtoms ); XLALDestroyPDF1D ( pdf_t0 ); XLALDestroyPDF1D ( pdf_tau ); } /* for i < numDraws */ /* ----- close files ----- */ if ( fpTransientStats) fclose ( fpTransientStats ); if ( fpInjParams ) fclose ( fpInjParams ); /* ----- free memory ---------- */ XLALDestroyMultiDetectorStateSeries ( cfg.multiDetStates ); XLALDestroyMultiAMCoeffs ( multiAMBuffer.multiAM ); XLALDestroyExpLUT(); /* ----- free amplitude prior pdfs ----- */ XLALDestroyPDF1D ( cfg.AmpPrior.pdf_h0Nat ); XLALDestroyPDF1D ( cfg.AmpPrior.pdf_cosi ); XLALDestroyPDF1D ( cfg.AmpPrior.pdf_psi ); XLALDestroyPDF1D ( cfg.AmpPrior.pdf_phi0 ); if ( cfg.logString ) XLALFree ( cfg.logString ); gsl_rng_free ( cfg.rng ); XLALDestroyUserVars(); /* did we forget anything ? (doesn't cover gsl-memory!) */ LALCheckMemoryLeaks(); return 0; } /* main() */
extern "C" HRESULT EngineRun( __in HINSTANCE hInstance, __in_z_opt LPCWSTR wzCommandLine, __in int nCmdShow, __out DWORD* pdwExitCode ) { HRESULT hr = S_OK; BOOL fComInitialized = FALSE; BOOL fLogInitialized = FALSE; BOOL fRegInitialized = FALSE; BOOL fWiuInitialized = FALSE; BOOL fXmlInitialized = FALSE; OSVERSIONINFOEXW ovix = { }; LPWSTR sczExePath = NULL; BOOL fRunNormal = FALSE; BOOL fRestart = FALSE; BURN_ENGINE_STATE engineState = { }; hr = InitializeEngineState(&engineState); ExitOnFailure(hr, "Failed to initialize engine state."); engineState.command.nCmdShow = nCmdShow; // Ensure that log contains approriate level of information #ifdef _DEBUG LogSetLevel(REPORT_DEBUG, FALSE); #else LogSetLevel(REPORT_VERBOSE, FALSE); // FALSE means don't write an additional text line to the log saying the level changed #endif // initialize platform layer PlatformInitialize(); // initialize COM hr = ::CoInitializeEx(NULL, COINIT_MULTITHREADED); ExitOnFailure(hr, "Failed to initialize COM."); fComInitialized = TRUE; // Initialize dutil. LogInitialize(::GetModuleHandleW(NULL)); fLogInitialized = TRUE; hr = RegInitialize(); ExitOnFailure(hr, "Failed to initialize Regutil."); fRegInitialized = TRUE; hr = WiuInitialize(); ExitOnFailure(hr, "Failed to initialize Wiutil."); fWiuInitialized = TRUE; hr = XmlInitialize(); ExitOnFailure(hr, "Failed to initialize XML util."); fXmlInitialized = TRUE; ovix.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXW); if (!::GetVersionExW((LPOSVERSIONINFOW)&ovix)) { ExitWithLastError(hr, "Failed to get OS info."); } PathForCurrentProcess(&sczExePath, NULL); // Ignore failure. LogId(REPORT_STANDARD, MSG_BURN_INFO, szVerMajorMinorBuild, ovix.dwMajorVersion, ovix.dwMinorVersion, ovix.dwBuildNumber, ovix.wServicePackMajor, sczExePath, wzCommandLine ? wzCommandLine : L""); ReleaseNullStr(sczExePath); // initialize core hr = CoreInitialize(wzCommandLine, &engineState); ExitOnFailure(hr, "Failed to initialize core."); // select run mode switch (engineState.mode) { case BURN_MODE_NORMAL: fRunNormal = TRUE; hr = RunNormal(hInstance, &engineState); ExitOnFailure(hr, "Failed to run per-user mode."); break; case BURN_MODE_ELEVATED: hr = RunElevated(hInstance, wzCommandLine, &engineState); ExitOnFailure(hr, "Failed to run per-machine mode."); break; case BURN_MODE_EMBEDDED: fRunNormal = TRUE; hr = RunEmbedded(hInstance, &engineState); ExitOnFailure(hr, "Failed to run embedded mode."); break; case BURN_MODE_RUNONCE: hr = RunRunOnce(wzCommandLine, nCmdShow); ExitOnFailure(hr, "Failed to run RunOnce mode."); break; default: hr = E_UNEXPECTED; ExitOnFailure(hr, "Invalid run mode."); } // set exit code and remember if we are supposed to restart. *pdwExitCode = engineState.userExperience.dwExitCode; fRestart = engineState.fRestart; LExit: ReleaseStr(sczExePath); // If anything went wrong but the log was never open, try to open a "failure" log // and that will dump anything captured in the log memory buffer to the log. if (FAILED(hr) && BURN_LOGGING_STATE_CLOSED == engineState.log.state) { LogOpen(NULL, L"Setup", L"_Failed", L"txt", FALSE, FALSE, NULL); } UserExperienceRemove(&engineState.userExperience); CacheRemoveWorkingFolder(engineState.registration.sczId); // If this is a related bundle (but not an update) suppress restart and return the standard restart error code. if (fRestart && BOOTSTRAPPER_RELATION_NONE != engineState.command.relationType && BOOTSTRAPPER_RELATION_UPDATE != engineState.command.relationType) { LogId(REPORT_STANDARD, MSG_RESTART_ABORTED, LoggingRelationTypeToString(engineState.command.relationType)); fRestart = FALSE; hr = HRESULT_FROM_WIN32(ERROR_SUCCESS_REBOOT_REQUIRED); } UninitializeEngineState(&engineState); if (fXmlInitialized) { XmlUninitialize(); } if (fWiuInitialized) { WiuUninitialize(); } if (fRegInitialized) { RegUninitialize(); } if (fComInitialized) { ::CoUninitialize(); } if (fRunNormal) { LogId(REPORT_STANDARD, MSG_EXITING, FAILED(hr) ? (int)hr : *pdwExitCode, LoggingBoolToString(fRestart)); if (fRestart) { LogId(REPORT_STANDARD, MSG_RESTARTING); } } if (fLogInitialized) { LogClose(FALSE); } if (fRestart) { Restart(); } if (fLogInitialized) { LogUninitialize(FALSE); } return hr; }
extern "C" HRESULT LoggingOpen( __in BURN_LOGGING* pLog, __in BURN_VARIABLES* pVariables, __in BOOTSTRAPPER_DISPLAY display, __in_z LPCWSTR wzBundleName ) { HRESULT hr = S_OK; LPWSTR sczLoggingBaseFolder = NULL; // Check if the logging policy is set and configure the logging appropriately. CheckLoggingPolicy(&pLog->dwAttributes); if (pLog->dwAttributes & BURN_LOGGING_ATTRIBUTE_VERBOSE || pLog->dwAttributes & BURN_LOGGING_ATTRIBUTE_EXTRADEBUG) { if (pLog->dwAttributes & BURN_LOGGING_ATTRIBUTE_EXTRADEBUG) { LogSetLevel(REPORT_DEBUG, FALSE); } else if (pLog->dwAttributes & BURN_LOGGING_ATTRIBUTE_VERBOSE) { LogSetLevel(REPORT_VERBOSE, FALSE); } if ((!pLog->sczPath || !*pLog->sczPath) && (!pLog->sczPrefix || !*pLog->sczPrefix)) { PathCreateTimeBasedTempFile(NULL, L"Setup", NULL, L"log", &pLog->sczPath, NULL); } } // Open the log approriately. if (pLog->sczPath && *pLog->sczPath) { DWORD cRetry = 0; hr = DirGetCurrent(&sczLoggingBaseFolder); ExitOnFailure(hr, "Failed to get current directory."); // Try pretty hard to open the log file when appending. do { if (0 < cRetry) { ::Sleep(LOG_OPEN_RETRY_WAIT); } hr = LogOpen(sczLoggingBaseFolder, pLog->sczPath, NULL, NULL, pLog->dwAttributes & BURN_LOGGING_ATTRIBUTE_APPEND, FALSE, &pLog->sczPath); if (pLog->dwAttributes & BURN_LOGGING_ATTRIBUTE_APPEND && HRESULT_FROM_WIN32(ERROR_SHARING_VIOLATION) == hr) { ++cRetry; } } while (cRetry > 0 && cRetry <= LOG_OPEN_RETRY_COUNT); if (FAILED(hr)) { // Log is not open, so note that. LogDisable(); pLog->state = BURN_LOGGING_STATE_DISABLED; if (pLog->dwAttributes & BURN_LOGGING_ATTRIBUTE_APPEND) { // If appending, ignore the failure and continue. hr = S_OK; } else // specifically tried to create a log file so show an error if appropriate and bail. { HRESULT hrOriginal = hr; hr = HRESULT_FROM_WIN32(ERROR_INSTALL_LOG_FAILURE); SplashScreenDisplayError(display, wzBundleName, hr); ExitOnFailure1(hrOriginal, "Failed to open log: %ls", pLog->sczPath); } } else { pLog->state = BURN_LOGGING_STATE_OPEN; } } else if (pLog->sczPrefix && *pLog->sczPrefix) { hr = GetNonSessionSpecificTempFolder(&sczLoggingBaseFolder); ExitOnFailure(hr, "Failed to get non-session specific TEMP folder."); // Best effort to open default logging. hr = LogOpen(sczLoggingBaseFolder, pLog->sczPrefix, NULL, pLog->sczExtension, FALSE, FALSE, &pLog->sczPath); if (FAILED(hr)) { LogDisable(); pLog->state = BURN_LOGGING_STATE_DISABLED; hr = S_OK; } else { pLog->state = BURN_LOGGING_STATE_OPEN; } } else // no logging enabled. { LogDisable(); pLog->state = BURN_LOGGING_STATE_DISABLED; } // If the log was opened, write the header info and update the prefix and extension to match // the log name so future logs are opened with the same pattern. if (BURN_LOGGING_STATE_OPEN == pLog->state) { LPCWSTR wzExtension = PathExtension(pLog->sczPath); if (wzExtension && *wzExtension) { hr = StrAllocString(&pLog->sczPrefix, pLog->sczPath, wzExtension - pLog->sczPath); ExitOnFailure(hr, "Failed to copy log path to prefix."); hr = StrAllocString(&pLog->sczExtension, wzExtension + 1, 0); ExitOnFailure(hr, "Failed to copy log extension to extension."); } else { hr = StrAllocString(&pLog->sczPrefix, pLog->sczPath, 0); ExitOnFailure(hr, "Failed to copy full log path to prefix."); } if (pLog->sczPathVariable && *pLog->sczPathVariable) { VariableSetString(pVariables, pLog->sczPathVariable, pLog->sczPath, FALSE); // Ignore failure. } } LExit: ReleaseStr(sczLoggingBaseFolder); return hr; }