Branch data     Line data    Source code

       1                 :             : #include "precizer.h"
       2                 :             : 
       3                 :             : /**
       4                 :             :  * @brief Retrieve a const pointer to a flag descriptor by index.
       5                 :             :  *
       6                 :             :  * Uses the mem helper to obtain a typed readonly view of the @ref Flags array and
       7                 :             :  * performs bounds checking. Returns NULL if the descriptor is missing, type
       8                 :             :  * verification fails, or the index is out of range.
       9                 :             :  */
      10                 :           8 : static const Flags *lookup(
      11                 :             :         const memory *flags,
      12                 :             :         size_t       index)
      13                 :             : {
      14                 :           8 :         const Flags *flags_data = cdata(Flags,flags);
      15                 :             : 
      16   [ +  -  -  + ]:           8 :         if(flags_data == NULL || index >= flags->length)
      17                 :             :         {
      18                 :           0 :                 return(NULL);
      19                 :             :         }
      20                 :             : 
      21                 :           8 :         return(&flags_data[index]);
      22                 :             : }
      23                 :             : 
      24                 :           2 : Return show_difference(
      25                 :             :         Changed         change_flags_mask,
      26                 :             :         const CmpctStat *before,
      27                 :             :         const CmpctStat *after)
      28                 :             : {
      29                 :             :         /* Validate input parameters */
      30   [ +  -  -  + ]:           2 :         if(NULL == before || NULL == after)
      31                 :             :         {
      32                 :           0 :                 return(FAILURE);
      33                 :             :         }
      34                 :             : 
      35         [ -  + ]:           2 :         if(change_flags_mask == IDENTICAL)
      36                 :             :         {
      37                 :           0 :                 return(SUCCESS);
      38                 :             :         }
      39                 :             : 
      40                 :             :         /* Status returned by this function through provide()
      41                 :             :            Default value assumes successful completion */
      42                 :           2 :         Return status = SUCCESS;
      43                 :             : 
      44                 :           2 :         create(Flags,flags);
      45   [ -  +  -  + ]:           2 :         call(resize(flags,4));
      46                 :             : 
      47                 :           2 :         Flags *flags_data = data(Flags,flags);
      48                 :             : 
      49         [ -  + ]:           2 :         if(flags_data == NULL)
      50                 :             :         {
      51                 :           0 :                 del(flags);
      52                 :           0 :                 provide(FAILURE);
      53                 :             :         }
      54                 :             : 
      55                 :           2 :         flags_data[0] = (Flags){SIZE_CHANGED,"lsize"};
      56                 :           2 :         flags_data[1] = (Flags){ALLOCATED_SIZE_CHANGED,"asize"};
      57                 :           2 :         flags_data[2] = (Flags){STATUS_CHANGED_TIME,"ctime"};
      58                 :           2 :         flags_data[3] = (Flags){MODIFICATION_TIME_CHANGED,"mtime"};
      59                 :             : 
      60                 :           2 :         unsigned int flags_found = 0;
      61                 :           2 :         bool first_word = true;
      62                 :             : 
      63                 :             :         /* Check each flag */
      64         [ +  + ]:          10 :         for(size_t i = 0; i < flags->length; i++)
      65                 :             :         {
      66                 :           8 :                 const Flags *flag = lookup(flags,i);
      67                 :             : 
      68         [ -  + ]:           8 :                 if(flag == NULL)
      69                 :             :                 {
      70                 :           0 :                         break;
      71                 :             :                 }
      72                 :             : 
      73         [ +  + ]:           8 :                 if(((unsigned int)change_flags_mask & (unsigned int)flag->flag_value) != 0u)
      74                 :             :                 {
      75         [ +  + ]:           4 :                         if(first_word == true)
      76                 :             :                         {
      77                 :           2 :                                 slog(ERROR,"Database file details: ");
      78                 :           2 :                                 first_word = false;
      79                 :             :                         }
      80                 :             : 
      81                 :             :                         /* Add separator if not the first flag */
      82         [ +  + ]:           4 :                         if(flags_found > 0)
      83                 :             :                         {
      84                 :           2 :                                 slog(ERROR|UNDECOR," & ");
      85                 :             :                         }
      86                 :           4 :                         slog(ERROR|UNDECOR,"%s",flag->flag_name);
      87                 :           4 :                         show_metadata(ERROR,flag->flag_value,before,after);
      88                 :           4 :                         flags_found++;
      89                 :             :                 }
      90                 :             :         }
      91                 :             : 
      92         [ +  - ]:           2 :         if(flags_found > 0)
      93                 :             :         {
      94                 :           2 :                 slog(ERROR|UNDECOR,"\n");
      95                 :             :         }
      96                 :             : 
      97                 :           2 :         del(flags);
      98                 :             : 
      99                 :           2 :         provide(SUCCESS);
     100                 :             : }