开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
ncbidiag.cpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：42k
源码类别：

生物技术

开发平台：

C/C++

ncbidiag.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: ncbidiag.cpp,v $
  4.  * PRODUCTION Revision 1000.4  2004/06/01 19:08:57  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.80
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: ncbidiag.cpp,v 1000.4 2004/06/01 19:08:57 gouriano Exp $
  11.  * ===========================================================================
  12.  *
  13.  *                            PUBLIC DOMAIN NOTICE
  14.  *               National Center for Biotechnology Information
  15.  *
  16.  *  This software/database is a "United States Government Work" under the
  17.  *  terms of the United States Copyright Act.  It was written as part of
  18.  *  the author's official duties as a United States Government employee and
  19.  *  thus cannot be copyrighted.  This software/database is freely available
  20.  *  to the public for use. The National Library of Medicine and the U.S.
  21.  *  Government have not placed any restriction on its use or reproduction.
  22.  *
  23.  *  Although all reasonable efforts have been taken to ensure the accuracy
  24.  *  and reliability of the software and data, the NLM and the U.S.
  25.  *  Government do not and cannot warrant the performance or results that
  26.  *  may be obtained by using this software or data. The NLM and the U.S.
  27.  *  Government disclaim all warranties, express or implied, including
  28.  *  warranties of performance, merchantability or fitness for any particular
  29.  *  purpose.
  30.  *
  31.  *  Please cite the author in any work or product based on this material.
  32.  *
  33.  * ===========================================================================
  34.  *
  35.  * Author:  Denis Vakatov
  36.  *
  37.  * File Description:
  38.  *   NCBI C++ diagnostic API
  39.  *
  40.  */
  43. #include <ncbi_pch.hpp>
  45. #include <ncbiconf.h>
  47. #include <corelib/ncbidiag.hpp>
  48. #include <corelib/ncbithr.hpp>
  49. #include <corelib/ncbimtx.hpp>
  50. #include <corelib/ncbi_safe_static.hpp>
  51. #include <corelib/ncbiexpt.hpp>
  52. #include <stdlib.h>
  53. #include <time.h>
  54. #include <stack>
  56. #if defined(NCBI_OS_MAC)
  57. #  include <corelib/ncbi_os_mac.hpp>
  58. #endif
  60. BEGIN_NCBI_SCOPE
  62. DEFINE_STATIC_MUTEX(s_DiagMutex);
  64. #if defined(NCBI_POSIX_THREADS) && defined(HAVE_PTHREAD_ATFORK)
  66. #include <unistd.h> // for pthread_atfork()
  68. extern "C" {
  69.     static void s_NcbiDiagPreFork(void)
  70.     {
  71.         s_DiagMutex.Lock();
  72.     }
  73.     static void s_NcbiDiagPostFork(void)
  74.     {
  75.         s_DiagMutex.Unlock();
  76.     }
  77. }
  79. #endif
  82. ///////////////////////////////////////////////////////
  83. //  CDiagRecycler::
  85. class CDiagRecycler {
  86. public:
  87.     CDiagRecycler(void)
  88.     {
  89. #if defined(NCBI_POSIX_THREADS) && defined(HAVE_PTHREAD_ATFORK)
  90.         pthread_atfork(s_NcbiDiagPreFork,   // before
  91.                        s_NcbiDiagPostFork,  // after in parent
  92.                        s_NcbiDiagPostFork); // after in child
  93. #endif
  94.     }
  95.     ~CDiagRecycler(void)
  96.     {
  97.         SetDiagHandler(0, false);
  98.         SetDiagErrCodeInfo(0, false);
  99.     }
  100. };
  102. static CSafeStaticPtr<CDiagRecycler> s_DiagRecycler;
  105. ///////////////////////////////////////////////////////
  106. //  CDiagBuffer::
  108. #if defined(NDEBUG)
  109. EDiagSev       CDiagBuffer::sm_PostSeverity       = eDiag_Error;
  110. #else
  111. EDiagSev       CDiagBuffer::sm_PostSeverity       = eDiag_Warning;
  112. #endif /* else!NDEBUG */
  114. EDiagSevChange CDiagBuffer::sm_PostSeverityChange = eDiagSC_Unknown;
  115.                                                   // to be set on first request
  117. TDiagPostFlags CDiagBuffer::sm_PostFlags          =
  118.     eDPF_Prefix | eDPF_Severity | eDPF_ErrCode | eDPF_ErrSubCode | 
  119.     eDPF_ErrCodeMessage | eDPF_ErrCodeExplanation | eDPF_ErrCodeUseSeverity;
  120. TDiagPostFlags CDiagBuffer::sm_TraceFlags         = eDPF_Trace;
  122. EDiagSev       CDiagBuffer::sm_DieSeverity        = eDiag_Fatal;
  124. EDiagTrace     CDiagBuffer::sm_TraceDefault       = eDT_Default;
  125. bool           CDiagBuffer::sm_TraceEnabled;     // to be set on first request
  128. const char*    CDiagBuffer::sm_SeverityName[eDiag_Trace+1] = {
  129.     "Info", "Warning", "Error", "Critical", "Fatal", "Trace" };
  131. // Use s_DefaultHandler only for purposes of comparison, as installing
  132. // another handler will normally delete it.
  133. CDiagHandler*      s_DefaultHandler = new CStreamDiagHandler(&NcbiCerr);
  134. CDiagHandler*      CDiagBuffer::sm_Handler = s_DefaultHandler;
  135. bool               CDiagBuffer::sm_CanDeleteHandler = true;
  136. CDiagErrCodeInfo*  CDiagBuffer::sm_ErrCodeInfo = 0;
  137. bool               CDiagBuffer::sm_CanDeleteErrCodeInfo = false;
  140. CDiagBuffer::CDiagBuffer(void)
  141.     : m_Stream(new CNcbiOstrstream)
  142. {
  143.     m_Diag = 0;
  144. }
  146. CDiagBuffer::~CDiagBuffer(void)
  147. {
  148. #if (_DEBUG > 1)
  149.     if (m_Diag  ||  dynamic_cast<CNcbiOstrstream*>(m_Stream)->pcount())
  150.         Abort();
  151. #endif
  152.     delete m_Stream;
  153.     m_Stream = 0;
  154. }
  156. void CDiagBuffer::DiagHandler(SDiagMessage& mess)
  157. {
  158.     if ( CDiagBuffer::sm_Handler ) {
  159.         CMutexGuard LOCK(s_DiagMutex);
  160.         if ( CDiagBuffer::sm_Handler ) {
  161.             mess.m_Prefix = GetDiagBuffer().m_PostPrefix.empty() ?
  162.                 0 : GetDiagBuffer().m_PostPrefix.c_str();
  163.             CDiagBuffer::sm_Handler->Post(mess);
  164.         }
  165.     }
  166. }
  168. bool CDiagBuffer::SetDiag(const CNcbiDiag& diag)
  169. {
  170.     if ( !m_Stream ) {
  171.         return false;
  172.     }
  174.     // Check severity level change status
  175.     if ( sm_PostSeverityChange == eDiagSC_Unknown ) {
  176.         GetSeverityChangeEnabledFirstTime();
  177.     }
  179.     if (diag.GetSeverity() < sm_PostSeverity  ||
  180.         (diag.GetSeverity() == eDiag_Trace  &&  !GetTraceEnabled())) {
  181.         return false;
  182.     }
  184.     if (m_Diag != &diag) {
  185.         if ( dynamic_cast<CNcbiOstrstream*>(m_Stream)->pcount() ) {
  186.             Flush();
  187.         }
  188.         m_Diag = &diag;
  189.     }
  191.     return true;
  192. }
  194. void CDiagBuffer::Flush(void)
  195. {
  196.     if ( !m_Diag )
  197.         return;
  199.     CNcbiOstrstream* ostr = dynamic_cast<CNcbiOstrstream*>(m_Stream);
  200.     EDiagSev sev = m_Diag->GetSeverity();
  201.     if ( ostr->pcount() ) {
  202.         const char* message = ostr->str();
  203.         size_t size = ostr->pcount();
  204.         ostr->rdbuf()->freeze(false);
  205.         TDiagPostFlags flags = m_Diag->GetPostFlags();
  206.         if (sev == eDiag_Trace) {
  207.             flags |= sm_TraceFlags;
  208.         } else if (sev == eDiag_Fatal) {
  209.             // normally only happens once, so might as well pull everything
  210.             // in for the record...
  211.             flags |= sm_TraceFlags | eDPF_Trace;
  212.         }
  214.         string dest;
  215.         if (IsSetDiagPostFlag(eDPF_PreMergeLines, flags)) {
  216.             string src(message,0,size);
  217.             NStr::Replace(NStr::Replace(src,"r",""),"n",";", dest);
  218.             message = dest.c_str();
  219.             size = dest.length();
  220.         }
  221.         SDiagMessage mess
  222.             (sev, message, size,
  223.              m_Diag->GetFile(), m_Diag->GetLine(), flags,
  224.              0, m_Diag->GetErrorCode(), m_Diag->GetErrorSubCode());
  225.         DiagHandler(mess);
  227. #if defined(NCBI_COMPILER_KCC)
  228.         // KCC's implementation of "freeze(false)" makes the ostrstream buffer
  229.         // stuck.  We need to replace the frozen stream with the new one.
  230.         delete ostr;
  231.         m_Stream = new CNcbiOstrstream;
  232. #endif
  234.         Reset(*m_Diag);
  235.     }
  237.     if (sev >= sm_DieSeverity  &&  sev != eDiag_Trace) {
  238.         m_Diag = 0;
  239. #if defined(NCBI_OS_MAC)
  240.         if ( g_Mac_SpecialEnvironment ) {
  241.             throw runtime_error("Application aborted.");
  242.         }
  243. #endif
  244.         Abort();
  245.     }
  246. }
  249. bool CDiagBuffer::GetTraceEnabledFirstTime(void)
  250. {
  251.     CMutexGuard LOCK(s_DiagMutex);
  252.     const char* str = ::getenv(DIAG_TRACE);
  253.     if (str  &&  *str) {
  254.         sm_TraceDefault = eDT_Enable;
  255.     } else {
  256.         sm_TraceDefault = eDT_Disable;
  257.     }
  258.     sm_TraceEnabled = (sm_TraceDefault == eDT_Enable);
  259.     return sm_TraceEnabled;
  260. }
  263. bool CDiagBuffer::GetSeverityChangeEnabledFirstTime(void)
  264. {
  265.     CMutexGuard LOCK(s_DiagMutex);
  266.     if ( sm_PostSeverityChange != eDiagSC_Unknown ) {
  267.         return sm_PostSeverityChange == eDiagSC_Enable;
  268.     }
  269.     const char* str = ::getenv(DIAG_POST_LEVEL);
  270.     EDiagSev sev;
  271.     if (str  &&  *str  &&  CNcbiDiag::StrToSeverityLevel(str, sev)) {
  272.         SetDiagFixedPostLevel(sev);
  273.     } else {
  274.         sm_PostSeverityChange = eDiagSC_Enable;
  275.     }
  276.     return sm_PostSeverityChange == eDiagSC_Enable;
  277. }
  280. void CDiagBuffer::UpdatePrefix(void)
  281. {
  282.     m_PostPrefix.erase();
  283.     ITERATE(TPrefixList, prefix, m_PrefixList) {
  284.         if (prefix != m_PrefixList.begin()) {
  285.             m_PostPrefix += "::";
  286.         }
  287.         m_PostPrefix += *prefix;
  288.     }
  289. }
  292. ///////////////////////////////////////////////////////
  293. //  CDiagMessage::
  295. void SDiagMessage::Write(string& str, TDiagWriteFlags flags) const
  296. {
  297.     CNcbiOstrstream ostr;
  298.     Write(ostr, flags);
  299.     ostr.put('');
  300.     str = ostr.str();
  301.     ostr.rdbuf()->freeze(false);
  302. }
  305. CNcbiOstream& SDiagMessage::Write(CNcbiOstream&   os,
  306.                                   TDiagWriteFlags flags) const
  307. {
  308.     if (IsSetDiagPostFlag(eDPF_MergeLines, m_Flags)) {
  309.         CNcbiOstrstream ostr;
  310.         string src, dest;
  311.         x_Write(ostr, fNoEndl);
  312.         ostr.put('');
  313.         src = ostr.str();
  314.         ostr.rdbuf()->freeze(false);
  315.         NStr::Replace(NStr::Replace(src,"r",""),"n","", dest);
  316.         os << dest;
  317.         if ((flags & fNoEndl) == 0) {
  318.             os << NcbiEndl;
  319.         }
  320.         return os;
  321.     } else {
  322.         return x_Write(os, flags);
  323.     }
  324. }
  327. CNcbiOstream& SDiagMessage::x_Write(CNcbiOstream& os,
  328.                                     TDiagWriteFlags flags) const
  329. {
  330.     // Date & time
  331.     if (IsSetDiagPostFlag(eDPF_DateTime, m_Flags)) {
  332.         static const char timefmt[] = "%D %T ";
  333.         time_t t = time(0);
  334.         char datetime[32];
  335.         struct tm* tm;
  336. #ifdef HAVE_LOCALTIME_R
  337.         struct tm temp;
  338.         localtime_r(&t, &temp);
  339.         tm = &temp;
  340. #else
  341.         tm = localtime(&t);
  342. #endif /*HAVE_LOCALTIME_R*/
  343.         NStr::strftime(datetime, sizeof(datetime), timefmt, tm);
  344.         os << datetime;
  345.     }
  346.     // "<file>"
  347.     bool print_file = (m_File  &&  *m_File  &&
  348.                        IsSetDiagPostFlag(eDPF_File, m_Flags));
  349.     if ( print_file ) {
  350.         const char* x_file = m_File;
  351.         if ( !IsSetDiagPostFlag(eDPF_LongFilename, m_Flags) ) {
  352.             for (const char* s = m_File;  *s;  s++) {
  353.                 if (*s == '/'  ||  *s == '\'  ||  *s == ':')
  354.                     x_file = s + 1;
  355.             }
  356.         }
  357.         os << '"' << x_file << '"';
  358.     }
  360.     // , line <line>
  361.     bool print_line = (m_Line  &&  IsSetDiagPostFlag(eDPF_Line, m_Flags));
  362.     if ( print_line )
  363.         os << (print_file ? ", line " : "line ") << m_Line;
  365.     // :
  366.     if (print_file  ||  print_line)
  367.         os << ": ";
  369.     // Get error code description
  370.     bool have_description = false;
  371.     SDiagErrCodeDescription description;
  372.     if ((m_ErrCode  ||  m_ErrSubCode)  &&
  373.         (IsSetDiagPostFlag(eDPF_ErrCodeMessage, m_Flags)  || 
  374.          IsSetDiagPostFlag(eDPF_ErrCodeExplanation, m_Flags)  ||
  375.          IsSetDiagPostFlag(eDPF_ErrCodeUseSeverity, m_Flags))  &&
  376.          IsSetDiagErrCodeInfo()) {
  378.         CDiagErrCodeInfo* info = GetDiagErrCodeInfo();
  379.         if ( info  && 
  380.              info->GetDescription(ErrCode(m_ErrCode, m_ErrSubCode), 
  381.                                   &description) ) {
  382.             have_description = true;
  383.             if (IsSetDiagPostFlag(eDPF_ErrCodeUseSeverity, m_Flags) && 
  384.                 description.m_Severity != -1 )
  385.                 m_Severity = (EDiagSev)description.m_Severity;
  386.         }
  387.     }
  389.     // <severity>:
  390.     if (IsSetDiagPostFlag(eDPF_Severity, m_Flags)  &&
  391.         (m_Severity != eDiag_Info || !IsSetDiagPostFlag(eDPF_OmitInfoSev)))
  392.         os << CNcbiDiag::SeverityName(m_Severity) << ": ";
  394.     // (<err_code>.<err_subcode>) or (err_text)
  395.     if ((m_ErrCode  ||  m_ErrSubCode || m_ErrText)  &&
  396.         IsSetDiagPostFlag(eDPF_ErrCode, m_Flags)) {
  397.         os << '(';
  398.         if (m_ErrText) {
  399.             os << m_ErrText;
  400.         } else {
  401.             os << m_ErrCode;
  402.             if ( IsSetDiagPostFlag(eDPF_ErrSubCode, m_Flags)) {
  403.                 os << '.' << m_ErrSubCode;
  404.             }
  405.         }
  406.         os << ") ";
  407.     }
  409.     // [<prefix1>::<prefix2>::.....]
  410.     if (m_Prefix  &&  *m_Prefix  &&  IsSetDiagPostFlag(eDPF_Prefix, m_Flags))
  411.         os << '[' << m_Prefix << "] ";
  413.     // <message>
  414.     if (m_BufferLen)
  415.         os.write(m_Buffer, m_BufferLen);
  417.     // <err_code_message> and <err_code_explanation>
  418.     if (have_description) {
  419.         if (IsSetDiagPostFlag(eDPF_ErrCodeMessage, m_Flags) &&
  420.             !description.m_Message.empty())
  421.             os << NcbiEndl << description.m_Message << ' ';
  422.         if (IsSetDiagPostFlag(eDPF_ErrCodeExplanation, m_Flags) &&
  423.             !description.m_Explanation.empty())
  424.             os << NcbiEndl << description.m_Explanation;
  425.     }
  427.     // Endl
  428.     if ((flags & fNoEndl) == 0) {
  429.         os << NcbiEndl;
  430.     }
  432.     return os;
  433. }
  436. ///////////////////////////////////////////////////////
  437. //  CDiagAutoPrefix::
  439. CDiagAutoPrefix::CDiagAutoPrefix(const string& prefix)
  440. {
  441.     PushDiagPostPrefix(prefix.c_str());
  442. }
  444. CDiagAutoPrefix::CDiagAutoPrefix(const char* prefix)
  445. {
  446.     PushDiagPostPrefix(prefix);
  447. }
  449. CDiagAutoPrefix::~CDiagAutoPrefix(void)
  450. {
  451.     PopDiagPostPrefix();
  452. }
  455. ///////////////////////////////////////////////////////
  456. //  EXTERN
  459. static TDiagPostFlags s_SetDiagPostAllFlags(TDiagPostFlags& flags,
  460.                                             TDiagPostFlags  new_flags)
  461. {
  462.     CMutexGuard LOCK(s_DiagMutex);
  464.     TDiagPostFlags prev_flags = flags;
  465.     if (new_flags & eDPF_Default) {
  466.         new_flags |= prev_flags;
  467.         new_flags &= ~eDPF_Default;
  468.     }
  469.     flags = new_flags;
  470.     return prev_flags;
  471. }
  474. static void s_SetDiagPostFlag(TDiagPostFlags& flags, EDiagPostFlag flag)
  475. {
  476.     if (flag == eDPF_Default)
  477.         return;
  479.     CMutexGuard LOCK(s_DiagMutex);
  480.     flags |= flag;
  481. }
  484. static void s_UnsetDiagPostFlag(TDiagPostFlags& flags, EDiagPostFlag flag)
  485. {
  486.     if (flag == eDPF_Default)
  487.         return;
  489.     CMutexGuard LOCK(s_DiagMutex);
  490.     flags &= ~flag;
  491. }
  494. extern TDiagPostFlags SetDiagPostAllFlags(TDiagPostFlags flags)
  495. {
  496.     return s_SetDiagPostAllFlags(CDiagBuffer::sm_PostFlags, flags);
  497. }
  499. extern void SetDiagPostFlag(EDiagPostFlag flag)
  500. {
  501.     s_SetDiagPostFlag(CDiagBuffer::sm_PostFlags, flag);
  502. }
  504. extern void UnsetDiagPostFlag(EDiagPostFlag flag)
  505. {
  506.     s_UnsetDiagPostFlag(CDiagBuffer::sm_PostFlags, flag);
  507. }
  510. extern TDiagPostFlags SetDiagTraceAllFlags(TDiagPostFlags flags)
  511. {
  512.     return s_SetDiagPostAllFlags(CDiagBuffer::sm_TraceFlags, flags);
  513. }
  515. extern void SetDiagTraceFlag(EDiagPostFlag flag)
  516. {
  517.     s_SetDiagPostFlag(CDiagBuffer::sm_TraceFlags, flag);
  518. }
  520. extern void UnsetDiagTraceFlag(EDiagPostFlag flag)
  521. {
  522.     s_UnsetDiagPostFlag(CDiagBuffer::sm_TraceFlags, flag);
  523. }
  526. extern void SetDiagPostPrefix(const char* prefix)
  527. {
  528.     CDiagBuffer& buf = GetDiagBuffer();
  529.     if ( prefix ) {
  530.         buf.m_PostPrefix = prefix;
  531.     } else {
  532.         buf.m_PostPrefix.erase();
  533.     }
  534.     buf.m_PrefixList.clear();
  535. }
  538. extern void PushDiagPostPrefix(const char* prefix)
  539. {
  540.     if (prefix  &&  *prefix) {
  541.         CDiagBuffer& buf = GetDiagBuffer();
  542.         buf.m_PrefixList.push_back(prefix);
  543.         buf.UpdatePrefix();
  544.     }
  545. }
  548. extern void PopDiagPostPrefix(void)
  549. {
  550.     CDiagBuffer& buf = GetDiagBuffer();
  551.     if ( !buf.m_PrefixList.empty() ) {
  552.         buf.m_PrefixList.pop_back();
  553.         buf.UpdatePrefix();
  554.     }
  555. }
  558. extern EDiagSev SetDiagPostLevel(EDiagSev post_sev)
  559. {
  560.     if (post_sev < eDiagSevMin  ||  post_sev > eDiagSevMax) {
  561.         NCBI_THROW(CCoreException, eInvalidArg,
  562.                    "SetDiagPostLevel() -- Severity must be in the range "
  563.                    "[eDiagSevMin..eDiagSevMax]");
  564.     }
  566.     CMutexGuard LOCK(s_DiagMutex);
  567.     EDiagSev sev = CDiagBuffer::sm_PostSeverity;
  568.     if ( CDiagBuffer::sm_PostSeverityChange != eDiagSC_Disable) {
  569.         CDiagBuffer::sm_PostSeverity = post_sev;
  570.     }
  571.     return sev;
  572. }
  575. extern void SetDiagFixedPostLevel(const EDiagSev post_sev)
  576. {
  577.     SetDiagPostLevel(post_sev);
  578.     DisableDiagPostLevelChange();
  579. }
  582. extern bool DisableDiagPostLevelChange(bool disable_change)
  583. {
  584.     CMutexGuard LOCK(s_DiagMutex);
  585.     bool prev_status = (CDiagBuffer::sm_PostSeverityChange == eDiagSC_Enable);
  586.     CDiagBuffer::sm_PostSeverityChange = disable_change ? eDiagSC_Disable : 
  587.                                                           eDiagSC_Enable;
  588.     return prev_status;
  589. }
  592. extern EDiagSev SetDiagDieLevel(EDiagSev die_sev)
  593. {
  594.     if (die_sev < eDiagSevMin  ||  die_sev > eDiag_Fatal) {
  595.         NCBI_THROW(CCoreException, eInvalidArg,
  596.                    "SetDiagDieLevel() -- Severity must be in the range "
  597.                    "[eDiagSevMin..eDiag_Fatal]");
  598.     }
  600.     CMutexGuard LOCK(s_DiagMutex);
  601.     EDiagSev sev = CDiagBuffer::sm_DieSeverity;
  602.     CDiagBuffer::sm_DieSeverity = die_sev;
  603.     return sev;
  604. }
  607. extern void IgnoreDiagDieLevel(bool ignore, EDiagSev* prev_sev)
  608. {
  609.     if (!!ignore != !!prev_sev) {
  610.         NCBI_THROW(CCoreException, eInvalidArg,
  611.                    "IgnoreDiagDieLevel() -- Illegal 'ignore'/'prev_sev' "
  612.                    "combination");
  613.     }
  615.     CMutexGuard LOCK(s_DiagMutex);
  616.     if ( ignore ) {
  617.         *prev_sev = CDiagBuffer::sm_DieSeverity;
  618.         CDiagBuffer::sm_DieSeverity = eDiag_Trace;
  619.     } else {
  620.         CDiagBuffer::sm_DieSeverity = eDiag_Fatal;
  621.         CNcbiDiag diag(eDiag_Info);
  622.     }
  623. }
  626. extern void SetDiagTrace(EDiagTrace how, EDiagTrace dflt)
  627. {
  628.     CMutexGuard LOCK(s_DiagMutex);
  629.     (void) CDiagBuffer::GetTraceEnabled();
  631.     if (dflt != eDT_Default)
  632.         CDiagBuffer::sm_TraceDefault = dflt;
  634.     if (how == eDT_Default)
  635.         how = CDiagBuffer::sm_TraceDefault;
  636.     CDiagBuffer::sm_TraceEnabled = (how == eDT_Enable);
  637. }
  640. extern void SetDiagHandler(CDiagHandler* handler, bool can_delete)
  641. {
  642.     CMutexGuard LOCK(s_DiagMutex);
  643.     if ( CDiagBuffer::sm_CanDeleteHandler )
  644.         delete CDiagBuffer::sm_Handler;
  645.     CDiagBuffer::sm_Handler          = handler;
  646.     CDiagBuffer::sm_CanDeleteHandler = can_delete;
  647. }
  649. extern bool IsSetDiagHandler(void)
  650. {
  651.     return (CDiagBuffer::sm_Handler != s_DefaultHandler);
  652. }
  654. extern CDiagHandler* GetDiagHandler(bool take_ownership)
  655. {
  656.     CMutexGuard LOCK(s_DiagMutex);
  657.     if (take_ownership) {
  658.         _ASSERT(CDiagBuffer::sm_CanDeleteHandler);
  659.         CDiagBuffer::sm_CanDeleteHandler = false;
  660.     }
  661.     return CDiagBuffer::sm_Handler;
  662. }
  665. static void s_TlsDataCleanup(CDiagBuffer* old_value, void* /* cleanup_data */)
  666. {
  667.     delete old_value;
  668. }
  670. static bool s_TlsDestroyed; /* = false */
  672. static void s_TlsObjectCleanup(void* /* ptr */)
  673. {
  674.     s_TlsDestroyed = true;
  675. }
  678. extern CDiagBuffer& GetDiagBuffer(void)
  679. {
  680.     static CSafeStaticRef< CTls<CDiagBuffer> >
  681.         s_DiagBufferTls(s_TlsObjectCleanup);
  683.     // Create and use dummy buffer if all real buffers are gone already
  684.     // (on the application exit)
  685.     if ( s_TlsDestroyed ) {
  686.         static CDiagBuffer s_DiagBuffer;
  687.         return s_DiagBuffer;
  688.     }
  690.     // Create thread-specific diag.buffer (if not created yet),
  691.     // and store it to TLS
  692.     CDiagBuffer* msg_buf = s_DiagBufferTls->GetValue();
  693.     if ( !msg_buf ) {
  694.         msg_buf = new CDiagBuffer;
  695.         s_DiagBufferTls->SetValue(msg_buf, s_TlsDataCleanup);
  696.     }
  698.     return *msg_buf;
  699. }
  702. void CStreamDiagHandler::Post(const SDiagMessage& mess)
  703. {
  704.     if (m_Stream) {
  705.         (*m_Stream) << mess;
  706.         if (m_QuickFlush) {
  707.             (*m_Stream) << NcbiFlush;
  708.         }
  709.     }
  710. }
  713. extern bool IsDiagStream(const CNcbiOstream* os)
  714. {
  715.     CStreamDiagHandler* sdh
  716.         = dynamic_cast<CStreamDiagHandler*>(CDiagBuffer::sm_Handler);
  717.     return (sdh  &&  sdh->m_Stream == os);
  718. }
  721. extern void SetDiagErrCodeInfo(CDiagErrCodeInfo* info, bool can_delete)
  722. {
  723.     CMutexGuard LOCK(s_DiagMutex);
  724.     if ( CDiagBuffer::sm_CanDeleteErrCodeInfo )
  725.         delete CDiagBuffer::sm_ErrCodeInfo;
  726.     CDiagBuffer::sm_ErrCodeInfo = info;
  727.     CDiagBuffer::sm_CanDeleteErrCodeInfo = can_delete;
  728. }
  730. extern bool IsSetDiagErrCodeInfo(void)
  731. {
  732.     return (CDiagBuffer::sm_ErrCodeInfo != 0);
  733. }
  735. extern CDiagErrCodeInfo* GetDiagErrCodeInfo(bool take_ownership)
  736. {
  737.     CMutexGuard LOCK(s_DiagMutex);
  738.     if (take_ownership) {
  739.         _ASSERT(CDiagBuffer::sm_CanDeleteErrCodeInfo);
  740.         CDiagBuffer::sm_CanDeleteErrCodeInfo = false;
  741.     }
  742.     return CDiagBuffer::sm_ErrCodeInfo;
  743. }
  746. ///////////////////////////////////////////////////////
  747. //  CNcbiDiag::
  749. CNcbiDiag::CNcbiDiag(EDiagSev sev, TDiagPostFlags post_flags)
  750.     : m_Severity(sev), m_Line(0), m_ErrCode(0), m_ErrSubCode(0),
  751.       m_Buffer(GetDiagBuffer()), m_PostFlags(post_flags)
  752. {
  753.     *m_File = '';
  754. }
  757. CNcbiDiag::CNcbiDiag(const char* file, size_t line,
  758.                      EDiagSev sev, TDiagPostFlags post_flags)
  759.     : m_Severity(sev), m_Line(line), m_ErrCode(0), m_ErrSubCode(0),
  760.       m_Buffer(GetDiagBuffer()), m_PostFlags(post_flags)
  761. {
  762.     SetFile(file);
  763. }
  766. const CNcbiDiag& CNcbiDiag::SetFile(const char* file) const
  767. {
  768.     if (file  &&  *file) {
  769.         strncpy(m_File, file, sizeof(m_File));
  770.         m_File[sizeof(m_File) - 1] = '';
  771.     } else {
  772.         *m_File = '';
  773.     }
  774.     return *this;
  775. }
  777. const CNcbiDiag& CNcbiDiag::operator<< (const CException& ex) const
  778. {
  780.     {
  781.         ostrstream os;
  782.         os << 'n' << "NCBI C++ Exception:" << 'n';
  783.         *this << string(CNcbiOstrstreamToString(os));
  784.     }
  785.     const CException* pex;
  786.     stack<const CException*> pile;
  787.     // invert the order
  788.     for (pex = &ex; pex; pex = pex->GetPredecessor()) {
  789.         pile.push(pex);
  790.     }
  791.     for (; !pile.empty(); pile.pop()) {
  792.         pex = pile.top();
  793.         string text(pex->GetMsg());
  794.         {
  795.             ostrstream os;
  796.             pex->ReportExtra(os);
  797.             if (os.pcount() != 0) {
  798.                 text += " (";
  799.                 text += (string)CNcbiOstrstreamToString(os);
  800.                 text += ')';
  801.             }
  802.         }
  803.         string err_type(pex->GetType());
  804.         err_type += "::";
  805.         err_type += pex->GetErrCodeString();
  806.         SDiagMessage diagmsg(
  807.             eDiag_Error, text.c_str(), text.size(),
  808.             (pex->GetFile()).c_str(), pex->GetLine(),
  809.             GetPostFlags(), 0,0,0,err_type.c_str());
  810.         string report;
  811.         diagmsg.Write(report);
  812.         *this << "    "; // indentation
  813.         *this << report;
  814.     }
  815.     return *this;
  816. }
  819. bool CNcbiDiag::StrToSeverityLevel(const char* str_sev, EDiagSev& sev)
  820. {
  821.     if (!str_sev || !*str_sev) {
  822.         return false;
  823.     } 
  824.     // Digital value
  825.     int nsev = NStr::StringToNumeric(str_sev);
  827.     if (nsev > eDiagSevMax) {
  828.         nsev = eDiagSevMax;
  829.     } else if ( nsev == -1 ) {
  830.         // String value
  831.         for (int s = eDiagSevMin; s <= eDiagSevMax; s++) {
  832.             if (NStr::CompareNocase(CNcbiDiag::SeverityName(EDiagSev(s)),
  833.                                     str_sev) == 0) {
  834.                 nsev = s;
  835.                 break;
  836.             }
  837.         }
  838.     }
  839.     sev = EDiagSev(nsev);
  840.     // Unknown value
  841.     return sev >= eDiagSevMin && sev <= eDiagSevMax;
  842. }
  844. void CNcbiDiag::DiagFatal(const char* file, size_t line,
  845.                           const char* message)
  846. {
  847.     CNcbiDiag(file, line, NCBI_NS_NCBI::eDiag_Fatal) << message << Endm;
  848. }
  850. void CNcbiDiag::DiagTrouble(const char* file, size_t line)
  851. {
  852.     DiagFatal(file, line, "Trouble!");
  853. }
  855. void CNcbiDiag::DiagAssert(const char* file, size_t line,
  856.                            const char* expression)
  857. {
  858.     CNcbiDiag(file, line, NCBI_NS_NCBI::eDiag_Fatal, eDPF_Trace) <<
  859.         "Assertion failed: (" << expression << ')' << Endm;
  860. }
  862. void CNcbiDiag::DiagValidate(const char* file, size_t line,
  863.                              const char* _DEBUG_ARG(expression),
  864.                              const char* message)
  865. {
  866. #ifdef _DEBUG
  867.     if ( xncbi_GetValidateAction() != eValidate_Throw ) {
  868.         DiagAssert(file, line, expression);
  869.     }
  870. #endif
  871.     throw CCoreException(file, (int) line, 0, CCoreException::eCore, message);
  872. }
  874. ///////////////////////////////////////////////////////
  875. //  CDiagRestorer::
  877. CDiagRestorer::CDiagRestorer(void)
  878. {
  879.     CMutexGuard LOCK(s_DiagMutex);
  880.     const CDiagBuffer& buf  = GetDiagBuffer();
  881.     m_PostPrefix            = buf.m_PostPrefix;
  882.     m_PrefixList            = buf.m_PrefixList;
  883.     m_PostFlags             = buf.sm_PostFlags;
  884.     m_PostSeverity          = buf.sm_PostSeverity;
  885.     m_PostSeverityChange    = buf.sm_PostSeverityChange;
  886.     m_DieSeverity           = buf.sm_DieSeverity;
  887.     m_TraceDefault          = buf.sm_TraceDefault;
  888.     m_TraceEnabled          = buf.sm_TraceEnabled;
  889.     m_Handler               = buf.sm_Handler;
  890.     m_CanDeleteHandler      = buf.sm_CanDeleteHandler;
  891.     m_ErrCodeInfo           = buf.sm_ErrCodeInfo;
  892.     m_CanDeleteErrCodeInfo  = buf.sm_CanDeleteErrCodeInfo;
  893.     // avoid premature cleanup
  894.     buf.sm_CanDeleteHandler = false;
  895.     buf.sm_CanDeleteErrCodeInfo = false;
  896. }
  898. CDiagRestorer::~CDiagRestorer(void)
  899. {
  900.     {{
  901.         CMutexGuard LOCK(s_DiagMutex);
  902.         CDiagBuffer& buf          = GetDiagBuffer();
  903.         buf.m_PostPrefix          = m_PostPrefix;
  904.         buf.m_PrefixList          = m_PrefixList;
  905.         buf.sm_PostFlags          = m_PostFlags;
  906.         buf.sm_PostSeverity       = m_PostSeverity;
  907.         buf.sm_PostSeverityChange = m_PostSeverityChange;
  908.         buf.sm_DieSeverity        = m_DieSeverity;
  909.         buf.sm_TraceDefault       = m_TraceDefault;
  910.         buf.sm_TraceEnabled       = m_TraceEnabled;
  911.     }}
  912.     SetDiagHandler(m_Handler, m_CanDeleteHandler);
  913.     SetDiagErrCodeInfo(m_ErrCodeInfo, m_CanDeleteErrCodeInfo);
  914. }
  917. //////////////////////////////////////////////////////
  918. //  internal diag. handler classes for compatibility:
  920. class CCompatDiagHandler : public CDiagHandler
  921. {
  922. public:
  923.     CCompatDiagHandler(FDiagHandler func, void* data, FDiagCleanup cleanup)
  924.         : m_Func(func), m_Data(data), m_Cleanup(cleanup)
  925.         { }
  926.     ~CCompatDiagHandler(void)
  927.         {
  928.             if (m_Cleanup) {
  929.                 m_Cleanup(m_Data);
  930.             }
  931.         }
  932.     virtual void Post(const SDiagMessage& mess) { m_Func(mess); }
  934. private:
  935.     FDiagHandler m_Func;
  936.     void*        m_Data;
  937.     FDiagCleanup m_Cleanup;
  938. };
  940. extern void SetDiagHandler(FDiagHandler func,
  941.                            void*        data,
  942.                            FDiagCleanup cleanup)
  943. {
  944.     SetDiagHandler(new CCompatDiagHandler(func, data, cleanup));
  945. }
  948. class CCompatStreamDiagHandler : public CStreamDiagHandler
  949. {
  950. public:
  951.     CCompatStreamDiagHandler(CNcbiOstream* os, bool quick_flush = true,
  952.                              FDiagCleanup cleanup = 0,
  953.                              void* cleanup_data = 0)
  954.         : CStreamDiagHandler(os, quick_flush),
  955.           m_Cleanup(cleanup), m_CleanupData(cleanup_data)
  956.         {
  957.         }
  959.     ~CCompatStreamDiagHandler(void)
  960.         {
  961.             if (m_Cleanup) {
  962.                 m_Cleanup(m_CleanupData);
  963.             }
  964.         }
  966. private:
  967.     FDiagCleanup m_Cleanup;
  968.     void*        m_CleanupData;
  969. };
  971. extern void SetDiagStream(CNcbiOstream* os, bool quick_flush,
  972.                           FDiagCleanup cleanup, void* cleanup_data)
  973. {
  974.     SetDiagHandler(new CCompatStreamDiagHandler(os, quick_flush,
  975.                                                 cleanup, cleanup_data));
  976. }
  979. //////////////////////////////////////////////////////
  980. //  abort handler
  983. static FAbortHandler s_UserAbortHandler = 0;
  985. extern void SetAbortHandler(FAbortHandler func)
  986. {
  987.     s_UserAbortHandler = func;
  988. }
  991. extern void Abort(void)
  992. {
  993.     // If defined user abort handler then call it 
  994.     if ( s_UserAbortHandler )
  995.         s_UserAbortHandler();
  996.     
  997.     // If don't defined handler or application doesn't still terminated
  999.     // Check environment variable for silent exit
  1000.     const char* value = getenv("DIAG_SILENT_ABORT");
  1001.     if (value  &&  (*value == 'Y'  ||  *value == 'y'  ||  *value == '1')) {
  1002.         ::exit(255);
  1003.     }
  1004.     else if (value  &&  (*value == 'N'  ||  *value == 'n' || *value == '0')) {
  1005.         ::abort();
  1006.     }
  1007.     else {
  1008. #if defined(_DEBUG)
  1009.         ::abort();
  1010. #else
  1011.         ::exit(255);
  1012. #endif
  1013.     }
  1014. }
  1017. ///////////////////////////////////////////////////////
  1018. //  CDiagErrCodeInfo::
  1019. //
  1021. SDiagErrCodeDescription::SDiagErrCodeDescription(void)
  1022.         : m_Message(kEmptyStr),
  1023.           m_Explanation(kEmptyStr),
  1024.           m_Severity(-1)
  1025. {
  1026.     return;
  1027. }
  1030. bool CDiagErrCodeInfo::Read(const string& file_name)
  1031. {
  1032.     CNcbiIfstream is(file_name.c_str());
  1033.     if ( !is.good() ) {
  1034.         return false;
  1035.     }
  1036.     return Read(is);
  1037. }
  1040. // Parse string for CDiagErrCodeInfo::Read()
  1042. bool s_ParseErrCodeInfoStr(string&          str,
  1043.                            const SIZE_TYPE  line,
  1044.                            int&             x_code,
  1045.                            int&             x_severity,
  1046.                            string&          x_message,
  1047.                            bool&            x_ready)
  1048. {
  1049.     list<string> tokens;    // List with line tokens
  1051.     try {
  1052.         // Get message text
  1053.         SIZE_TYPE pos = str.find_first_of(':');
  1054.         if (pos == NPOS) {
  1055.             x_message = kEmptyStr;
  1056.         } else {
  1057.             x_message = NStr::TruncateSpaces(str.substr(pos+1));
  1058.             str.erase(pos);
  1059.         }
  1061.         // Split string on parts
  1062.         NStr::Split(str, ",", tokens);
  1063.         if (tokens.size() < 2) {
  1064.             ERR_POST("Error message file parsing: Incorrect file format " 
  1065.                      ", line " + NStr::IntToString(line));
  1066.             return false;
  1067.         }
  1068.         // Mnemonic name (skip)
  1069.         tokens.pop_front();
  1071.         // Error code
  1072.         string token = NStr::TruncateSpaces(tokens.front());
  1073.         tokens.pop_front();
  1074.         x_code = NStr::StringToInt(token);
  1076.         // Severity
  1077.         if (!tokens.empty()) { 
  1078.             token = NStr::TruncateSpaces(tokens.front());
  1079.             EDiagSev sev;
  1080.             if (CNcbiDiag::StrToSeverityLevel(token.c_str(), sev)) {
  1081.                 x_severity = sev;
  1082.             } else {
  1083.                 ERR_POST(Warning << "Error message file parsing: " 
  1084.                          "Incorrect severity level in the verbose " 
  1085.                          "message file, line " + NStr::IntToString(line));
  1086.             }
  1087.         } else {
  1088.             x_severity = -1;
  1089.         }
  1090.     }
  1091.     catch (CException& e) {
  1092.         ERR_POST(Warning << "Error message file parsing: " << e.GetMsg() <<
  1093.                  ", line " + NStr::IntToString(line));
  1094.         return false;
  1095.     }
  1096.     x_ready = true;
  1097.     return true;
  1098. }
  1100.   
  1101. bool CDiagErrCodeInfo::Read(CNcbiIstream& is)
  1102. {
  1103.     string       str;                      // The line being parsed
  1104.     SIZE_TYPE    line;                     // # of the line being parsed
  1105.     bool         err_ready       = false;  // Error data ready flag 
  1106.     int          err_code        = 0;      // First level error code
  1107.     int          err_subcode     = 0;      // Second level error code
  1108.     string       err_message;              // Short message
  1109.     string       err_text;                 // Error explanation
  1110.     int          err_severity    = -1;     // Use default severity if  
  1111.                                            // has not specified
  1112.     int          err_subseverity = -1;     // Use parents severity if  
  1113.                                            // has not specified
  1115.     for (line = 1;  NcbiGetlineEOL(is, str);  line++) {
  1116.         
  1117.         // This is a comment or empty line
  1118.         if (!str.length()  ||  NStr::StartsWith(str,"#")) {
  1119.             continue;
  1120.         }
  1121.         // Add error description
  1122.         if (err_ready  &&  str[0] == '$') {
  1123.             if (err_subseverity == -1)
  1124.                 err_subseverity = err_severity;
  1125.             SetDescription(ErrCode(err_code, err_subcode), 
  1126.                 SDiagErrCodeDescription(err_message, err_text,
  1127.                                         err_subseverity));
  1128.             // Clean
  1129.             err_subseverity = -1;
  1130.             err_text     = kEmptyStr;
  1131.             err_ready    = false;
  1132.         }
  1134.         // Get error code
  1135.         if (NStr::StartsWith(str,"$$")) {
  1136.             if (!s_ParseErrCodeInfoStr(str, line, err_code, err_severity, 
  1137.                                        err_message, err_ready))
  1138.                 continue;
  1139.             err_subcode = 0;
  1140.         
  1141.         } else if (NStr::StartsWith(str,"$^")) {
  1142.         // Get error subcode
  1143.             s_ParseErrCodeInfoStr(str, line, err_subcode, err_subseverity,
  1144.                                   err_message, err_ready);
  1145.       
  1146.         } else if (err_ready) {
  1147.         // Get line of explanation message
  1148.             if (!err_text.empty()) {
  1149.                 err_text += 'n';
  1150.             }
  1151.             err_text += str;
  1152.         }
  1153.     }
  1154.     if (err_ready) {
  1155.         if (err_subseverity == -1)
  1156.             err_subseverity = err_severity;
  1157.         SetDescription(ErrCode(err_code, err_subcode), 
  1158.             SDiagErrCodeDescription(err_message, err_text,
  1159.                                     err_subseverity));
  1160.     }
  1161.     return true;
  1162. }
  1165. bool CDiagErrCodeInfo::GetDescription(const ErrCode& err_code, 
  1166.                       SDiagErrCodeDescription* description) const
  1167. {
  1168.     // Find entry
  1169.     TInfo::const_iterator find_entry = m_Info.find(err_code);
  1170.     if (find_entry == m_Info.end()) {
  1171.         return false;
  1172.     }
  1173.     // Get entry value
  1174.     const SDiagErrCodeDescription& entry = find_entry->second;
  1175.     if (description) {
  1176.         *description = entry;
  1177.     }
  1178.     return true;
  1179. }
  1182. END_NCBI_SCOPE
  1186. /*
  1187.  * ==========================================================================
  1188.  * $Log: ncbidiag.cpp,v $
  1189.  * Revision 1000.4  2004/06/01 19:08:57  gouriano
  1190.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.80
  1191.  *
  1192.  * Revision 1.80  2004/05/14 13:59:27  gorelenk
  1193.  * Added include of ncbi_pch.hpp
  1194.  *
  1195.  * Revision 1.79  2004/03/18 20:19:20  gouriano
  1196.  * make it possible to convert multi-line diagnostic message into single-line
  1197.  *
  1198.  * Revision 1.78  2003/11/12 20:30:26  ucko
  1199.  * Make extra flags for severity-trace messages tunable.
  1200.  *
  1201.  * Revision 1.77  2003/11/06 21:40:56  vakatov
  1202.  * A somewhat more natural handling of the 'eDPF_Default' flag -- replace
  1203.  * it by the current global flags, then merge these with other flags (if any)
  1204.  *
  1205.  * Revision 1.76  2003/10/31 19:38:53  lavr
  1206.  * No '' in exception reporting
  1207.  *
  1208.  * Revision 1.75  2003/09/26 15:54:13  vakatov
  1209.  * CNcbiDiag::DiagAssert() -- print everything (trace-like -- file, line, etc.)
  1210.  * in the message
  1211.  *
  1212.  * Revision 1.74  2003/09/17 15:58:29  vasilche
  1213.  * Allow debug abort when:
  1214.  * CObjectException is thrown - env var NCBI_ABORT_ON_COBJECT_THROW=[Yy1],
  1215.  * CNullPointerException is thrown - env var NCBI_ABORT_ON_NULL=[Yy1].
  1216.  * Allow quit abort in debug mode and coredump in release mode:
  1217.  * env var DIAG_SILENT_ABORT=[Yy1Nn0].
  1218.  *
  1219.  * Revision 1.73  2003/05/19 21:12:46  vakatov
  1220.  * CNcbiDiag::DiagValidate() -- get rid of "unused func arg" compilation warning
  1221.  *
  1222.  * Revision 1.72  2003/04/25 20:54:15  lavr
  1223.  * Introduce draft version of IgnoreDiagDieLevel()
  1224.  *
  1225.  * Revision 1.71  2003/03/10 18:57:08  kuznets
  1226.  * iterate->ITERATE
  1227.  *
  1228.  * Revision 1.70  2003/02/21 21:08:57  vakatov
  1229.  * Minor cast to get rid of 64-bit compilation warning
  1230.  *
  1231.  * Revision 1.69  2003/01/13 20:42:50  gouriano
  1232.  * corrected the problem with ostrstream::str(): replaced such calls with
  1233.  * CNcbiOstrstreamToString(os)
  1234.  *
  1235.  * Revision 1.68  2002/09/30 16:35:16  vasilche
  1236.  * Restored mutex lock on fork().
  1237.  *
  1238.  * Revision 1.67  2002/09/24 18:28:20  vasilche
  1239.  * Fixed behavour of CNcbiDiag::DiagValidate() in release mode
  1240.  *
  1241.  * Revision 1.66  2002/09/19 20:05:42  vasilche
  1242.  * Safe initialization of static mutexes
  1243.  *
  1244.  * Revision 1.65  2002/08/20 19:10:39  gouriano
  1245.  * added DiagWriteFlags into SDiagMessage::Write
  1246.  *
  1247.  * Revision 1.64  2002/08/16 15:02:11  ivanov
  1248.  * Added class CDiagAutoPrefix
  1249.  *
  1250.  * Revision 1.63  2002/08/01 18:47:43  ivanov
  1251.  * Added stuff to store and output error verbose messages for error codes
  1252.  *
  1253.  * Revision 1.62  2002/07/25 15:46:08  ivanov
  1254.  * Rollback R1.60
  1255.  *
  1256.  * Revision 1.61  2002/07/25 13:35:05  ivanov
  1257.  * Changed exit code of a faild test
  1258.  *
  1259.  * Revision 1.60  2002/07/15 18:17:24  gouriano
  1260.  * renamed CNcbiException and its descendents
  1261.  *
  1262.  * Revision 1.59  2002/07/10 16:19:00  ivanov
  1263.  * Added CNcbiDiag::StrToSeverityLevel().
  1264.  * Rewrite and rename SetDiagFixedStrPostLevel() -> SetDiagFixedPostLevel()
  1265.  *
  1266.  * Revision 1.58  2002/07/09 16:37:11  ivanov
  1267.  * Added GetSeverityChangeEnabledFirstTime().
  1268.  * Fix usage forced set severity post level from environment variable
  1269.  * to work without NcbiApplication::AppMain()
  1270.  *
  1271.  * Revision 1.57  2002/07/02 18:26:22  ivanov
  1272.  * Added CDiagBuffer::DisableDiagPostLevelChange()
  1273.  *
  1274.  * Revision 1.56  2002/06/27 18:56:16  gouriano
  1275.  * added "title" parameter to report functions
  1276.  *
  1277.  * Revision 1.55  2002/06/26 18:38:04  gouriano
  1278.  * added CNcbiException class
  1279.  *
  1280.  * Revision 1.54  2002/06/18 17:07:12  lavr
  1281.  * Take advantage of NStr:strftime()
  1282.  *
  1283.  * Revision 1.53  2002/05/14 16:47:27  ucko
  1284.  * Conditionalize usage of pthread_atfork, which doesn't seem to exist at
  1285.  * all on FreeBSD.
  1286.  *
  1287.  * Revision 1.52  2002/05/03 14:29:17  ucko
  1288.  * #include <unistd.h> for pthread_atfork(); the other headers do not
  1289.  * necessarily already include it.
  1290.  *
  1291.  * Revision 1.51  2002/04/25 21:49:05  ucko
  1292.  * Made pthread_atfork callbacks extern "C".
  1293.  *
  1294.  * Revision 1.50  2002/04/25 21:29:39  ucko
  1295.  * At Yan Raytselis's suggestion, use pthread_atfork to avoid
  1296.  * inadvertently holding s_DiagMutex across fork.
  1297.  *
  1298.  * Revision 1.49  2002/04/23 19:57:29  vakatov
  1299.  * Made the whole CNcbiDiag class "mutable" -- it helps eliminate
  1300.  * numerous warnings issued by SUN Forte6U2 compiler.
  1301.  * Do not use #NO_INCLASS_TMPL anymore -- apparently all modern
  1302.  * compilers seem to be supporting in-class template methods.
  1303.  *
  1304.  * Revision 1.48  2002/04/16 18:48:42  ivanov
  1305.  * SuppressDiagPopupMessages() moved to "test/test_assert.h"
  1306.  *
  1307.  * Revision 1.47  2002/04/11 19:58:34  ivanov
  1308.  * Added function SuppressDiagPopupMessages()
  1309.  *
  1310.  * Revision 1.46  2002/04/10 14:45:27  ivanov
  1311.  * Abort() moved from static to extern and added to header file
  1312.  *
  1313.  * Revision 1.45  2002/04/01 22:35:22  ivanov
  1314.  * Added SetAbortHandler() function to set user abort handler.
  1315.  * Used call internal function Abort() vice ::abort().
  1316.  *
  1317.  * Revision 1.44  2002/02/07 19:45:54  ucko
  1318.  * Optionally transfer ownership in GetDiagHandler.
  1319.  *
  1320.  * Revision 1.43  2002/02/05 22:01:36  lavr
  1321.  * Minor tweak
  1322.  *
  1323.  * Revision 1.42  2002/01/12 22:16:47  lavr
  1324.  * Eliminated GCC warning: "'%D' yields only 2 digits of year"
  1325.  *
  1326.  * Revision 1.41  2001/12/07 15:27:28  ucko
  1327.  * Switch CDiagRecycler over to current form of SetDiagHandler.
  1328.  *
  1329.  * Revision 1.40  2001/12/03 22:06:31  juran
  1330.  * Use 'special environment' flag to indicate that a fatal error
  1331.  * must throw an exception rather than abort.  (Mac only.)
  1332.  *
  1333.  * Revision 1.39  2001/11/14 15:15:00  ucko
  1334.  * Revise diagnostic handling to be more object-oriented.
  1335.  *
  1336.  * Revision 1.38  2001/10/29 15:16:13  ucko
  1337.  * Preserve default CGI diagnostic settings, even if customized by app.
  1338.  *
  1339.  * Revision 1.37  2001/10/16 23:44:07  vakatov
  1340.  * + SetDiagPostAllFlags()
  1341.  *
  1342.  * Revision 1.36  2001/08/24 13:48:01  grichenk
  1343.  * Prevented some memory leaks
  1344.  *
  1345.  * Revision 1.35  2001/08/09 16:26:11  lavr
  1346.  * Added handling for new eDPF_OmitInfoSev format flag
  1347.  *
  1348.  * Revision 1.34  2001/07/30 14:42:10  lavr
  1349.  * eDiag_Trace and eDiag_Fatal always print as much as possible
  1350.  *
  1351.  * Revision 1.33  2001/07/26 21:29:00  lavr
  1352.  * Remove printing DateTime stamp by default
  1353.  *
  1354.  * Revision 1.32  2001/07/25 19:13:55  lavr
  1355.  * Added date/time stamp for message logging
  1356.  *
  1357.  * Revision 1.31  2001/06/13 23:19:38  vakatov
  1358.  * Revamped previous revision (prefix and error codes)
  1359.  *
  1360.  * Revision 1.30  2001/06/13 20:48:28  ivanov
  1361.  * + PushDiagPostPrefix(), PopPushDiagPostPrefix() - stack post prefix messages.
  1362.  * + ERR_POST_EX, LOG_POST_EX - macros for posting with error codes.
  1363.  * + ErrCode(code[,subcode]) - CNcbiDiag error code manipulator.
  1364.  * + eDPF_ErrCode, eDPF_ErrSubCode - new post flags.
  1365.  *
  1366.  * Revision 1.29  2001/06/05 20:58:16  vakatov
  1367.  * ~CDiagBuffer()::  to check for consistency and call "abort()" only
  1368.  * #if (_DEBUG > 1)
  1369.  *
  1370.  * Revision 1.28  2001/05/17 15:04:59  lavr
  1371.  * Typos corrected
  1372.  *
  1373.  * Revision 1.27  2001/03/30 22:49:22  grichenk
  1374.  * KCC freeze() bug workaround
  1375.  *
  1376.  * Revision 1.26  2001/03/26 21:45:54  vakatov
  1377.  * Made MT-safe (with A.Grichenko)
  1378.  *
  1379.  * Revision 1.25  2001/01/23 23:20:42  lavr
  1380.  * MSVS++ -> MSVC++
  1381.  *
  1382.  * Revision 1.24  2000/11/16 23:52:41  vakatov
  1383.  * Porting to Mac...
  1384.  *
  1385.  * Revision 1.23  2000/10/24 21:51:21  vakatov
  1386.  * [DEBUG] By default, do not print file name and line into the diagnostics
  1387.  *
  1388.  * Revision 1.22  2000/10/24 19:54:46  vakatov
  1389.  * Diagnostics to go to CERR by default (was -- disabled by default)
  1390.  *
  1391.  * Revision 1.21  2000/06/22 22:09:10  vakatov
  1392.  * Fixed:  GetTraceEnabledFirstTime(), sm_TraceDefault
  1393.  *
  1394.  * Revision 1.20  2000/06/11 01:47:28  vakatov
  1395.  * IsDiagSet(0) to return TRUE if the diag stream is unset
  1396.  *
  1397.  * Revision 1.19  2000/06/09 21:22:21  vakatov
  1398.  * IsDiagStream() -- fixed
  1399.  *
  1400.  * Revision 1.18  2000/04/04 22:31:59  vakatov
  1401.  * SetDiagTrace() -- auto-set basing on the application
  1402.  * environment and/or registry
  1403.  *
  1404.  * Revision 1.17  2000/02/18 16:54:07  vakatov
  1405.  * + eDiag_Critical
  1406.  *
  1407.  * Revision 1.16  2000/01/20 16:52:32  vakatov
  1408.  * SDiagMessage::Write() to replace SDiagMessage::Compose()
  1409.  * + operator<<(CNcbiOstream& os, const SDiagMessage& mess)
  1410.  * + IsSetDiagHandler(), IsDiagStream()
  1411.  *
  1412.  * Revision 1.15  1999/12/29 22:30:25  vakatov
  1413.  * Use "exit()" rather than "abort()" in non-#_DEBUG mode
  1414.  *
  1415.  * Revision 1.14  1999/12/29 21:22:30  vakatov
  1416.  * Fixed "delete" to "delete[]"
  1417.  *
  1418.  * Revision 1.13  1999/12/27 19:44:18  vakatov
  1419.  * Fixes for R1.13:
  1420.  * ERR_POST() -- use eDPF_Default rather than eDPF_Trace;  forcibly flush
  1421.  * ("<< Endm") the diag. stream. Get rid of the eDPF_CopyFilename, always
  1422.  * make a copy of the file name.
  1423.  *
  1424.  * Revision 1.12  1999/12/16 17:22:51  vakatov
  1425.  * Fixed "delete" to "delete[]"
  1426.  *
  1427.  * Revision 1.11  1999/09/27 16:23:23  vasilche
  1428.  * Changed implementation of debugging macros (_TRACE, _THROW*, _ASSERT etc),
  1429.  * so that they will be much easier for compilers to eat.
  1430.  *
  1431.  * Revision 1.10  1999/05/27 16:32:26  vakatov
  1432.  * In debug-mode(#_DEBUG), set the default post severity level to
  1433.  * "Warning" (yet, it is "Error" in non-debug mode)
  1434.  *
  1435.  * Revision 1.9  1999/04/30 19:21:04  vakatov
  1436.  * Added more details and more control on the diagnostics
  1437.  * See #ERR_POST, EDiagPostFlag, and ***DiagPostFlag()
  1438.  *
  1439.  * Revision 1.8  1998/12/28 17:56:37  vakatov
  1440.  * New CVS and development tree structure for the NCBI C++ projects
  1441.  *
  1442.  * Revision 1.7  1998/11/06 22:42:41  vakatov
  1443.  * Introduced BEGIN_, END_ and USING_ NCBI_SCOPE macros to put NCBI C++
  1444.  * API to namespace "ncbi::" and to use it by default, respectively
  1445.  * Introduced THROWS_NONE and THROWS(x) macros for the exception
  1446.  * specifications
  1447.  * Other fixes and rearrangements throughout the most of "corelib" code
  1448.  *
  1449.  * Revision 1.6  1998/11/03 22:57:51  vakatov
  1450.  * Use #define'd manipulators(like "NcbiFlush" instead of "flush") to
  1451.  * make it compile and work with new(templated) version of C++ streams
  1452.  *
  1453.  * Revision 1.4  1998/11/03 22:28:35  vakatov
  1454.  * Renamed Die/Post...Severity() to ...Level()
  1455.  *
  1456.  * Revision 1.3  1998/11/03 20:51:26  vakatov
  1457.  * Adaptation for the SunPro compiler glitchs(see conf. #NO_INCLASS_TMPL)
  1458.  *
  1459.  * Revision 1.2  1998/10/30 20:08:37  vakatov
  1460.  * Fixes to (first-time) compile and test-run on MSVC++
  1461.  *
  1462.  * ==========================================================================
  1463.  */