CoCalc -- mkhelp.pl

GitHub Repository: freebsd/pkg
Path: blob/main/external/curl/src/mkhelp.pl
²⁰⁶⁵ views
1
#!/usr/bin/env perl
2
#***************************************************************************
3
#                                  _   _ ____  _
4
#  Project                     ___| | | |  _ \| |
5
#                             / __| | | | |_) | |
6
#                            | (__| |_| |  _ <| |___
7
#                             \___|\___/|_| \_\_____|
8
#
9
# Copyright (C) Daniel Stenberg, <[email protected]>, et al.
10
#
11
# This software is licensed as described in the file COPYING, which
12
# you should have received as part of this distribution. The terms
13
# are also available at https://curl.se/docs/copyright.html.
14
#
15
# You may opt to use, copy, modify, merge, publish, distribute and/or sell
16
# copies of the Software, and permit persons to whom the Software is
17
# furnished to do so, under the terms of the COPYING file.
18
#
19
# This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
20
# KIND, either express or implied.
21
#
22
# SPDX-License-Identifier: curl
23
#
24
###########################################################################
25

26
if($ARGV[0] eq "-c") {
27
    $c=1;
28
    shift @ARGV;
29
}
30

31
push @out, "          _   _ ____  _\n";
32
push @out, "      ___| | | |  _ \\| |\n";
33
push @out, "     / __| | | | |_) | |\n";
34
push @out, "    | (__| |_| |  _ <| |___\n";
35
push @out, "     \\___|\\___/|_| \\_\\_____|\n";
36

37
while (<STDIN>) {
38
    my $line = $_;
39
    push @out, $line;
40
}
41

42
print <<HEAD
43
/*
44
 * NEVER EVER edit this manually, fix the mkhelp.pl script instead!
45
 */
46
#include "tool_hugehelp.h"
47
#ifdef USE_MANUAL
48
#include "tool_help.h"
49

50
HEAD
51
    ;
52
if($c) {
53
    # If compression requested, check that the Gzip module is available
54
    # or else disable compression
55
    $c = eval
56
    {
57
      require IO::Compress::Gzip;
58
      IO::Compress::Gzip->import();
59
      1;
60
    };
61
    print STDERR "Warning: compression requested but Gzip is not available\n" if (!$c)
62
}
63

64
if($c)
65
{
66
    my $content = join("", @out);
67
    my $gzippedContent;
68
    IO::Compress::Gzip::gzip(
69
        \$content, \$gzippedContent, Level => 9, TextFlag => 1, Time=>0) or die "gzip failed:";
70
    $gzip = length($content);
71
    $gzipped = length($gzippedContent);
72

73
    print <<HEAD
74
#include <zlib.h>
75
#include <memdebug.h> /* keep this as LAST include */
76
static const unsigned char hugehelpgz[] = {
77
  /* This mumbo-jumbo is the huge help text compressed with gzip.
78
     Thanks to this operation, the size of this data shrank from $gzip
79
     to $gzipped bytes. You can disable the use of compressed help
80
     texts by NOT passing -c to the mkhelp.pl tool. */
81
HEAD
82
;
83

84
    my $c=0;
85
    for(split(//, $gzippedContent)) {
86
        my $num=ord($_);
87
        if(!($c % 12)) {
88
            print " ";
89
        }
90
        printf(" 0x%02x,", 0+$num);
91
        if(!(++$c % 12)) {
92
            print "\n";
93
        }
94
    }
95
    print "\n};\n";
96

97
    print <<EOF
98
#define BUF_SIZE 0x10000
99
static voidpf zalloc_func(voidpf opaque, unsigned int items, unsigned int size)
100
{
101
  (void) opaque;
102
  /* not a typo, keep it calloc() */
103
  return (voidpf) calloc(items, size);
104
}
105
static void zfree_func(voidpf opaque, voidpf ptr)
106
{
107
  (void) opaque;
108
  free(ptr);
109
}
110

111
#define HEADERLEN 10
112

113
/* Decompress and send to stdout a gzip-compressed buffer */
114
void hugehelp(void)
115
{
116
  unsigned char *buf;
117
  int status;
118
  z_stream z;
119

120
  /* Make sure no gzip options are set */
121
  if(hugehelpgz[3] & 0xfe)
122
    return;
123

124
  memset(&z, 0, sizeof(z_stream));
125
  z.zalloc = (alloc_func)zalloc_func;
126
  z.zfree = (free_func)zfree_func;
127
  z.avail_in = (uInt)(sizeof(hugehelpgz) - HEADERLEN);
128
  z.next_in = (z_const Bytef *)hugehelpgz + HEADERLEN;
129

130
  if(inflateInit2(&z, -MAX_WBITS) != Z_OK)
131
    return;
132

133
  buf = malloc(BUF_SIZE);
134
  if(buf) {
135
    while(1) {
136
      z.avail_out = BUF_SIZE;
137
      z.next_out = buf;
138
      status = inflate(&z, Z_SYNC_FLUSH);
139
      if(status == Z_OK || status == Z_STREAM_END) {
140
        fwrite(buf, BUF_SIZE - z.avail_out, 1, stdout);
141
        if(status == Z_STREAM_END)
142
          break;
143
      }
144
      else
145
        break;    /* error */
146
    }
147
    free(buf);
148
  }
149
  inflateEnd(&z);
150
}
151
/* Show the help text for the 'arg' curl argument on stdout */
152
void showhelp(const char *trigger, const char *arg, const char *endarg)
153
{
154
  unsigned char *buf;
155
  int status;
156
  z_stream z;
157
  struct scan_ctx ctx;
158
  inithelpscan(&ctx, trigger, arg, endarg);
159

160
  /* Make sure no gzip options are set */
161
  if(hugehelpgz[3] & 0xfe)
162
    return;
163

164
  memset(&z, 0, sizeof(z_stream));
165
  z.zalloc = (alloc_func)zalloc_func;
166
  z.zfree = (free_func)zfree_func;
167
  z.avail_in = (uInt)(sizeof(hugehelpgz) - HEADERLEN);
168
  z.next_in = (z_const Bytef *)hugehelpgz + HEADERLEN;
169

170
  if(inflateInit2(&z, -MAX_WBITS) != Z_OK)
171
    return;
172

173
  buf = malloc(BUF_SIZE);
174
  if(buf) {
175
    while(1) {
176
      z.avail_out = BUF_SIZE;
177
      z.next_out = buf;
178
      status = inflate(&z, Z_SYNC_FLUSH);
179
      if(status == Z_OK || status == Z_STREAM_END) {
180
        size_t len = BUF_SIZE - z.avail_out;
181
        if(!helpscan(buf, len, &ctx))
182
          break;
183
        if(status == Z_STREAM_END)
184
          break;
185
      }
186
      else
187
        break;    /* error */
188
    }
189
    free(buf);
190
  }
191
  inflateEnd(&z);
192
}
193
EOF
194
    ;
195
foot();
196
exit;
197
}
198
else {
199
    print <<HEAD
200
static const char * const curlman[] = {
201
HEAD
202
        ;
203
}
204

205
my $blank;
206
for my $n (@out) {
207
    chomp $n;
208
    $n =~ s/\\/\\\\/g;
209
    $n =~ s/\"/\\\"/g;
210
    $n =~ s/\t/\\t/g;
211

212
    if(!$n) {
213
        $blank++;
214
    }
215
    else {
216
        $n =~ s/        /\\t/g;
217
        printf("  \"%s%s\",\n", $blank?"\\n":"", $n);
218
        $blank = 0;
219
    }
220
}
221

222
print <<ENDLINE
223
  NULL
224
};
225
void hugehelp(void)
226
{
227
  int i = 0;
228
  while(curlman[i])
229
    puts(curlman[i++]);
230
}
231

232
/* Show the help text for the 'arg' curl argument on stdout */
233
void showhelp(const char *trigger, const char *arg, const char *endarg)
234
{
235
  int i = 0;
236
  struct scan_ctx ctx;
237
  inithelpscan(&ctx, trigger, arg, endarg);
238
  while(curlman[i]) {
239
    size_t len = strlen(curlman[i]);
240
    if(!helpscan((const unsigned char *)curlman[i], len, &ctx) ||
241
       !helpscan((const unsigned char *)"\\n", 1, &ctx))
242
      break;
243
    i++;
244
  }
245
}
246
ENDLINE
247
    ;
248

249
foot();
250

251
sub foot {
252
    print <<FOOT
253
#endif /* USE_MANUAL */
254
FOOT
255
  ;
256
}
257

258
Product

Resources

Company
