File: list.c

package info (click to toggle)
clzip 1.11-5
  • links: PTS, VCS
  • area: main
  • in suites: bullseye, sid
  • size: 536 kB
  • sloc: ansic: 3,986; sh: 503; makefile: 118
file content (123 lines) | stat: -rw-r--r-- 4,417 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
/*  Clzip - LZMA lossless data compressor
    Copyright (C) 2010-2019 Antonio Diaz Diaz.

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#define _FILE_OFFSET_BITS 64

#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <unistd.h>
#include <sys/stat.h>

#include "lzip.h"
#include "lzip_index.h"


static void list_line( const unsigned long long uncomp_size,
                       const unsigned long long comp_size,
                       const char * const input_filename )
  {
  if( uncomp_size > 0 )
    printf( "%15llu %15llu %6.2f%%  %s\n", uncomp_size, comp_size,
            100.0 - ( ( 100.0 * comp_size ) / uncomp_size ),
            input_filename );
  else
    printf( "%15llu %15llu   -INF%%  %s\n", uncomp_size, comp_size,
            input_filename );
  }


int list_files( const char * const filenames[], const int num_filenames,
                const bool ignore_trailing, const bool loose_trailing )
  {
  unsigned long long total_comp = 0, total_uncomp = 0;
  int files = 0, retval = 0;
  int i;
  bool first_post = true;
  bool stdin_used = false;
  for( i = 0; i < num_filenames; ++i )
    {
    const char * input_filename;
    struct Lzip_index lzip_index;
    struct stat in_stats;				/* not used */
    int infd;
    const bool from_stdin = ( strcmp( filenames[i], "-" ) == 0 );
    if( from_stdin ) { if( stdin_used ) continue; else stdin_used = true; }
    input_filename = from_stdin ? "(stdin)" : filenames[i];
    infd = from_stdin ? STDIN_FILENO :
      open_instream( input_filename, &in_stats, true, true );
    if( infd < 0 ) { if( retval < 1 ) retval = 1; continue; }

    Li_init( &lzip_index, infd, ignore_trailing, loose_trailing );
    close( infd );
    if( lzip_index.retval != 0 )
      {
      show_file_error( input_filename, lzip_index.error, 0 );
      if( retval < lzip_index.retval ) retval = lzip_index.retval;
      Li_free( &lzip_index ); continue;
      }
    if( verbosity >= 0 )
      {
      const unsigned long long udata_size = Li_udata_size( &lzip_index );
      const unsigned long long cdata_size = Li_cdata_size( &lzip_index );
      total_comp += cdata_size; total_uncomp += udata_size; ++files;
      if( first_post )
        {
        first_post = false;
        if( verbosity >= 1 ) fputs( "   dict   memb  trail ", stdout );
        fputs( "   uncompressed      compressed   saved  name\n", stdout );
        }
      if( verbosity >= 1 )
        {
        long long trailing_size;
        unsigned dictionary_size = 0;
        long i;
        for( i = 0; i < lzip_index.members; ++i )
          dictionary_size =
            max( dictionary_size, Li_dictionary_size( &lzip_index, i ) );
        trailing_size = Li_file_size( &lzip_index ) - cdata_size;
        printf( "%s %5ld %6lld ", format_ds( dictionary_size ),
                lzip_index.members, trailing_size );
        }
      list_line( udata_size, cdata_size, input_filename );

      if( verbosity >= 2 && lzip_index.members > 1 )
        {
        long i;
        fputs( " member      data_pos       data_size      member_pos     member_size\n", stdout );
        for( i = 0; i < lzip_index.members; ++i )
          {
          const struct Block * db = Li_dblock( &lzip_index, i );
          const struct Block * mb = Li_mblock( &lzip_index, i );
          printf( "%5ld %15llu %15llu %15llu %15llu\n",
                  i + 1, db->pos, db->size, mb->pos, mb->size );
          }
        first_post = true;	/* reprint heading after list of members */
        }
      fflush( stdout );
      }
    Li_free( &lzip_index );
    }
  if( verbosity >= 0 && files > 1 )
    {
    if( verbosity >= 1 ) fputs( "                      ", stdout );
    list_line( total_uncomp, total_comp, "(totals)" );
    fflush( stdout );
    }
  return retval;
  }