LCOV - code coverage report
Current view: top level - src - ichierr.c (source / functions) Coverage Total Hit
Test: InChI Unit Test Coverage Lines: 41.8 % 67 28
Test Date: 2026-10-14 12:14:55 Functions: 66.7 % 3 2
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 42.0 % 69 29

             Branch data     Line data    Source code
       1                 :             : /*
       2                 :             :  * SPDX-License-Identifier: MIT
       3                 :             :  * Copyright (c) 2024 IUPAC and InChI Trust
       4                 :             :  */
       5                 :             : 
       6                 :             : #pragma warning( disable : 4706 4127 4514 4100 4786 4996 4244 4267 )
       7                 :             : 
       8                 :             : #include <string.h>
       9                 :             : 
      10                 :             : #include "mode.h"
      11                 :             : #include "ichierr.h"
      12                 :             : 
      13                 :             : #include "bcf_s.h"
      14                 :             : 
      15                 :             : static int already_have_this_message( char *prev_messages, const char *new_message );
      16                 :             : 
      17                 :             : 
      18                 :             : /****************************************************************************/
      19                 :           0 : const char *ErrMsg( int nErrorCode )
      20                 :             : {
      21                 :             :     const char *p;
      22                 :             :     static char szErrMsg[64];
      23   [ #  #  #  #  :           0 :     switch (nErrorCode)
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                      # ]
      24                 :             :     {
      25                 :           0 :         case 0:                      p = "";                      break;
      26                 :           0 :         case CT_OVERFLOW:            p = "ARRAY OVERFLOW";        break;
      27                 :           0 :         case CT_LEN_MISMATCH:        p = "LENGTH_MISMATCH";       break;
      28                 :           0 :         case CT_OUT_OF_RAM:          p = "Out of RAM";            break;
      29                 :           0 :         case CT_RANKING_ERR:         p = "RANKING_ERR";           break;
      30                 :           0 :         case CT_ISOCOUNT_ERR:        p = "ISOCOUNT_ERR";          break;
      31                 :           0 :         case CT_TAUCOUNT_ERR:        p = "TAUCOUNT_ERR";          break;
      32                 :           0 :         case CT_ISOTAUCOUNT_ERR:     p = "ISOTAUCOUNT_ERR";       break;
      33                 :           0 :         case CT_MAPCOUNT_ERR:        p = "MAPCOUNT_ERR";          break;
      34                 :           0 :         case CT_TIMEOUT_ERR:         p = "Time limit exceeded";   break;
      35                 :           0 :         case CT_ISO_H_ERR:           p = "ISO_H_ERR";             break;
      36                 :           0 :         case CT_STEREOCOUNT_ERR:     p = "STEREOCOUNT_ERR";       break;
      37                 :           0 :         case CT_ATOMCOUNT_ERR:       p = "ATOMCOUNT_ERR";         break;
      38                 :           0 :         case CT_STEREOBOND_ERROR:    p = "STEREOBOND_ERR";        break;
      39                 :           0 :         case CT_USER_QUIT_ERR:       p = "User requested termination"; break;
      40                 :           0 :         case CT_REMOVE_STEREO_ERR:   p = "REMOVE_STEREO_ERR";     break;
      41                 :           0 :         case CT_CALC_STEREO_ERR:     p = "CALC_STEREO_ERR";       break;
      42                 :           0 :         case CT_STEREO_CANON_ERR:    p = "STEREO_CANON_ERR";      break;
      43                 :           0 :         case CT_CANON_ERR:           p = "CANON_ERR";             break;
      44                 :           0 :         case CT_WRONG_FORMULA:       p = "Wrong or missing chemical formula";  break;
      45                 :             :         /*case CT_CANON_ERR2:          p = "CT_CANON_ERR2";         break;*/
      46                 :           0 :         case CT_UNKNOWN_ERR:         p = "UNKNOWN_ERR";           break;
      47                 :           0 :         case BNS_RADICAL_ERR:        p = "Cannot process free radical center"; break;
      48                 :           0 :         case BNS_ALTBOND_ERR:        p = "Cannot process aromatic bonds";      break;
      49                 :             :         /* v. 1.05 */
      50                 :           0 :         case BNS_TIMEOUT:             p = "Structure normalization timeout";      break;
      51                 :             : 
      52                 :           0 :         default:
      53         [ #  # ]:           0 :             if (nErrorCode > CT_UNKNOWN_ERR)
      54                 :             :             {
      55                 :           0 :                 sprintf(szErrMsg, "No description(%d)", nErrorCode);
      56                 :           0 :                 p = szErrMsg;
      57                 :             :             }
      58                 :             :             else
      59                 :             :             {
      60                 :           0 :                 sprintf(szErrMsg, "UNKNOWN_ERR(%d)", CT_UNKNOWN_ERR - nErrorCode);
      61                 :           0 :                 p = szErrMsg;
      62                 :             :             }
      63                 :           0 :             break;
      64                 :             :     }
      65                 :             : 
      66                 :           0 :     return p;
      67                 :             : }
      68                 :             : 
      69                 :             : 
      70                 :             : /****************************************************************************/
      71                 :         111 : int AddErrorMessage( char *all_messages, const char *new_message )
      72                 :             : {
      73                 :             :     int len_all, len;
      74                 :             : 
      75         [ -  + ]:         111 :     if (!all_messages)
      76                 :             :     {
      77                 :           0 :         return 0;
      78                 :             :     }
      79         [ -  + ]:         111 :     if (!new_message)
      80                 :             :     {
      81                 :           0 :         return 0;
      82                 :             :     }
      83         [ -  + ]:         111 :     if (!new_message[0])
      84                 :             :     {
      85                 :           0 :         return 0;
      86                 :             :     }
      87         [ +  + ]:         111 :     if (already_have_this_message( all_messages, new_message ))
      88                 :             :     {
      89                 :          42 :         return 1;
      90                 :             :     }
      91                 :             : 
      92                 :          69 :     len_all = (int) strlen( all_messages );
      93                 :          69 :     len = (int) strlen( new_message );
      94                 :             : 
      95   [ +  +  +  + ]:          69 :     if (len_all + len + 2 * ( len_all > 0 ) < STR_ERR_LEN)
      96                 :             :     {
      97                 :             :         /* enough room... add message and return */
      98         [ +  + ]:          42 :         if (len_all > 0)
      99                 :             :         {
     100         [ +  + ]:          17 :             if (all_messages[len_all - 1] != ':')
     101                 :             :             {
     102                 :          14 :                 strcat(all_messages, ";");
     103                 :             :             }
     104                 :          17 :             strcat(all_messages, " ");
     105                 :             :         }
     106                 :          42 :         strcat(all_messages, new_message);
     107                 :          42 :         return 1;
     108                 :             :     }
     109                 :             : 
     110                 :             :     /*  not enough room... add no-room marker if not yet added */
     111         [ -  + ]:          27 :     if (strstr( all_messages, "..." ))
     112                 :             :     {
     113                 :           0 :         return 0;
     114                 :             :     }
     115         [ -  + ]:          27 :     if (len_all + 3 < STR_ERR_LEN)
     116                 :             :     {
     117                 :           0 :         strcat(all_messages, "...");
     118                 :             :     }
     119                 :             : 
     120                 :          27 :     return 0;
     121                 :             : }
     122                 :             : 
     123                 :             : 
     124                 :             : /****************************************************************************/
     125                 :         111 : int already_have_this_message( char *prev_messages, const char *new_message )
     126                 :             : {
     127                 :         111 :     int have = 0;
     128                 :             : 
     129                 :         111 :     char *p = strstr( prev_messages, new_message );
     130                 :             : 
     131         [ +  + ]:         111 :     if (p)
     132                 :             :     {
     133   [ +  +  +  -  :          42 :         have = ( p == prev_messages || (*( p - 1 ) == ' ' && ( *( p - 2 ) == ';' || *( p - 2 ) == ':' )) ); /* djb-rwth: addressing LLVM warning */
             +  +  +  - ]
     134         [ +  - ]:          42 :         if (have)
     135                 :             :         {
     136                 :          42 :             int len_prev = (int) strlen( prev_messages );
     137                 :          42 :             int len = (int) strlen( new_message );
     138   [ +  +  -  +  :          42 :             have = ( p + len == prev_messages + len_prev || (p[len] == ';' && p[len + 1] == ' ') || (p[len - 1] == ':' && p[len] == ' ') ); /* djb-rwth: addressing LLVM warning */
          -  -  +  -  +  
                      - ]
     139                 :             :         }
     140                 :             :     }
     141                 :             : 
     142                 :         111 :     return have;
     143                 :             : }
        

Generated by: LCOV version 2.0-1