gecko-dev/xpcom/base/nsLogging.cpp

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
 *
 * The contents of this file are subject to the Netscape Public
 * License Version 1.1 (the "License"); you may not use this file
 * except in compliance with the License. You may obtain a copy of
 * the License at http://www.mozilla.org/NPL/
 *
 * Software distributed under the License is distributed on an "AS
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * rights and limitations under the License.
 *
 * The Original Code is mozilla.org code.
 *
 * The Initial Developer of the Original Code is Netscape
 * Communications Corporation.  Portions created by Netscape are
 * Copyright (C) 1998 Netscape Communications Corporation. All
 * Rights Reserved.
 *
 * Contributor(s): 
 */

#include "nsLogging.h"

#ifdef NS_ENABLE_LOGGING

#include "nsCRT.h"
#include "prthread.h"
#include "nsAutoLock.h"
#include "nsISupportsArray.h"
#include "nsIServiceManager.h"
#include "nsSpecialSystemDirectory.h"
#include <math.h>
#ifdef XP_PC
#include <windows.h>
#endif

#undef printf
#undef fprintf

static PRMonitor* gLogMonitor = nsnull;
static nsObjectHashtable* gSettings = nsnull;

NS_DECL_LOG(LogInfo);

NS_DEFINE_CID(kLoggingServiceCID, NS_LOGGINGSERVICE_CID);

////////////////////////////////////////////////////////////////////////////////
// nsLoggingService

nsLoggingService::nsLoggingService()
    : mDefaultControlFlags(nsILog::PRINT_THREAD_ID |
                           nsILog::PRINT_LOG_NAME |
                           nsILog::PRINT_LEVEL |
                           nsILog::TIMING_PER_THREAD),
      mLogs(16)
{
    NS_INIT_REFCNT();
}

nsLoggingService::~nsLoggingService()
{
    NS_INIT_LOG(LogInfo);
    DescribeLogs(LogInfo);
    DescribeTimings(LogInfo);
}

NS_IMPL_ISUPPORTS1(nsLoggingService, nsILoggingService)

static void*
levelClone(nsHashKey *aKey, void *aData, void* closure)
{
    PRUint32 level = (PRUint32)aData;
    return (void*)level;
}

static PRBool
levelDestroy(nsHashKey *aKey, void *aData, void* closure)
{
    return PR_TRUE;
}

static void
RecordSetting(const char* name, const char* value)
{
    PRUint32 level = nsILog::LEVEL_ERROR;
    if (nsCRT::strcasecmp(value, "ERROR") == 0 ||
        nsCRT::strcasecmp(value, "2") == 0) {
        level = nsILog::LEVEL_ERROR;
        fprintf(stderr, "### NS_LOG: %s = ERROR\n", name);
    }
    else if (nsCRT::strcasecmp(value, "WARN") == 0 ||
             nsCRT::strcasecmp(value, "WARNING") == 0 ||
             nsCRT::strcasecmp(value, "3") == 0) {
        level = nsILog::LEVEL_WARN;
        fprintf(stderr, "### NS_LOG: %s = WARN\n", name);
    }
    else if (nsCRT::strcasecmp(value, "STDOUT") == 0 ||
             nsCRT::strcasecmp(value, "OUT") == 0 ||
             nsCRT::strcasecmp(value, "4") == 0) {
        level = nsILog::LEVEL_STDOUT;
        fprintf(stderr, "### NS_LOG: %s = STDOUT\n", name);
    }
    else if (nsCRT::strcasecmp(value, "DBG") == 0 ||
             nsCRT::strcasecmp(value, "DEBUG") == 0 ||
             nsCRT::strcasecmp(value, "5") == 0) {
        level = nsILog::LEVEL_DBG;
        fprintf(stderr, "### NS_LOG: %s = DBG\n", name);
    }
    else {
        fprintf(stderr, "### NS_LOG error: %s = %s (bad level)\n", name, value);
    }

    nsStringKey key(name);
    gSettings->Put(&key, (void*)level);
}

nsresult
nsLoggingService::Init()
{
    nsresult rv;
    nsStandardLogEventSink* defaultSink = nsnull;
    const char* outputPath = nsnull;

    if (gLogMonitor == nsnull) {
        gLogMonitor = PR_NewMonitor();
        if (gLogMonitor == nsnull)
            return NS_ERROR_OUT_OF_MEMORY;
    }

    if (gSettings == nsnull) {
        gSettings = new nsObjectHashtable(levelClone, nsnull,
                                          levelDestroy, nsnull,
                                          16);
        if (gSettings == nsnull) {
            rv = NS_ERROR_OUT_OF_MEMORY;
            goto error;
        }
    }

    // try the nspr log environment variables first:
    {
        const char* nspr_log_modules = getenv("NSPR_LOG_MODULES");
        if (nspr_log_modules) {
            fprintf(stderr, "### NS_LOG: using NSPR_LOG_MODULES (instead of .nslog)\n");
            char* head = nsCRT::strdup(nspr_log_modules);
            char* rest = nsCRT::strdup(nspr_log_modules);
            while (1) {
                char* name = nsCRT::strtok(rest, ":", &rest);
                if (name == nsnull) break;
                char* value = nsCRT::strtok(rest, ";", &rest);
                if (value == nsnull) break;
                RecordSetting(name, value);
            }
            nsCRT::free(head);
        }
        const char* nspr_log_file = getenv("NSPR_LOG_FILE");
        if (nspr_log_file) {
            fprintf(stderr, "### NS_LOG: using NSPR_LOG_FILE (instead of .nslog) -- logging to %s\n", 
                    nspr_log_file);
            outputPath = nspr_log_file;
        }
    }
    // then load up log description file:
    {
        nsSpecialSystemDirectory file(nsSpecialSystemDirectory::OS_CurrentProcessDirectory);
        file += ".nslog";
        const char* path = file.GetNativePathCString();
        FILE* f = ::fopen(path, "r");
        if (f != nsnull) {
            PRInt32 cnt;
            while (PR_TRUE) {
                char name[64];
                char value[64];
//                cnt = ::fscanf(f, "%64s=%64s\n", name, value);
                cnt = ::fscanf(f, "%64s\n", name);
                if (cnt <= 0) break;
                cnt = ::fscanf(f, "%64s\n", value);
                if (cnt <= 0) break;
                RecordSetting(name, value);
            }
            ::fclose(f);
        }
    }

    defaultSink = new nsStandardLogEventSink();
    if (defaultSink == nsnull) {
        rv = NS_ERROR_OUT_OF_MEMORY;
        goto error;
    }

    NS_ADDREF(defaultSink);
    if (outputPath)
        rv = defaultSink->Init(outputPath, nsILog::LEVEL_ERROR);
    else
        rv = defaultSink->InitFromFILE("stderr", stderr, nsILog::LEVEL_ERROR);
    if (NS_FAILED(rv)) goto error;

    mDefaultSink = defaultSink;
    NS_RELEASE(defaultSink);
    return NS_OK;

  error:
    NS_IF_RELEASE(defaultSink);
    if (gLogMonitor) {
        PR_DestroyMonitor(gLogMonitor);
        gLogMonitor = nsnull;
    }
    return rv;
}

NS_METHOD
nsLoggingService::Create(nsISupports* outer, const nsIID& aIID, void* *aInstancePtr)
{
    nsresult rv;
    if (outer)
        return NS_ERROR_NO_AGGREGATION;

    nsLoggingService* it = new nsLoggingService();
    if (it == NULL)
        return NS_ERROR_OUT_OF_MEMORY;

    rv = it->Init();
    if (NS_FAILED(rv)) {
        delete it;
        return rv; 
    }

    rv = it->QueryInterface(aIID, aInstancePtr);
    if (NS_FAILED(rv)) {
        delete it;
        return rv;
    }
    return rv;
}

NS_IMETHODIMP
nsLoggingService::GetLog(const char* name, nsILog* *result)
{
    nsAutoMonitor monitor(gLogMonitor);
    
    nsStringKey key(name);
    nsILog* log = (nsILog*)mLogs.Get(&key);
    if (log) {
        *result = log;
        return NS_OK;
    }

    nsLog* newLog = new nsLog();
    if (newLog == nsnull)
        return NS_ERROR_OUT_OF_MEMORY;
    nsresult rv = newLog->Init(name, mDefaultControlFlags, mDefaultSink);
    if (NS_FAILED(rv)) {
        delete newLog;
        return rv;
    }
    mLogs.Put(&key, newLog);
    *result = newLog;
    NS_ADDREF(newLog);
    return NS_OK;
}

static PRBool
DescribeLog(nsHashKey *aKey, void *aData, void* closure)
{
    nsILog* log = (nsILog*)aData;
    nsILog* out = (nsILog*)closure;
    (void)log->Describe(out);
    return PR_TRUE;
}

NS_IMETHODIMP
nsLoggingService::DescribeLogs(nsILog* out)
{
    NS_LOG(out, STDOUT, ("%-20.20s %-8.8s %s\n", "LOG NAME", "ENABLED", "DESTINATION"));
    mLogs.Enumerate(DescribeLog, out);
    return NS_OK;
}

static PRBool
DescribeTiming(nsHashKey *aKey, void *aData, void* closure)
{
    nsILog* log = (nsILog*)aData;
    nsILog* out = (nsILog*)closure;
    nsresult rv;
    PRUint32 sampleSize;
    double meanTime;
    double stdDevTime;
    rv = log->GetTimingStats(&sampleSize, &meanTime, &stdDevTime);
    if (NS_SUCCEEDED(rv) && sampleSize > 0)
        (void)log->DescribeTiming(out, "TOTAL TIME");
    return PR_TRUE;
}

NS_IMETHODIMP
nsLoggingService::DescribeTimings(nsILog* out)
{
    NS_LOG(out, STDOUT, ("  %-20.20s %-8.8s %s\n", "LOG NAME", "ENABLED", "DESTINATION"));
    mLogs.Enumerate(DescribeTiming, out);
    return NS_OK;
}

NS_IMETHODIMP
nsLoggingService::GetDefaultControlFlags(PRUint32 *controlFlags)
{
    *controlFlags = mDefaultControlFlags;
    return NS_OK;
}

NS_IMETHODIMP
nsLoggingService::SetDefaultControlFlags(PRUint32 controlFlags)
{
    mDefaultControlFlags = controlFlags;
    return NS_OK;
}

NS_IMETHODIMP
nsLoggingService::GetDefaultLogEventSink(nsILogEventSink* *sink)
{
    *sink = mDefaultSink;
    NS_ADDREF(*sink);
    return NS_OK;
}

NS_IMETHODIMP
nsLoggingService::SetDefaultLogEventSink(nsILogEventSink* sink)
{
    mDefaultSink = sink;
    return NS_OK;
}

////////////////////////////////////////////////////////////////////////////////
// nsLog

nsLog::nsLog()
    : mName(nsnull),
      mControlFlags(0),
      mIndentLevel(0)
{
    mEnabledLevel = LEVEL_ERROR;
    NS_INIT_REFCNT();
}

nsLog::~nsLog()
{
    if (mName) nsCRT::free(mName);
}

NS_IMPL_ISUPPORTS1(nsLog, nsILog)

static void PR_CALLBACK
DeleteTimingData(void *priv)
{
    nsTimingData* data = (nsTimingData*)priv;
    delete data;
}

nsresult
nsLog::Init(const char* name, PRUint32 controlFlags, nsILogEventSink* sink)
{
    mName = nsCRT::strdup(name);
    if (mName == nsnull)
        return NS_ERROR_OUT_OF_MEMORY;
    mControlFlags = controlFlags; 
    mSink = sink;

    nsStringKey key(name);
    PRUint32 level = (PRUint32)gSettings->Get(&key);
    if (level != LEVEL_NEVER) {
        mEnabledLevel = level;
    }
    PRStatus status = PR_NewThreadPrivateIndex(&mThreadTimingDataIndex,
                                               DeleteTimingData);
    if (status != PR_SUCCESS)
        return NS_ERROR_FAILURE;
    return NS_OK;
}

NS_IMETHODIMP
nsLog::GetName(char* *aName)
{
    *aName = nsCRT::strdup(mName);
    return *aName ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
}

NS_IMETHODIMP
nsLog::GetLevel(PRUint32 *aLevel)
{
    *aLevel = mEnabledLevel;
    return NS_OK;
}

NS_IMETHODIMP
nsLog::SetLevel(PRUint32 aLevel)
{
    mEnabledLevel = aLevel;
    return NS_OK;
}

NS_IMETHODIMP
nsLog::Enabled(PRUint32 level, PRBool *result)
{
    *result = Test(level);
    return NS_OK;
}

NS_IMETHODIMP
nsLog::Print(PRUint32 level, const PRUnichar *message)
{
    nsAutoMonitor monitor(gLogMonitor);
    
    nsCString str(message);
    char* msg = str.ToNewCString();
    nsLogEvent event(this, level);
    nsresult rv = event.Printf(msg);
    nsCRT::free(msg);
    return rv;
}

NS_IMETHODIMP
nsLog::Flush(void)
{
    nsAutoMonitor monitor(gLogMonitor);
    
    return mSink->Flush();
}

NS_IMETHODIMP
nsLog::PrintEvent(nsLogEvent& event)
{
    nsAutoMonitor monitor(gLogMonitor);
    
    return mSink->PrintEvent(event);
}

NS_IMETHODIMP
nsLog::IncreaseIndent()
{
    nsAutoMonitor monitor(gLogMonitor);
    
    mIndentLevel++;
    return NS_OK;
}

NS_IMETHODIMP
nsLog::DecreaseIndent()
{
    nsAutoMonitor monitor(gLogMonitor);
    
//    PR_ASSERT(mIndentLevel > 0);      // XXX layout is having trouble
    if (mIndentLevel == 0)
        return NS_ERROR_FAILURE;
    mIndentLevel--;
    return NS_OK;
}

NS_IMETHODIMP
nsLog::GetIndentLevel(PRUint32 *aIndentLevel)
{
    *aIndentLevel = mIndentLevel;
    return NS_OK;
}

NS_IMETHODIMP
nsLog::Describe(nsILog* out)
{
    nsresult rv;
    const char* levelName;
    switch (mEnabledLevel) {
      case nsILog::LEVEL_NEVER:  levelName = "NEVER"; break;
      case nsILog::LEVEL_ERROR:  levelName = "ERROR"; break;
      case nsILog::LEVEL_WARN:   levelName = "WARN"; break;
      case nsILog::LEVEL_STDOUT: levelName = "STDOUT"; break;
      case nsILog::LEVEL_DBG:    levelName = "DBG"; break;
      default:                   levelName = "<unknown>"; break;
    }
    char* dest = nsnull;
    rv = mSink->GetDestinationName(&dest);
    if (NS_FAILED(rv)) {
        dest = nsCRT::strdup("<unknown>");
    }
    NS_LOG(out, STDOUT, ("  %-20.20s %-8.8s %s\n", mName, levelName, dest));
    if (dest) nsCRT::free(dest);
    return NS_OK;
}

NS_IMETHODIMP
nsLog::BeginTiming(void)
{
    nsTimingData* data;
    if (mControlFlags & TIMING_PER_THREAD) {
        data = (nsTimingData*)PR_GetThreadPrivate(mThreadTimingDataIndex);
        if (data == nsnull) {
            data = new nsTimingData;
            if (data == nsnull) 
                return NS_ERROR_OUT_OF_MEMORY;
            PRStatus status = PR_SetThreadPrivate(mThreadTimingDataIndex, data);
            if (status != PR_SUCCESS)
                return NS_ERROR_FAILURE;
        }
    }
    else {
        data = &mTimingData;
    } 

    PR_ASSERT(data->mStartTime == 0);
    if (data->mStartTime != 0)
        return NS_ERROR_FAILURE;
    data->mStartTime = PR_IntervalNow();
    return NS_OK;
}

NS_IMETHODIMP
nsLog::EndTiming(PRIntervalTime *elapsedTime)
{
    nsTimingData* data;
    if (mControlFlags & TIMING_PER_THREAD)
        data = (nsTimingData*)PR_GetThreadPrivate(mThreadTimingDataIndex);
    else
        data = &mTimingData;
    
    PR_ASSERT(data->mStartTime != 0);
    if (data->mStartTime == 0)
        return NS_ERROR_FAILURE;
    PRIntervalTime elapsed = PR_IntervalNow();
    elapsed -= data->mStartTime;
    data->mStartTime = 0;
    data->mTimingSamples++;
    data->mTotalTime += elapsed;
    data->mTotalSquaredTime += elapsed * elapsed;
    *elapsedTime = elapsed;

    if (mControlFlags & TIMING_PER_THREAD) {
        // dump per-thread data into per-log data:
        mTimingData.mTotalTime += data->mTotalTime;
        mTimingData.mTotalSquaredTime += data->mTotalSquaredTime;
        mTimingData.mTimingSamples += data->mTimingSamples;

        // destroy TLS:
        PRStatus status = PR_SetThreadPrivate(mThreadTimingDataIndex, nsnull);
        if (status != PR_SUCCESS)
            return NS_ERROR_FAILURE;
    }
    return NS_OK;
}

NS_IMETHODIMP
nsLog::GetTimingStats(PRUint32 *sampleSize,
                      double *meanTime,
                      double *stdDevTime)
{
    *sampleSize = mTimingData.mTimingSamples;
    double mean = mTimingData.mTotalTime / mTimingData.mTimingSamples;
    *meanTime = (PRIntervalTime)mean;
    double variance = fabs(mTimingData.mTotalSquaredTime / mTimingData.mTimingSamples - mean * mean);
    *stdDevTime = sqrt(variance);
    return NS_OK;
}

NS_IMETHODIMP
nsLog::DescribeTiming(nsILog* out, const char* msg)
{
    nsresult rv;
    
    PR_ASSERT(mTimingData.mStartTime == 0);
    if (mTimingData.mStartTime != 0) {
        NS_LOG(this, STDOUT, ("%s: TIMING ERROR\n", msg));
        return NS_ERROR_FAILURE;
    }

    PRUint32 realTimeSamples;
    double realTimeMean, realTimeStdDev;
    rv = GetTimingStats(&realTimeSamples, &realTimeMean, &realTimeStdDev);
    if (NS_FAILED(rv)) return rv;
    PRUint32 tps = PR_TicksPerSecond();
    if (realTimeSamples > 1) {
        NS_LOG(out, STDOUT, ("%s: %.2f +/- %.2f ms (%d samples)\n", 
                             msg,
                             realTimeMean * 1000 / tps,
                             realTimeStdDev * 1000 / tps,
                             realTimeSamples));
    }
    else {
        NS_LOG(out, STDOUT, ("%s: %.2f ms\n", 
                             msg, realTimeMean * 1000 / tps));
    }
    return NS_OK;
}

NS_IMETHODIMP
nsLog::ResetTiming(void)
{
    PR_ASSERT(mTimingData.mStartTime == 0);
    mTimingData.mTotalTime = 0;
    mTimingData.mTotalSquaredTime = 0;
    mTimingData.mTimingSamples = 0;
    return NS_OK;
}

NS_IMETHODIMP
nsLog::GetControlFlags(PRUint32 *flags)
{
    nsAutoMonitor monitor(gLogMonitor);
    
    *flags = mControlFlags;
    return NS_OK;
}

NS_IMETHODIMP
nsLog::SetControlFlags(PRUint32 flags)
{
    nsAutoMonitor monitor(gLogMonitor);
    
    mControlFlags = flags;
    return NS_OK;
}

NS_IMETHODIMP
nsLog::GetLogEventSink(nsILogEventSink* *sink)
{
    nsAutoMonitor monitor(gLogMonitor);
    
    *sink = mSink;
    NS_ADDREF(*sink);
    return NS_OK;
}

NS_IMETHODIMP
nsLog::SetLogEventSink(nsILogEventSink* sink)
{
    nsAutoMonitor monitor(gLogMonitor);
    
    mSink = sink;
    return NS_OK;
}

////////////////////////////////////////////////////////////////////////////////
// nsLogEvent

nsresult
nsLogEvent::Printf(const char* format, ...)
{
    if (mMessage == nsnull) {
        va_list args;
        va_start(args, format);
        mMessage = PR_vsmprintf(format, args);
        va_end(args);
    }
    return mLog->PrintEvent(*this);
}

nsresult
nsLogEvent::Vprintf(const char* format, va_list args)
{
    if (mMessage == nsnull) {
        mMessage = PR_vsmprintf(format, args);
    }
    return mLog->PrintEvent(*this);
}

////////////////////////////////////////////////////////////////////////////////
// nsStandardLogEventSink 

nsStandardLogEventSink::nsStandardLogEventSink()
    : mName(nsnull),
      mOutput(nsnull),
      mDebugLevel(nsILog::LEVEL_NEVER),
      mBeginningOfLine(PR_TRUE),
      mCloseFile(PR_FALSE)
{
    NS_INIT_REFCNT();
}

nsStandardLogEventSink::~nsStandardLogEventSink()
{
    if (mCloseFile) {
        ::fclose(mOutput);
        mOutput = nsnull;
    }
    if (mName) nsCRT::free(mName);
}

NS_IMPL_ISUPPORTS2(nsStandardLogEventSink, 
                   nsIStandardLogEventSink,
                   nsILogEventSink)

NS_IMETHODIMP
nsStandardLogEventSink::GetDestinationName(char* *result)
{
    *result = nsCRT::strdup(mName);
    return *result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
}

NS_IMETHODIMP
nsStandardLogEventSink::Init(const char* filePath, PRUint32 levelForDebugOutput)
{
    FILE* filePtr;
    if (nsCRT::strcmp(filePath, "1") == 0) {
        filePtr = stdout;
    }
    else if (nsCRT::strcmp(filePath, "2") == 0) {
        filePtr = stderr;
    }
    else {
        filePtr = ::fopen(filePath, "W");
        if (filePtr == nsnull)
            return NS_ERROR_FAILURE;
        mCloseFile = PR_TRUE;
    }
    return InitFromFILE(filePath, filePtr, levelForDebugOutput);
}

NS_IMETHODIMP
nsStandardLogEventSink::InitFromFILE(const char* name, FILE* filePtr, PRUint32 levelForDebugOutput)
{
    mOutput = filePtr;
    mDebugLevel = levelForDebugOutput;
    mName = nsCRT::strdup(name);
    return mName ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
}

NS_IMETHODIMP
nsStandardLogEventSink::PrintEvent(nsLogEvent& event)
{
    nsresult rv;
    nsILog* log = event.GetLog();
    PRUint32 level = event.GetLevel();
    const char* msg = event.GetMsg();

    if (level == nsILog::LEVEL_NEVER) 
        return NS_OK;

    // do debug output first
    if (level <= mDebugLevel) {
#ifdef XP_PC
        OutputDebugString(msg);
#elif defined(XP_MAC)
        {
#           define BUF_SIZE 1024
            char buf[BUF_SIZE];
            PRUint32 len =
                PL_snprintf(buf+1, BUF_SIZE-1, "ERROR: %s", msg);
            buf[0] = (char) (len > 255 ? 255 : len);
            DebugStr(StringPtr(buf));
        }
#endif
    }

    if (!log->Test(level))
        return NS_OK;

    nsAutoMonitor monitor(gLogMonitor);
    
    if (!mBeginningOfLine) {
        ::fputc('\n', mOutput);
    }

    // print preamble
    char levels[] = { 'X', 'E', 'W', ' ', 'D' };
    PRUint32 flags;
    rv = log->GetControlFlags(&flags);
    if (NS_FAILED(rv)) return rv;
    if (flags & nsILog::PRINT_THREAD_ID) {
        ::fprintf(mOutput, "%8x ", PR_CurrentThread());
    }
    else {
        ::fprintf(mOutput, "%8s ", "");
    }

    char* name;
    rv = log->GetName(&name);
    ::fprintf(mOutput, "%-8.8s %c ",
              flags & nsILog::PRINT_LOG_NAME ? name : "",
              flags & nsILog::PRINT_LEVEL ? levels[level] : ' ');
    nsCRT::free(name);
    mBeginningOfLine = PR_FALSE;

    PRUint32 indentLevel;
    rv = log->GetIndentLevel(&indentLevel);
    if (NS_FAILED(rv)) return rv;
    do {
      indent:
        // do indentation
        for (PRUint32 i = 0; i < indentLevel; i++) {
            ::fputs("|  ", mOutput);
        }

        char c;
        while ((c = *msg++)) {
            switch (c) {
              case '\n':
                if (*msg == '\0') {
                    ::fputc('\n', mOutput);
                    mBeginningOfLine = PR_TRUE;
                    break;
                }
                else {
                    ::fputs("\n                    ", mOutput);
                    goto indent;
                }
              default:
                ::fputc(c, mOutput);
            }
        }
    } while (0);
    return NS_OK;
}

NS_IMETHODIMP
nsStandardLogEventSink::Flush()
{
    ::fflush(mOutput);
    return NS_OK;
}

////////////////////////////////////////////////////////////////////////////////

#endif // NS_ENABLE_LOGGING