@ -479,7 +479,6 @@ tcl::namespace::eval punk::args::tclcore {
method method
} "@doc -name Manpage: -url [manpage_tcl info]" } "@doc -name Manpage: -url [manpage_tcl info]"
#todo - make generic - take command and known_groups_dict
proc info_subcommands {} { proc info_subcommands {} {
#package require punk::ns #package require punk::ns
#set subdict [punk::ns::ensemble_subcommands -return dict info] #set subdict [punk::ns::ensemble_subcommands -return dict info]
@ -709,7 +708,7 @@ tcl::namespace::eval punk::args::tclcore {
@form -form {set} @form -form {set}
@values -min 3 -max -1 @values -min 3 -max -1
channel channel
"optionName value" -type {string any} -typesynopsis {optionName value} -multiple 1 -optional 0 "optionName value" -type {string any} -typesynopsis {${$I} optionName value${$NI} } -multiple 1 -optional 0
} "@doc -name Manpage: -url [manpage_tcl chan]" ] } "@doc -name Manpage: -url [manpage_tcl chan]" ]
@ -815,7 +814,7 @@ tcl::namespace::eval punk::args::tclcore {
as arguments (keys and values alternating, with each key being followed by as arguments (keys and values alternating, with each key being followed by
its associated value)" its associated value)"
@values -min 2 -max -1 @values -min 2 -max -1
"key value" -type {string string} -typesynopsis {key value} -optional 1 -multiple 1 "key value" -type {string string} -typesynopsis {${$I} key${$NI} ${$I} value${$NI} } -optional 1 -multiple 1
} "@doc -name Manpage: -url [manpage_tcl dict]" ] } "@doc -name Manpage: -url [manpage_tcl dict]" ]
# -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
lappend PUNKARGS [list { lappend PUNKARGS [list {
@ -1116,8 +1115,8 @@ tcl::namespace::eval punk::args::tclcore {
to the ${$I}dictionaryVariable${$NI}'s contents only happen when ${$I}body${$NI} terminates." to the ${$I}dictionaryVariable${$NI}'s contents only happen when ${$I}body${$NI} terminates."
@values -min 4 -max -1 @values -min 4 -max -1
dictionaryVariable -type string dictionaryVariable -type string
"key varName" -type {any any} -typesynopsis {key varName} -optional 0 -multiple 1 "key varName" -type {any any} -typesynopsis {${$I} key${$NI} ${$I} varName${$NI} } -optional 0 -multiple 1
body -type script -typesynopsis body<script> -optional 0 body -type script -typesynopsis ${$I} body<script>${$NI} -optional 0
} "@doc -name Manpage: -url [manpage_tcl dict]" ] } "@doc -name Manpage: -url [manpage_tcl dict]" ]
# -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
} }
@ -3249,7 +3248,7 @@ tcl::namespace::eval punk::args::tclcore {
@opts @opts
-nobackslashes -type none -nobackslashes -type none
-nocommands -type none -nocommands -type none
-novariable -type none -novariables -type none
@values -min 1 -max -1 @values -min 1 -max -1
string -type string string -type string
} "@doc -name Manpage: -url [manpage_tcl subst]" } "@doc -name Manpage: -url [manpage_tcl subst]"
@ -3589,6 +3588,7 @@ tcl::namespace::eval punk::args::tclcore {
#we can't use 'namespace ensemble configure' to query it #we can't use 'namespace ensemble configure' to query it
#define subcommand documentation first #define subcommand documentation first
# -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
punk::args::define { punk::args::define {
@dynamic @dynamic
@id -id "::zlib adler32" @id -id "::zlib adler32"
@ -3601,6 +3601,7 @@ tcl::namespace::eval punk::args::tclcore {
initValue -type string -optional 1 initValue -type string -optional 1
} "@doc -name Manpage: -url [punk::args::tclcore::manpage_tcl zlib]" } "@doc -name Manpage: -url [punk::args::tclcore::manpage_tcl zlib]"
# -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
punk::args::define { punk::args::define {
@dynamic @dynamic
@id -id "::zlib crc32" @id -id "::zlib crc32"
@ -3613,6 +3614,7 @@ tcl::namespace::eval punk::args::tclcore {
initValue -type string -optional 1 initValue -type string -optional 1
} "@doc -name Manpage: -url [punk::args::tclcore::manpage_tcl zlib]" } "@doc -name Manpage: -url [punk::args::tclcore::manpage_tcl zlib]"
# -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
punk::args::define { punk::args::define {
@dynamic @dynamic
@id -id "::zlib compress" @id -id "::zlib compress"
@ -3624,23 +3626,209 @@ tcl::namespace::eval punk::args::tclcore {
string -type string string -type string
level -type integer -range {0 9} -optional 1 level -type integer -range {0 9} -optional 1
} "@doc -name Manpage: -url [punk::args::tclcore::manpage_tcl zlib]" } "@doc -name Manpage: -url [punk::args::tclcore::manpage_tcl zlib]"
# -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
punk::args::define {
@dynamic
@id -id "::zlib decompress"
@cmd -name "builtin: ::zlib compress" -help\
"Returns the uncompressed version of the raw compressed binary data in
${$I}string${$NI}. If present, ${$I}bufferSize${$NI} is a hint as to what size of buffer is to
be used to receive the data."
@values -min 1 -max 2
string -type string
bufferSize -type integer -optional 1
} "@doc -name Manpage: -url [punk::args::tclcore::manpage_tcl zlib]"
# -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
punk::args::define {
@id -id "::zlib deflate"
@cmd -name "builtin: ::zlib deflate" -help\
"Returns the raw compressed binary data of the binary string in ${$I}string${$NI}.
If present, ${$I}level${$NI} gives the compression level to use (from 0, which is
uncompressed, to 9, maximally compressed)."
@values -min 1 -max 2
string -type string
level -type integer -range {0 9} -optional 1
} "@doc -name Manpage: -url [punk::args::tclcore::manpage_tcl zlib]"
# -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
punk::args::define {
@id -id "::zlib push"
@cmd -name "builtin: ::zlib push" -help\
"Pushes a compressing or decompressing transformation onto the channel
channel. The transformation can be removed again with chan pop. The mode
argument determines what type of transformation is pushed.
Both compressing and decompressing channel transformations add extra
configuration options that may be accessed through chan configure.
The options are:
-checksum checksum
This read-only option gets the current checksum for the uncompressed
data that the compression engine has seen so far. It is valid for both
compressing and decompressing transforms, but not for the raw inflate
and deflate formats. The compression algorithm depends on what format
is being produced or consumed.
-dictionary binData
This read-write options gets or sets the initial compression dictionary
to use when working with compressing or decompressing the data to be
binData. It is not valid for transformations that work with gzip-format
data, and should not normally be set on compressing transformations
other than at the point where the transformation is stacked. Note that
this cannot be used to get the current active compression dictionary
mid-stream, as that information is not exposed by the underlying library.
-flush type
This write-only operation flushes the current state of the compressor to
the underlying channel. It is only valid for compressing transformations.
The type must be either sync or full for a normal flush or an expensive
flush respectively. Flushing degrades the compression ratio, but makes it
easier for a decompressor to recover more of the file in the case of data
corruption.
-header dictionary
This read-only option, only valid for decompressing transforms that are
processing gzip-format data, returns the dictionary describing the header
read off the data stream.
-limit readaheadLimit
This read-write option is used by decompressing channels to control the
maximum number of bytes ahead to read from the underlying data source.
See below for more information."
@leaders -min 1 -max 1
# -- --- --- --- --- --- --- --- --- --- ---
mode -type string -choicecolumns 2 -choices {compress decompress deflate gunzip gzip inflate} -choicelabels {
compress\
"The transformation will be a compressing
transformation that produces zlib-format
data on channel, which must be writable."
decompress\
"The transformation will be a decompressing
transformation that reads zlib-format data
from channel, which must be readable."
deflate\
"The transformation will be a compressing
transformation that produces raw compressed
data on channel, which must be writable."
gunzip\
"The transformation will be a decompressing
transformation that reads gzip-format data
from channel, which must be readable."
gzip\
"The transformation will be a compressing
transformation that produces gzip-format
data on channel, which must be writable."
inflate\
"The transformation will be a decompressing
transformation that reads raw compressed
data from channel, which must be readable."
}
@opts
-dictionary -type dict -typesynopsis ${$I}binData${$NI} -help\
"Sets the compression dictionary to use when working with compressing or
decompressing the data to be binData. Not valid for transformations that
work with gzip-format data. The dictionary should consist of strings
(byte sequences) that are likely to be encountered later in the data to
be compressed, with the most commonly used strings preferably put towards
the end of the dictionary. Tcl provides no mechanism for choosing a good
such dictionary for a particular data sequence."
-header -type dict -typesynopsis ${$I}dictionary${$NI} -help\
"Passes a description of the gzip header to create, in the same format that
zlib gzip understands."
-level -type integer -range {0 9} -typesynopsis ${$I}compressionLevel${$NI} -help\
"How hard to compress the data. Must be an integer from 0 (uncompressed) to
9 (maximally compressed)."
-limit -type integer -typesynopsis ${$I}readaheadLimit${$NI} -help\
"The maximum number of bytes ahead to read when decompressing.
This option has become irrelevant. It was originally introduced to prevent
Tcl from reading beyond the end of a compressed stream in multi-stream
channels to ensure that the data after was left alone for further reading,
at the cost of speed.
Tcl now automatically returns any bytes it has read beyond the end of a
compressed stream back to the channel, making them appear as unread to
further readers."
@values -min 0 -max 0
} "@doc -name Manpage: -url [punk::args::tclcore::manpage_tcl zlib]"
# -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
punk::args::define {
@id -id "::zlib gunzip"
@cmd -name "builtin: ::zlib gunzip" -help\
"Return the uncompressed contents of binary string ${$I}string${$NI}, which must have
been in gzip format. If ${$B}-headerVar${$N} is given, store a dictionary describing
the contents of the gzip header in the variable called varName. The keys of the
dictionary that may be present are:
${$B}comment${$N}
The comment field from the header, if present.
${$B}crc${$N}
A boolean value describing whether a CRC of the header is computed.
${$B}filename${$N}
The filename field from the header, if present.
${$B}os${$N}
The operating system type code field from the header (if not the QW unknown value).
See RFC 1952 for the meaning of these codes.
${$B}size${$N}
The size of the uncompressed data.
${$B}time${$N}
The time field from the header if non-zero, expected to be time that the file named
by the ${$B}filename${$N} field was modified. Suitable for use with ${$B}clock format${$N}.
${$B}type${$N}
The type of the uncompressed data (${$B}binary${$N} or ${$B}text${$N}) if known."
@leaders -min 1 -max 1
string -type string
@opts
-headerVar -type string -typesynopsis ${$I}varName${$NI}
@values -max 0
} "@doc -name Manpage: -url [punk::args::tclcore::manpage_tcl zlib]"
# -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
punk::args::define {
@id -id "::zlib gzip"
@cmd -name "builtin: ::zlib gzip" -help\
"Return the compressed contents of binary string string in gzip format.
If -level is given, level gives the compression level to use (from 0,
which is uncompressed, to 9, maximally compressed). If -header is given,
dict is a dictionary containing values used for the gzip header.
The following keys may be defined:
${$B}comment${$N}
Add the given comment to the header of the gzip-format data.
${$B}crc${$N}
A boolean saying whether to compute a CRC of the header. Note that
if the data is to be interchanged with the gzip program, a header CRC
should not be computed.
${$B}filename${$N}
The name of the file that the data to be compressed came from.
${$B}os${$N}
The operating system type code, which should be one of the values
described in RFC 1952.
${$B}time${$N}
The time that the file named in the filename key was last modified.
This will be in the same as is returned by clock seconds or ${$B}file
mtime${$N}.
${$B}type${$N}
The type of the data being compressed, being ${$B}binary${$N} or ${$B}text${$N}."
@leaders -min 1 -max 1
string -type string
@opts
-level -type integer -range {0 9} -typesynopsis ${$I}level${$NI}
-header -type dict -typesynopsis ${$I}dict${$NI}
@values -max 0
} "@doc -name Manpage: -url [punk::args::tclcore::manpage_tcl zlib]"
# -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
set CHOICES [list compress decompress deflate gunzip gzip inflate push stream adler32 crc32] set CHOICES [list compress decompress deflate gunzip gzip inflate push stream adler32 crc32]
#manual synopses for subcommands not yet defined #manual synopses for subcommands not yet defined
set CHOICELABELS { set CHOICELABELS [subst -novariables {
compress "zlib compress string ?level?" compress "zlib compress string ?level?"
decompress "zlib decompress string ?buffersize?" decompress "zlib decompress string ?buffersize?"
deflate "zlib deflate string ?level?" deflate "zlib deflate string ?level?"
gunzip "zlib gunzip string ?-headerVar varName?" gunzip "zlib gunzip string ?-headerVar varName?"
gzip "zlib gzip string ?-level level? ?-header dict?" gzip "zlib gzip string ?-level level? ?-header dict?"
inflate "zlib inflate string ?bufferSize?" inflate "zlib inflate string ?bufferSize?"
push "zlib push mode channel ?options ...?" push "zlib push [punk::ansi::a+ italic] mode[punk::ansi::a+ noitalic] channel ?options ...?"
stream "zlib stream mode ?options?" stream "zlib stream mode ?options?"
adler32 "zlib adler32 string ?initValue?" adler32 "zlib adler32 string ?initValue?"
crc32 "zlib crc32 string ?initValue?" crc32 "zlib crc32 string ?initValue?"
} }]
set CHOICEINFO [dict create] set CHOICEINFO [dict create]
foreach sub $CHOICES { foreach sub $CHOICES {
#default for all #default for all
@ -3674,6 +3862,293 @@ tcl::namespace::eval punk::args::tclcore {
} "@doc -name Manpage: -url [punk::args::tclcore::manpage_tcl zlib]" } "@doc -name Manpage: -url [punk::args::tclcore::manpage_tcl zlib]"
# -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
proc zipfs_subcommands {} {
dict set groups "" {canonical exists find info list mount mountdata root unmount}
dict set groups "ZIP Creation" {mkzip mkimg mkkey lmkimg lmkzip}
return [ensemble_subcommands_definition -groupdict $groups -columns 3 zipfs]
}
set DYN_ZIPFS_SUBCOMMANDS {${[punk::args::tclcore::argdoc::zipfs_subcommands]}}
punk::args::define {
@dynamic
@id -id ::zipfs
@cmd -name "builtin: ::zipfs" -help\
"Mount and work with ZIP files within Tcl
The ${$B}zipfs${$N} command provides Tcl with the ability to mount the contents of a
ZIP archive file as a virtual file system. Tcl's ZIP archive support is
limited to basic features and options. Supported storage methods include
only STORE and DEFLATE with optional simple encryption, sufficient to
prevent casual inspection of their contents but not able to prevent access
by even a moderately determined attacker. Strong encryption, multi-part
archives, platform metadata, zip64 formats and other compression methods
like bzip2 are not supported.
Files within mounted archives can be written to but new files or directories
cannot be created. Further, modifications to files are limited to the
mounted archive in memory and are not persisted to disk.
Paths in mounted archives are case-sensitive on all platforms."
@leaders -min 1 -max 1
${$DYN_ZIPFS_SUBCOMMANDS}
@values -min 0
} "@doc -name Manpage: -url [punk::args::tclcore::manpage_tcl zipfs]"
# -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
punk::args::define {
@id -id ::tcl::zipfs::canonical
@cmd -name "builtin: ::zipfs::canonical" -help\
"This takes the name of a file, ${$I}filename${$NI}, and produces where it would be
mapped into a zipfs mount as its result. If specified, mountpoint says
within which mount the mapping will be done; if omitted, the main root of
the zipfs system is used."
@leaders -min 0 -max 0
@values -min 1 -max 1
mountpoint -type string -optional 1
filename -type string
} "@doc -name Manpage: -url [punk::args::tclcore::manpage_tcl zipfs]"
# -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
punk::args::define {
@id -id ::tcl::zipfs::exists
@cmd -name "builtin: ::zipfs::exists" -help\
"Return 1 if the given filename exists in the mounted zipfs and 0 if it does not."
@leaders -min 0 -max 0
@values -min 1 -max 1
filename -type file
} "@doc -name Manpage: -url [punk::args::tclcore::manpage_tcl zipfs]"
# -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
punk::args::define {
@id -id ::tcl::zipfs::find
@cmd -name "builtin: ::zipfs::find" -help\
"Returns the list of paths under directory ${$I}directoryName${$NI} which need not
be within a zipfs mounted archive. The paths are prefixed with
${$I}directoryName${$NI}. This command is also used by the ${$B}zipfs mkzip${$N} and
${$B}zipfs mkimg${$N} commands."
@leaders -min 0 -max 0
@values -min 1 -max 1
directoryName -type directory
} "@doc -name Manpage: -url [punk::args::tclcore::manpage_tcl zipfs]"
# -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
punk::args::define {
@id -id ::tcl::zipfs::info
@cmd -name "builtin: ::zipfs::info" -help\
"Return information about the given ${$I}file${$NI} in the mounted zipfs.
The information consists of:
1. the name of the ZIP archive file that contains the file,
2. the size of the file after decompressions,
3. the compressed size of the file, and
4. the offset of the compressed data in the ZIP archive file.
As a special case, querying the mount point gives the start of the zip
data as the offset in (4), which can be used to truncate the zip
information from an executable. Querying an ancestor of a mount point
will raise an error."
@leaders -min 0 -max 0
@values -min 1 -max 1
file -type string
} "@doc -name Manpage: -url [punk::args::tclcore::manpage_tcl zipfs]"
# -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
punk::args::define {
@id -id ::tcl::zipfs::list
@cmd -name "builtin: ::zipfs::list" -help\
"If pattern is not specified, the command returns a list of files across
all zipfs mounted archives. If pattern is specified, only those paths
matching the pattern are returned. By default, or with the -glob option,
the pattern is treated as a glob pattern and matching is done as described
for the string match command. Alternatively, the -regexp option may be
used to specify matching pattern as a regular expression. The file names
are returned in arbitrary order. Note that path separators are treated as
ordinary characters in the matching. Thus forward slashes should be used
as path separators in the pattern. The returned paths only include those
actually in the archive and does not include intermediate directories in
mount paths."
@leaders -min 0 -max 0
@values -min 1 -max 1
#patterntype -type literalprefix(-glob)|literalprefix(-regexp) -optional 1
patterntype -type string -default -glob -choices {-glob -regexp} -typesynopsis -glob|-regex
pattern -type string -optional 1
} "@doc -name Manpage: -url [punk::args::tclcore::manpage_tcl zipfs]"
# -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
punk::args::define {
@id -id ::tcl::zipfs::lmkimg
@cmd -name "builtin: ::zipfs::lmkimg" -help\
"This command is like ${$B}zipfs mkimg${$N}, but instead of an input directory,
${$I}inlist${$NI} must be a Tcl list where the odd elements are the names of files
to be copied into the archive in the image, and the even elements are
their respective names within that archive."
@leaders -min 0 -max 0
@values -min 2 -max 4
outfile -type file
inlist -type dict
password -type any -optional 1
infile -type file -optional 1
} "@doc -name Manpage: -url [punk::args::tclcore::manpage_tcl zipfs]"
# -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
punk::args::define {
@id -id ::tcl::zipfs::lmkzip
@cmd -name "builtin: ::zipfs::lmkzip" -help\
"This command is like ${$B}zipfs mkzip${$N}, but instead of an input directory,
${$I}inlist${$NI} must be a Tcl list where the odd elements are the names of files
to be copied into the archive, and the even elements are their respective
names within that archive."
@leaders -min 0 -max 0
@values -min 2 -max 3
outfile -type file
inlist -type dict
password -type any -optional 1
} "@doc -name Manpage: -url [punk::args::tclcore::manpage_tcl zipfs]"
# -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
punk::args::define {
@id -id ::tcl::zipfs::mount
@cmd -name "builtin: ::zipfs::mount" -help\
"The ${$B}zipfs mount${$N} command mounts ZIP archives as Tcl virtual file systems
and returns information about current mounts.
With no arguments, the command returns a dictionary mapping mount points
to the path of the corresponding ZIP archive.
In the single argument form, the command returns the file path of the ZIP
archive mounted at the specified mount point.
In the third form, the command mounts the ZIP archive zipfile as a Tcl
virtual filesystem at ${$I}mountpoint${$NI}. After this command executes, files
contained in zipfile will appear to Tcl to be regular files at the mount
point. If ${$I}mountpoint${$NI} is specified as an empty string, it is defaulted to
the ${$B}[zipfs root]${$N}. The command returns the normalized mount point path.
If not under the zipfs file system root, ${$I}mountpoint${$NI} is normalized with
respect to it. For example, a mount point passed as either ${$B}mt${$N} or ${$B}/mt${$N} would
be normalized to ${$B}//zipfs:/mt${$N} (given that ${$B}zipfs root${$N} returns “//zipfs:/”).
An error is raised if the mount point includes a drive or UNC volume.
${$B}NB${$N}: because the current working directory is a concept maintained by the
operating system, using ${$B}cd${$N} into a mounted archive will only work in the
current process, and then not entirely consistently (e.g., if a shared
library uses direct access to the OS rather than through Tcl's filesystem
API, it will not see the current directory as being inside the mount and
will not be able to access the files inside the mount)."
@leaders -min 0 -max 0
@form -form dict
@values -min 0 -max 0
@form -form query
@values -min 1 -max 1
mountpoint
@form -form mount
@values -min 2 -max 3
zipfile -type file
mountpoint -type string
password -type string -optional 1
} "@doc -name Manpage: -url [punk::args::tclcore::manpage_tcl zipfs]"
# -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
punk::args::define {
@id -id ::tcl::zipfs::mountdata
@cmd -name "builtin: ::zipfs::mountdata" -help\
"Mounts the ZIP archive content ${$I}data${$NI} as a Tcl virtual filesystem at ${$I}mountpoint${$NI}."
@leaders -min 0 -max 0
@values -min 1 -max 1
data -type any
mountpoint -type string
} "@doc -name Manpage: -url [punk::args::tclcore::manpage_tcl zipfs]"
# -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
punk::args::define {
@id -id ::tcl::zipfs::mkzip
@cmd -name "builtin: ::zipfs::mkzip" -help\
"Creates a ZIP archive file named outfile from the contents of the input
directory indir (contained regular files only) with optional ZIP password
password. While processing the files below indir the optional file name
prefix given in strip is stripped off the beginning of the respective file
name if non-empty. When stripping, it is common to remove either the whole
source directory name or the name of its parent directory.
Caution: the choice of the indir parameter (less the optional stripped
prefix) determines the later root name of the archive's content."
@leaders -min 0 -max 0
@values -min 2 -max 4
outfile
indir
strip -type string -optional 1 -help\
"file name prefix"
password -type any -optional 1
} "@doc -name Manpage: -url [punk::args::tclcore::manpage_tcl zipfs]"
# -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
punk::args::define {
@id -id ::tcl::zipfs::mkimg
@cmd -name "builtin: ::zipfs::mkzip" -help\
"Creates an image (potentially a new executable file) similar to ${$B}zipfs mkzip${$N};
see that command for a description of most parameters to this command, as
they behave identically here. If outfile exists, it will be silently
overwritten.
If the ${$I}infile${$NI} parameter is specified, this file is prepended in front of the
ZIP archive, otherwise the file returned by ${$B}info nameofexecutable${$N} (i.e., the
executable file of the running process, typically ${$B}wish${$N} or ${$B}tclsh${$N}) is used. If
the ${$I}password${$NI} parameter is not the empty string, an obfuscated version of that
password (see ${$B}zipfs mkkey${$N}) is placed between the image and ZIP chunks of the
output file and the contents of the ZIP chunk are protected with that
password. If the starting image has a ZIP archive already attached to it, it
is removed from the copy in ${$I}outfile${$NI} before the new ZIP archive is added.
If there is a file, main.tcl, in the root directory of the resulting archive
and the image file that the archive is attached to is a ${$B}tclsh${$N} (or ${$B}wish${$N})
instance (true by default, but depends on your configuration), then the
resulting image is an executable that will ${$B}source${$N} the script in that main.tcl
after mounting the ZIP archive, and will ${$B}exit${$N} once that script has been
executed.
Note: ${$B}tclsh${$N} and ${$B}wish${$N} can be built using either dynamic binding or static
binding of the core implementation libraries. With a dynamic binding, the
base application Tcl_Library contents are attached to the libtcl and libtk
shared library, respectively. With a static binding, the Tcl_Library contents,
etc., are attached to the application, tclsh or wish. When using ${$B}mkimg${$N} with a
statically built tclsh, it is the user's responsibility to preserve the
attached archive by first extracting it to a temporary location, and then add
whatever additional files desired, before creating and attaching the new
archive to the new application."
@leaders -min 0 -max 0
@values -min 2 -max 5
outfile
indir
strip -type string -optional 1 -help\
"file name prefix"
password -type string -optional 1
infile -type string -optional 1
} "@doc -name Manpage: -url [punk::args::tclcore::manpage_tcl zipfs]"
# -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
punk::args::define {
@id -id ::tcl::zipfs::mkkey
@cmd -name "builtin: ::zipfs::mkzip" -help\
"Given the clear text ${$I}password${$NI} argument, an obfuscated string version is
returned with the same format used in the ${$B}zipfs mkimg${$N} command."
@leaders -min 0 -max 0
@values -min 1 -max 1
password -type string
} "@doc -name Manpage: -url [punk::args::tclcore::manpage_tcl zipfs]"
# -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
punk::args::define {
@id -id ::tcl::zipfs::root
@cmd -name "builtin: ::zipfs::root" -help\
"Returns a constant string which indicates the mount point for zipfs
volumes for the current platform. User should not rely on the mount point
being the same constant string for all platforms."
@leaders -min 0 -max 0
@opts -min 0 -max 0
@values -min 0 -max 0
} "@doc -name Manpage: -url [punk::args::tclcore::manpage_tcl zipfs]"
# -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
punk::args::define {
@id -id ::tcl::zipfs::unmount
@cmd -name "builtin: ::zipfs::unmount" -help\
"Unmounts a previously mounted ZIP archive mounted to ${$I}mountpoint${$NI}. The
command will fail with an error exception if there are any files within
the mounted archive are open."
@leaders -min 0 -max 0
@opts -min 0 -max 0
@values -min 1 -max 1
mountpoint
} "@doc -name Manpage: -url [punk::args::tclcore::manpage_tcl zipfs]"
# -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
} }
# -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- # -- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- ---
