curl/src/mkhelp.pl

#!/usr/local/bin/perl

# Yeah, I know, probably 1000 other persons already wrote a script like
# this, but I'll tell ya:

# THEY DON'T FIT ME :-)

# Get readme file as parameter:

if($ARGV[0] eq "-c") {
    $c=1;
    shift @ARGV;
}

my $README = $ARGV[0];

if($README eq "") {
    print "usage: mkreadme.pl [-c] <README> < manpage\n";
    exit;
}


push @out, "                                  _   _ ____  _     \n";
push @out, "  Project                     ___| | | |  _ \\| |    \n";
push @out, "                             / __| | | | |_) | |    \n";
push @out, "                            | (__| |_| |  _ <| |___ \n";
push @out, "                             \\___|\\___/|_| \\_\\_____|\n";

my $olen=0;
while (<STDIN>) {
    my $line = $_;

    # this should be removed:
    $line =~ s/(.|_)//g;

    if($line =~ /^([ \t]*\n|curl)/i) {
        # cut off headers and empty lines
	$wline++; # count number of cut off lines
	next;
    }

    my $text = $line;
    $text =~ s/^\s+//g; # cut off preceeding...
    $text =~ s/\s+$//g; # and trailing whitespaces

    $tlen = length($text);

    if($wline && ($olen == $tlen)) {
        # if the previous line with contents was exactly as long as
        # this line, then we ignore the newlines!

        # We do this magic because a header may abort a paragraph at
        # any line, but we don't want that to be noticed in the output
        # here
        $wline=0;
    }
    $olen = $tlen;

    if($wline) {
	# we only make one empty line max
	$wline = 0;
        push @out, "\n";
    }
    push @out, $line;
}
push @out, "\n"; # just an extra newline

open(READ, "<$README") ||
    die "couldn't read the README infile $README";

while(<READ>) {
    push @out, $_;
}
close(READ);

# if compressed
if($c) {
    my @test = `gzip --version 2>&1`;
    if($test[0] =~ /gzip/) {
        open(GZIP, ">dumpit") ||
            die "can't create the dumpit file, try without -c";
        binmode GZIP;
        for(@out) {
            print GZIP $_;
            $gzip += length($_);
        }
        close(GZIP);

        system("gzip --best --no-name dumpit");
        
        open(GZIP, "<dumpit.gz") ||
             die "can't read the dumpit.gz file, try without -c";
        binmode GZIP;
        while(<GZIP>) {
            push @gzip, $_;
            $gzipped += length($_);
        }
        close(GZIP);

        unlink("dumpit.gz");
    }
    else {
        # no gzip, no compression!
        undef $c;
        print STDERR "MEEEP: Couldn't find gzip, disable compression\n";
    }
}

$now = localtime;
print <<HEAD
/*
 * NEVER EVER edit this manually, fix the mkhelp.pl script instead!
 * Generation time: $now
 */
#include "setup.h"
#ifdef USE_MANUAL
#include "hugehelp.h"
#include <stdio.h>
HEAD
    ;
if($c) {
    print <<HEAD
#include <zlib.h>
static const unsigned char hugehelpgz[] = {
  /* This mumbo-jumbo is the huge help text compressed with gzip.
     Thanks to this operation, the size of this data shrunk from $gzip
     to $gzipped bytes. You can disable the use of compressed help
     texts by NOT passing -c to the mkhelp.pl tool. */
HEAD
;
    my $c=0;
    print "  ";
    for(@gzip) {
        my @all=split(//, $_);
        for(@all) {
            my $num=ord($_);
            printf("0x%02x, ", 0+$num);
            if(++$c>11) {
                print "\n  ";
                $c=0;
            }
        }
    }
    print "\n};\n";

    print <<EOF
/* Decompress and send to stdout a gzip-compressed buffer */
void hugehelp(void)
{
  unsigned char buf[0x10000];
  int status,headerlen;
  z_stream z;

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

  headerlen = 10;
  z.avail_in = sizeof(hugehelpgz) - headerlen;
  z.next_in = (unsigned char *)hugehelpgz + headerlen;
  z.zalloc = (alloc_func)Z_NULL;
  z.zfree = (free_func)Z_NULL;
  z.opaque = 0;

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

  while(1) {
    z.avail_out = (int)sizeof(buf);
    z.next_out = buf;
    status = inflate(&z, Z_SYNC_FLUSH);
    if (status == Z_OK || status == Z_STREAM_END) {
      fwrite(buf, sizeof(buf) - z.avail_out, 1, stdout);
      if (status == Z_STREAM_END)
         break;
    }
     else
      break;    /* Error */
  }
  inflateEnd(&z);
}
EOF
    ;
foot();
exit;
}
else {
    print <<HEAD
void hugehelp(void)
{
   fputs(
HEAD
         ;
}

$outsize=0;
for(@out) {
    chop;

    $new = $_;

    $outsize += length($new)+1; # one for the newline

    $new =~ s/\\/\\\\/g;
    $new =~ s/\"/\\\"/g;

    # gcc 2.96 claims ISO C89 only is required to support 509 letter strings
    if($outsize > 500) {
        # terminate and make another fputs() call here
        print ", stdout);\n fputs(\n";
        $outsize=length($new)+1;
    }
    printf("\"%s\\n\"\n", $new);

}

print ", stdout) ;\n}\n";

foot();

sub foot {
  print <<FOOT
#endif /* USE_MANUAL */
FOOT
  ;
}
-												Initial revision

											
										
										
											1999-12-29 09:20:26 -05:00
+								#!/usr/local/bin/perl
 								# Yeah, I know, probably 1000 other persons already wrote a script like
 								# this, but I'll tell ya:
 								# THEY DON'T FIT ME :-)
 								# Get readme file as parameter:
-												Fixes based on Gisle Vanem's input since this script failed due to
possibly crlf newlines.

											
										
										
											2003-07-28 19:00:56 -04:00
 								if($ARGV[0] eq "-c") {
 								    $c=1;
 								    shift @ARGV;
 								}
-												Based on Dan Fandrich's patch and gzip unpack function, we now compress
the 'hugehelp' text if libz and gzip are available at build time.

											
										
										
											2003-06-12 08:54:34 -04:00
+								my $README = $ARGV[0];
-												Initial revision

											
										
										
											1999-12-29 09:20:26 -05:00
 								if($README eq "") {
-												Based on Dan Fandrich's patch and gzip unpack function, we now compress
the 'hugehelp' text if libz and gzip are available at build time.

											
										
										
											2003-06-12 08:54:34 -04:00
+								    print "usage: mkreadme.pl [-c] <README> < manpage\n";
-												Initial revision

											
										
										
											1999-12-29 09:20:26 -05:00
+								    exit;
 								}
 								push @out, "                                  _   _ ____  _     \n";
 								push @out, "  Project                     ___| | | |  _ \\| |    \n";
 								push @out, "                             / __| | | | |_) | |    \n";
 								push @out, "                            | (__| |_| |  _ <| |___ \n";
 								push @out, "                             \\___|\\___/|_| \\_\\_____|\n";
-												Fixes based on Gisle Vanem's input since this script failed due to
possibly crlf newlines.

											
										
										
											2003-07-28 19:00:56 -04:00
+								my $olen=0;
-												Initial revision

											
										
										
											1999-12-29 09:20:26 -05:00
+								while (<STDIN>) {
-												adjusted the compressed generation to be more helpful in comments etc

											
										
										
											2003-06-26 07:34:07 -04:00
+								    my $line = $_;
-												Initial revision

											
										
										
											1999-12-29 09:20:26 -05:00
-												adjusted the compressed generation to be more helpful in comments etc

											
										
										
											2003-06-26 07:34:07 -04:00
+								    # this should be removed:
 								    $line =~ s/(.|_)//g;
-												Initial revision

											
										
										
											1999-12-29 09:20:26 -05:00
-												adjusted the compressed generation to be more helpful in comments etc

											
										
										
											2003-06-26 07:34:07 -04:00
+								    if($line =~ /^([ \t]*\n|curl)/i) {
 								        # cut off headers and empty lines
 									$wline++; # count number of cut off lines
-												Based on Dan Fandrich's patch and gzip unpack function, we now compress
the 'hugehelp' text if libz and gzip are available at build time.

											
										
										
											2003-06-12 08:54:34 -04:00
+									next;
-												adjusted the compressed generation to be more helpful in comments etc

											
										
										
											2003-06-26 07:34:07 -04:00
+								    }
-												Initial revision

											
										
										
											1999-12-29 09:20:26 -05:00
-												adjusted the compressed generation to be more helpful in comments etc

											
										
										
											2003-06-26 07:34:07 -04:00
+								    my $text = $line;
 								    $text =~ s/^\s+//g; # cut off preceeding...
 								    $text =~ s/\s+$//g; # and trailing whitespaces
 								    $tlen = length($text);
 								    if($wline && ($olen == $tlen)) {
 								        # if the previous line with contents was exactly as long as
 								        # this line, then we ignore the newlines!
 								        # We do this magic because a header may abort a paragraph at
 								        # any line, but we don't want that to be noticed in the output
 								        # here
 								        $wline=0;
-												Initial revision

											
										
										
											1999-12-29 09:20:26 -05:00
+								    }
-												adjusted the compressed generation to be more helpful in comments etc

											
										
										
											2003-06-26 07:34:07 -04:00
+								    $olen = $tlen;
-												Initial revision

											
										
										
											1999-12-29 09:20:26 -05:00
+								    if($wline) {
-												adjusted the compressed generation to be more helpful in comments etc

											
										
										
											2003-06-26 07:34:07 -04:00
+									# we only make one empty line max
-												Initial revision

											
										
										
											1999-12-29 09:20:26 -05:00
+									$wline = 0;
-												adjusted the compressed generation to be more helpful in comments etc

											
										
										
											2003-06-26 07:34:07 -04:00
+								        push @out, "\n";
-												Initial revision

											
										
										
											1999-12-29 09:20:26 -05:00
+								    }
 								    push @out, $line;
 								}
 								push @out, "\n"; # just an extra newline
 								open(READ, "<$README") ||
-												Based on Dan Fandrich's patch and gzip unpack function, we now compress
the 'hugehelp' text if libz and gzip are available at build time.

											
										
										
											2003-06-12 08:54:34 -04:00
+								    die "couldn't read the README infile $README";
-												Initial revision

											
										
										
											1999-12-29 09:20:26 -05:00
 								while(<READ>) {
 								    push @out, $_;
 								}
 								close(READ);
-												Based on Dan Fandrich's patch and gzip unpack function, we now compress
the 'hugehelp' text if libz and gzip are available at build time.

											
										
										
											2003-06-12 08:54:34 -04:00
+								# if compressed
 								if($c) {
 								    my @test = `gzip --version 2>&1`;
 								    if($test[0] =~ /gzip/) {
-												Fixes based on Gisle Vanem's input since this script failed due to
possibly crlf newlines.

											
										
										
											2003-07-28 19:00:56 -04:00
+								        open(GZIP, ">dumpit") ||
 								            die "can't create the dumpit file, try without -c";
-												Based on Dan Fandrich's patch and gzip unpack function, we now compress
the 'hugehelp' text if libz and gzip are available at build time.

											
										
										
											2003-06-12 08:54:34 -04:00
+								        binmode GZIP;
 								        for(@out) {
 								            print GZIP $_;
 								            $gzip += length($_);
 								        }
 								        close(GZIP);
-												Fixes based on Gisle Vanem's input since this script failed due to
possibly crlf newlines.

											
										
										
											2003-07-28 19:00:56 -04:00
 								        system("gzip --best --no-name dumpit");
-												Based on Dan Fandrich's patch and gzip unpack function, we now compress
the 'hugehelp' text if libz and gzip are available at build time.

											
										
										
											2003-06-12 08:54:34 -04:00
-												Fixes based on Gisle Vanem's input since this script failed due to
possibly crlf newlines.

											
										
										
											2003-07-28 19:00:56 -04:00
+								        open(GZIP, "<dumpit.gz") ||
 								             die "can't read the dumpit.gz file, try without -c";
-												Based on Dan Fandrich's patch and gzip unpack function, we now compress
the 'hugehelp' text if libz and gzip are available at build time.

											
										
										
											2003-06-12 08:54:34 -04:00
+								        binmode GZIP;
 								        while(<GZIP>) {
 								            push @gzip, $_;
 								            $gzipped += length($_);
 								        }
 								        close(GZIP);
-												remove the dumpit file after use

											
										
										
											2003-06-12 15:17:08 -04:00
 								        unlink("dumpit.gz");
-												Based on Dan Fandrich's patch and gzip unpack function, we now compress
the 'hugehelp' text if libz and gzip are available at build time.

											
										
										
											2003-06-12 08:54:34 -04:00
+								    }
 								    else {
 								        # no gzip, no compression!
 								        undef $c;
 								        print STDERR "MEEEP: Couldn't find gzip, disable compression\n";
 								    }
 								}
-												Initial revision

											
										
										
											1999-12-29 09:20:26 -05:00
-												Based on Dan Fandrich's patch and gzip unpack function, we now compress
the 'hugehelp' text if libz and gzip are available at build time.

											
										
										
											2003-06-12 08:54:34 -04:00
+								$now = localtime;
 								print <<HEAD
 								/*
 								 * NEVER EVER edit this manually, fix the mkhelp.pl script instead!
 								 * Generation time: $now
 								 */
-												Include "setup.h" and not "config.h" since setup.h is made to include
the correct config.h for the platform, and when this is done the USE_MANUAL
define is properly known.

											
										
										
											2004-04-26 17:15:48 -04:00
+								#include "setup.h"
-												make the generated hugehelp.c file use the USE_MANUAL define so that it
will be properly built with configure --disable-manual even if the source
file is already present

											
										
										
											2004-04-25 04:13:07 -04:00
+								#ifdef USE_MANUAL
-												use hugehelp.h to silence picky compiler warnings

											
										
										
											2004-01-29 08:48:36 -05:00
+								#include "hugehelp.h"
-												Based on Dan Fandrich's patch and gzip unpack function, we now compress
the 'hugehelp' text if libz and gzip are available at build time.

											
										
										
											2003-06-12 08:54:34 -04:00
+								#include <stdio.h>
 								HEAD
 								    ;
 								if($c) {
-												adjusted the compressed generation to be more helpful in comments etc

											
										
										
											2003-06-26 07:34:07 -04:00
+								    print <<HEAD
 								#include <zlib.h>
 								static const unsigned char hugehelpgz[] = {
 								  /* This mumbo-jumbo is the huge help text compressed with gzip.
 								     Thanks to this operation, the size of this data shrunk from $gzip
 								     to $gzipped bytes. You can disable the use of compressed help
 								     texts by NOT passing -c to the mkhelp.pl tool. */
 								HEAD
 								;
-												Based on Dan Fandrich's patch and gzip unpack function, we now compress
the 'hugehelp' text if libz and gzip are available at build time.

											
										
										
											2003-06-12 08:54:34 -04:00
+								    my $c=0;
-												adjusted the compressed generation to be more helpful in comments etc

											
										
										
											2003-06-26 07:34:07 -04:00
+								    print "  ";
-												Based on Dan Fandrich's patch and gzip unpack function, we now compress
the 'hugehelp' text if libz and gzip are available at build time.

											
										
										
											2003-06-12 08:54:34 -04:00
+								    for(@gzip) {
 								        my @all=split(//, $_);
 								        for(@all) {
 								            my $num=ord($_);
 								            printf("0x%02x, ", 0+$num);
 								            if(++$c>11) {
 								                print "\n  ";
 								                $c=0;
 								            }
 								        }
 								    }
 								    print "\n};\n";
 								    print <<EOF
 								/* Decompress and send to stdout a gzip-compressed buffer */
 								void hugehelp(void)
 								{
 								  unsigned char buf[0x10000];
 								  int status,headerlen;
 								  z_stream z;
 								  /* Make sure no gzip options are set */
 								  if (hugehelpgz[3] & 0xfe)
 								    return;
 								  headerlen = 10;
 								  z.avail_in = sizeof(hugehelpgz) - headerlen;
 								  z.next_in = (unsigned char *)hugehelpgz + headerlen;
 								  z.zalloc = (alloc_func)Z_NULL;
 								  z.zfree = (free_func)Z_NULL;
 								  z.opaque = 0;
 								  if (inflateInit2(&z, -MAX_WBITS) != Z_OK)
 								    return;
-												nonsence change to make -Wunreachable-code get happy

											
										
										
											2004-01-29 08:49:41 -05:00
+								  while(1) {
-												Based on Dan Fandrich's patch and gzip unpack function, we now compress
the 'hugehelp' text if libz and gzip are available at build time.

											
										
										
											2003-06-12 08:54:34 -04:00
+								    z.avail_out = (int)sizeof(buf);
 								    z.next_out = buf;
 								    status = inflate(&z, Z_SYNC_FLUSH);
 								    if (status == Z_OK || status == Z_STREAM_END) {
 								      fwrite(buf, sizeof(buf) - z.avail_out, 1, stdout);
 								      if (status == Z_STREAM_END)
 								         break;
-												nonsence change to make -Wunreachable-code get happy

											
										
										
											2004-01-29 08:49:41 -05:00
+								    }
 								     else
-												Based on Dan Fandrich's patch and gzip unpack function, we now compress
the 'hugehelp' text if libz and gzip are available at build time.

											
										
										
											2003-06-12 08:54:34 -04:00
+								      break;    /* Error */
 								  }
 								  inflateEnd(&z);
 								}
 								EOF
 								    ;
-												make the generated hugehelp.c file use the USE_MANUAL define so that it
will be properly built with configure --disable-manual even if the source
file is already present

											
										
										
											2004-04-25 04:13:07 -04:00
+								foot();
-												Based on Dan Fandrich's patch and gzip unpack function, we now compress
the 'hugehelp' text if libz and gzip are available at build time.

											
										
										
											2003-06-12 08:54:34 -04:00
+								exit;
 								}
 								else {
 								    print <<HEAD
 								void hugehelp(void)
 								{
 								   fputs(
 								HEAD
 								         ;
 								}
-												Initial revision

											
										
										
											1999-12-29 09:20:26 -05:00
-												now splits the text into several puts() calls

											
										
										
											2000-05-23 06:25:30 -04:00
+								$outsize=0;
-												Initial revision

											
										
										
											1999-12-29 09:20:26 -05:00
+								for(@out) {
 								    chop;
 								    $new = $_;
-												only generate maximum 509 characters in each string

											
										
										
											2001-03-09 08:11:28 -05:00
+								    $outsize += length($new)+1; # one for the newline
-												now splits the text into several puts() calls

											
										
										
											2000-05-23 06:25:30 -04:00
-												Initial revision

											
										
										
											1999-12-29 09:20:26 -05:00
+								    $new =~ s/\\/\\\\/g;
 								    $new =~ s/\"/\\\"/g;
-												only generate maximum 509 characters in each string

											
										
										
											2001-03-09 08:11:28 -05:00
+								    # gcc 2.96 claims ISO C89 only is required to support 509 letter strings
 								    if($outsize > 500) {
-												Gisle Vanem's fix to make the 'curl -M' output nicer

											
										
										
											2003-05-21 03:21:44 -04:00
+								        # terminate and make another fputs() call here
 								        print ", stdout);\n fputs(\n";
-												only generate maximum 509 characters in each string

											
										
										
											2001-03-09 08:11:28 -05:00
+								        $outsize=length($new)+1;
-												now splits the text into several puts() calls

											
										
										
											2000-05-23 06:25:30 -04:00
+								    }
-												only generate maximum 509 characters in each string

											
										
										
											2001-03-09 08:11:28 -05:00
+								    printf("\"%s\\n\"\n", $new);
-												now splits the text into several puts() calls

											
										
										
											2000-05-23 06:25:30 -04:00
-												Initial revision

											
										
										
											1999-12-29 09:20:26 -05:00
+								}
-												make the generated hugehelp.c file use the USE_MANUAL define so that it
will be properly built with configure --disable-manual even if the source
file is already present

											
										
										
											2004-04-25 04:13:07 -04:00
+								print ", stdout) ;\n}\n";
 								foot();
 								sub foot {
 								  print <<FOOT
 								#endif /* USE_MANUAL */
 								FOOT
 								  ;
 								}