karl@sugar.hackercorp.com (Karl Lehenbauer) (03/19/90)
#! /bin/sh
# This is a shell archive. Remove anything before this line, then feed it
# into a shell via "sh file" or similar. To overwrite existing files,
# type "sh file -c".
# The tool that generated this appeared in the comp.sources.unix newsgroup;
# send mail to comp-sources-unix@uunet.uu.net if you want that tool.
# If this archive is complete, you will see the following message at the end:
# "End of shell archive."
# Contents: ./help/run ./help/string ./help/format ./help/uplevel
# ./help/random ./help/index ./help/continue ./help/exec ./help/for
# ./help/variables ./help/send ./help/break ./help/trace
# ./help/results ./help/error ./help/length ./help/gadgets
# ./help/global ./help/programs ./help/info ./help/resources
# ./help/range ./help/tcl ./help/expr ./help/glob ./help/display
# ./help/expressions ./help/rename ./help/catch ./help/menu
# ./help/window ./help/set ./help/time ./help/endeventloop
# ./help/case ./help/source ./help/lists ./help/eventloop
# ./help/commands ./help/procedures ./help/post ./help/tcla
# ./help/displayrequest
# Wrapped by karl@sugar on Sun Mar 18 22:50:04 1990
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f './help/run' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/run'\"
else
echo shar: Extracting \"'./help/run'\" \(204 characters\)
sed "s/^X//" >'./help/run' <<'END_OF_FILE'
Xrun
X---
X
Xrun works just like "exec", except that the CLI command run by run
Xhas it's output go to the standard output of the tcl interpreter
Xthat executes it, which at this time would be a CLI window.
END_OF_FILE
if test 204 -ne `wc -c <'./help/run'`; then
echo shar: \"'./help/run'\" unpacked with wrong size!
fi
# end of './help/run'
fi
if test -f './help/string' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/string'\"
else
echo shar: Extracting \"'./help/string'\" \(1751 characters\)
sed "s/^X//" >'./help/string' <<'END_OF_FILE'
X string option a b
X Perform a string operation on the two operands a and b,
X based on option. The possible options are:
X
X string compare a b
X Perform a character-by-character comparison of
X strings a and b, in the same way as the C strcmp
X procedure. Return -1, 0, or 1, depending on
X whether a is lexicographically less than, equal
X to, or greater than b.
X
X string first a b
X Search b for a sequence of characters that exactly
X match the characters in a. If found, return the
X index of the first character in the first such
X match within b. If not found, return -1.
X
X string last a b
X Search b for a sequence of characters that exactly
X match the characters in a. If found, return the
X index of the first character in the last such
X match within b. If there is no match, then return
X -1.
X
X string match pattern string
X See if pattern matches string; return 1 if it
X does, 0 if it doesn't. Matching is done in a
X fashion similar to that used by the C-shell. For
X the two strings to match, their contents must be
X identical except that the following special
X sequences may appear in pattern:
X
X *
X Matches any sequence of characters in
X string, including a null string.
X
X ?
X Matches any single character in string.
X
X [chars]
X Matches any character in the set given
X by chars. If a sequence of the form x-y
X appears in chars, then any character
X between x and y, inclusive, will match.
X
X \x
X Matches the single character x. This
X provides a way of avoiding the special
X interpretation of the characters *?[]\
X in pattern.
X
X Unique abbreviations for option are acceptable.
X
END_OF_FILE
if test 1751 -ne `wc -c <'./help/string'`; then
echo shar: \"'./help/string'\" unpacked with wrong size!
fi
# end of './help/string'
fi
if test -f './help/format' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/format'\"
else
echo shar: Extracting \"'./help/format'\" \(1114 characters\)
sed "s/^X//" >'./help/format' <<'END_OF_FILE'
X format formatString arg arg ...
X This command generates a formatted string in the same
X way as the C sprintf procedure (it uses sprintf in its
X implementation). FormatString indicates how to format
X the result, using % fields as in sprintf, and the
X additional arguments, if any, provide values to be
X substituted into the result. All of the sprintf
X options are valid; see the sprintf man page for
X details. Each arg must match the expected type from
X the % field in formatString; the format command
X converts each argument to the correct type (floating,
X integer, etc.) before passing it to sprintf for
X formatting. The only unusual conversion is for %c; in
X this case the argument must be a decimal string, which
X will then be converted to the corresponding ASCII
X character value. Format does backslash substitution on
X its formatString argument, so backslash sequences in
X formatString will be handled correctly even if the
X argument is in braces. The return value from format is
X the formatted string.
X
END_OF_FILE
if test 1114 -ne `wc -c <'./help/format'`; then
echo shar: \"'./help/format'\" unpacked with wrong size!
fi
# end of './help/format'
fi
if test -f './help/uplevel' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/uplevel'\"
else
echo shar: Extracting \"'./help/uplevel'\" \(1840 characters\)
sed "s/^X//" >'./help/uplevel' <<'END_OF_FILE'
X uplevel level command command ...
X All of the command arguments are concatenated as if
X they had been passed to concat and the result is
X evaluated in the variable context indicated by level.
X Uplevel returns the result of that evaluation. If
X level is zero, then top-level context is used (all
X variable names refer to global variables). If level is
X a positive number, then it is treated as a stack level:
X 1 refers to the topmost active procedure, 2 to the
X procedure it called, and so on. If level is a negative
X number, then it is treated as a level relative to the
X current procedure. For example, a level of -1 refers
X to the procedure that called the one invoking the
X uplevel command (which is top-level if the procedure
X invoking uplevel is at level 1). The uplevel command
X causes the invoking procedure to disappear from the
X procedure calling stack while the command is being
X executed. For example, suppose procedure x is at level
X 3 and invokes the command
X
X uplevel -1 {set a 43; c}
X
X where c is another Tcl procedure. The set command will
X modify variable a in x's caller, and c will execute at
X level 3, as if called from x's caller. If it in turn
X executes the command
X
X uplevel -1 {set a 42}
X
X then the set command will modify the same variable a in
X x's caller: the procedure x does not appear to be on
X the call stack when c is executing. The command ``info
X level'' may be used to obtain the level of the current
X procedure. Uplevel makes it possible to implement new
X control constructs as Tcl procedures (for example,
X uplevel could be used to implement the while construct
X as a Tcl procedure).
X
END_OF_FILE
if test 1840 -ne `wc -c <'./help/uplevel'`; then
echo shar: \"'./help/uplevel'\" unpacked with wrong size!
fi
# end of './help/uplevel'
fi
if test -f './help/random' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/random'\"
else
echo shar: Extracting \"'./help/random'\" \(415 characters\)
sed "s/^X//" >'./help/random' <<'END_OF_FILE'
X
XThe random command returns a random number or seeds the random number
Xgenerator.
X
XUsge:
X
X random x
X
Xreturns a random integer between 0 and x-1
X
X
X random x seed
X
Xseeds the random number generator with x
X
X
XBUGS
X
Xuses the library routine, consequently a seed and the random number are
Xfor everyone using the shared library. This will be changed to where
Xeach program using the library has a private seed and number.
END_OF_FILE
if test 415 -ne `wc -c <'./help/random'`; then
echo shar: \"'./help/random'\" unpacked with wrong size!
fi
# end of './help/random'
fi
if test -f './help/index' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/index'\"
else
echo shar: Extracting \"'./help/index'\" \(883 characters\)
sed "s/^X//" >'./help/index' <<'END_OF_FILE'
X index value index [chars]
X Extract an element from a list or a character from a
X string. If the chars keyword isn't specified, then
X index treats value as a list and returns the index'th
X field from it. In extracting the field, index observes
X the same rules concerning braces and backslashes as the
X Tcl command interpreter; however, variable
X substitution and command substitution do not occur. If
X index is greater than or equal to the number of
X elements in value, then the empty string is returned.
X If the chars keyword is specified (or any abbreviation
X of it), then value is treated as a string and the
X command returns the index'th character from it (or the
X empty string if there aren't at least index+1
X characters in the string). Index 0 refers to the first
X element or character of value.
X
END_OF_FILE
if test 883 -ne `wc -c <'./help/index'`; then
echo shar: \"'./help/index'\" unpacked with wrong size!
fi
# end of './help/index'
fi
if test -f './help/continue' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/continue'\"
else
echo shar: Extracting \"'./help/continue'\" \(303 characters\)
sed "s/^X//" >'./help/continue' <<'END_OF_FILE'
X continue
X This command may be invoked only inside the body of a
X loop command such as for or foreach. It returns a
X TCL_CONTINUE code to signal the innermost containing
X loop command to skip the remainder of the loop's body
X but continue with the next iteration of the loop.
X
END_OF_FILE
if test 303 -ne `wc -c <'./help/continue'`; then
echo shar: \"'./help/continue'\" unpacked with wrong size!
fi
# end of './help/continue'
fi
if test -f './help/exec' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/exec'\"
else
echo shar: Extracting \"'./help/exec'\" \(1498 characters\)
sed "s/^X//" >'./help/exec' <<'END_OF_FILE'
X exec command arg1 arg2 ...[< input]
X The exec command treats its command argument as the
X name of a program to execute. It searches the
X directories in the PATH environment variable to find an
X executable file by the name command, then executes the
X file, passing it an argument list consisting of command
X plus all of the args. If an argument < appears
X anywhere among the arguments to exec, then neither it
X or the following argument is passed to command.
X Instead, the following argument (input) consists of
X input to the command; exec will create a pipe and use
X it to pass input to command as standard input. Exec
X also creates a pipe to receive command's output (both
X standard output and standard error). The information
X received over this pipe is returned as the result of
X the exec command. The exec command also looks at the
X return status returned by command. Normally this
X should be zero; if it is then exec returns normally.
X If command returns a non-zero status, then exec will
X return that code; it should be one of the ones defined
X in the section ``COMMAND RESULTS'' above. If an out-of
X range code is returned by the command, it will cause
X command unwinding just as if TCL_ERROR had been
X returned; at the outermost level of command
X interpretation, the Tcl interpreter will turn the code
X into TCL_ERROR, with an appropriate error message.
X
END_OF_FILE
if test 1498 -ne `wc -c <'./help/exec'`; then
echo shar: \"'./help/exec'\" unpacked with wrong size!
fi
# end of './help/exec'
fi
if test -f './help/for' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/for'\"
else
echo shar: Extracting \"'./help/for'\" \(1033 characters\)
sed "s/^X//" >'./help/for' <<'END_OF_FILE'
X for start test next body
X For is a looping command, similar in structure to the C
X for statement. The start, next, and body arguments
X must be Tcl command strings, and test is an expression
X string. The for command first invokes the Tcl
X interpreter to execute first. Then it repeatedly
X evaluates test as an expression; if the result is
X non-zero it invokes the Tcl interpreter on body, then
X invokes the Tcl interpreter on next, then repeats the
X loop. The command terminates when test evaluates to 0.
X If a continue command is invoked within body then any
X remaining commands in the current execution of body are
X skipped; processing continues by invoking the Tcl
X interpreter on next, then evaluating test, and so on.
X If a break command is invoked within body or next, then |
X the for command will return immediately. The operation
X of break and continue are similar to the corresponding
X statements in C. For returns an empty string.
X
END_OF_FILE
if test 1033 -ne `wc -c <'./help/for'`; then
echo shar: \"'./help/for'\" unpacked with wrong size!
fi
# end of './help/for'
fi
if test -f './help/variables' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/variables'\"
else
echo shar: Extracting \"'./help/variables'\" \(837 characters\)
sed "s/^X//" >'./help/variables' <<'END_OF_FILE'
XVARIABLES
X Tcl allows the definition of variables and the use of their
X values either through $-style variable substitution, the set
X command, or a few other mechanisms. Variables need not be
X declared: a new variable will automatically be created each
X time a new variable name is used. Variables may be either
X global or local. If a variable name is used when a
X procedure isn't being executed, then it automatically refers
X to a global variable. Variable names used within a
X procedure normally refer to local variables associated with
X that invocation of the procedure. Local variables are
X deleted whenever a procedure exits. The global command may
X be used to request that a name refer to a global variable
X for the duration of the current procedure (this is somewhat
X analogous to extern in C).
X
END_OF_FILE
if test 837 -ne `wc -c <'./help/variables'`; then
echo shar: \"'./help/variables'\" unpacked with wrong size!
fi
# end of './help/variables'
fi
if test -f './help/send' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/send'\"
else
echo shar: Extracting \"'./help/send'\" \(769 characters\)
sed "s/^X//" >'./help/send' <<'END_OF_FILE'
X
XThe send command allows you to send a command to another Tcl program.
X
XUsage is 'send programname message...'
X
XIf programname is the name of a program (the filename of the program when
Xit's started) that has called TclaInitPort, your message will be queued
Xto a message port belonging to the other program, and your program will
Xwait for that program to reply with a reply message for your program.
X
XNote that this command fully preserves Tcl semantics, that is, if the
Xremote program returns an error, you get an error back (which kills
Xyour command unless you trap it), etc, etc, which is to say that a
X'send bar format "x%sz" "y"' should work exactly the same to your
Xprogram (assuming bar exists and is running, etc.) as if you had
Xexecuted 'format "x%sz" "y"'.
X
END_OF_FILE
if test 769 -ne `wc -c <'./help/send'`; then
echo shar: \"'./help/send'\" unpacked with wrong size!
fi
# end of './help/send'
fi
if test -f './help/break' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/break'\"
else
echo shar: Extracting \"'./help/break'\" \(218 characters\)
sed "s/^X//" >'./help/break' <<'END_OF_FILE'
Xbreak
X This command may be invoked only inside the body of a
X loop command such as for or foreach. It returns a
X TCL_BREAK code to signal the innermost containing loop
X command to return immediately.
X
END_OF_FILE
if test 218 -ne `wc -c <'./help/break'`; then
echo shar: \"'./help/break'\" unpacked with wrong size!
fi
# end of './help/break'
fi
if test -f './help/trace' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/trace'\"
else
echo shar: Extracting \"'./help/trace'\" \(212 characters\)
sed "s/^X//" >'./help/trace' <<'END_OF_FILE'
X
XOnce you have called TclaInitTrace, you may execute 'trace level' to
Xstart tracing, where level is the call depth you want to start tracing
Xat. (For more info, check out the trace(3) stuff in the Tcl manual.)
X
END_OF_FILE
if test 212 -ne `wc -c <'./help/trace'`; then
echo shar: \"'./help/trace'\" unpacked with wrong size!
fi
# end of './help/trace'
fi
if test -f './help/results' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/results'\"
else
echo shar: Extracting \"'./help/results'\" \(2213 characters\)
sed "s/^X//" >'./help/results' <<'END_OF_FILE'
XCOMMAND RESULTS
X
X Each command produces two results: a code and a string.
X The code indicates whether the command completed
X successfully or not, and the string gives additional
X information. The valid codes are defined in tcl.h, and are:
X
X TCL_OK This is the normal return code, and
X indicates that the command
X completed succesfully. The string
X gives the command's return value.
X
X TCL_ERROR Indicates that an error occurred;
X the string gives a message
X describing the error. The variable
X errorInfo will contain additional
X information describing which
X commands and procedures were being
X executed when the error occurred.
X
X TCL_RETURN Indicates that the return command
X has been invoked, and that the
X current procedure (or top-level
X command or source command) should
X return immediately. The string
X gives the return value for the
X procedure or command.
X
X TCL_BREAK Indicates that the break command
X has been invoked, so the innermost
X loop should abort immediately. The
X string should always be empty.
X
X TCL_CONTINUE Indicates that the continue command
X has been invoked, so the innermost
X loop should go on to the next
X iteration. The string should
X always be empty.
X
X caller. If there are several nested invocations of the Tcl
X interpreter in progress, then each nested command will
X usually return the error to its caller, until eventually the
X error is reported to the top-level application code. The
X application will then display the error message for the
X user.
X
X In a few cases, some commands will handle certain ``error''
X conditions themselves and not return them upwards. For
X example, the for command checks for the TCL_BREAK code; if
X it occurs, then for stops executing the body of the loop and
X returns TCL_OK to its caller. The for command also handles
X TCL_CONTINUE codes and the procedure interpreter handles
X TCL_RETURN codes. The catch command allows Tcl programs to
X catch errors and handle them without aborting command
X interpretation any further.
X
END_OF_FILE
if test 2213 -ne `wc -c <'./help/results'`; then
echo shar: \"'./help/results'\" unpacked with wrong size!
fi
# end of './help/results'
fi
if test -f './help/error' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/error'\"
else
echo shar: Extracting \"'./help/error'\" \(203 characters\)
sed "s/^X//" >'./help/error' <<'END_OF_FILE'
X error message
X Returns a TCL_ERROR code, which causes command
X interpretation to be unwound. Message is a string that
X is returned to the application to indicate what went
X wrong.
X
END_OF_FILE
if test 203 -ne `wc -c <'./help/error'`; then
echo shar: \"'./help/error'\" unpacked with wrong size!
fi
# end of './help/error'
fi
if test -f './help/length' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/length'\"
else
echo shar: Extracting \"'./help/length'\" \(336 characters\)
sed "s/^X//" >'./help/length' <<'END_OF_FILE'
X length value [chars]
X If chars isn't specified, treats value as a list and
X returns the number of elements in the list. If chars
X is specified (or any abbreviation of it), then length
X treats value as a string and returns the number of
X characters in it (not including the terminating null
X character).
X
END_OF_FILE
if test 336 -ne `wc -c <'./help/length'`; then
echo shar: \"'./help/length'\" unpacked with wrong size!
fi
# end of './help/length'
fi
if test -f './help/gadgets' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/gadgets'\"
else
echo shar: Extracting \"'./help/gadgets'\" \(740 characters\)
sed "s/^X//" >'./help/gadgets' <<'END_OF_FILE'
X gadget add hit left top width height [relbottom] [relright]
X [relwidth] [relheight] [disabled] [up tclcode] [down tclcode]
X
X gadget add toggle ...
X (same as above)
X
X gadget add string left top width height initial [relbottom] [relright]
X [relwidth] [relheight] [selected] [disabled]
X [up tclcode] [down tclcode] [stringcenter] [stringright]
X
X gadget add integer ...
X (same as "gadget add string")
X
X gadget add proportional left top width height [relbottom] [relright]
X [relwidth] [relheight] [selected] [disabled]
X [up tclcode] [down tclcode]
X
X not implemented yet.
X
X gadget remove gadgethandle
X
X gadget on gadgethandle
X
X gadget off gadgethandle
X
X gadget value gadgethandle
X
X gadget setvalue gadgethandle value
X
X gadget refresh
END_OF_FILE
if test 740 -ne `wc -c <'./help/gadgets'`; then
echo shar: \"'./help/gadgets'\" unpacked with wrong size!
fi
# end of './help/gadgets'
fi
if test -f './help/global' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/global'\"
else
echo shar: Extracting \"'./help/global'\" \(424 characters\)
sed "s/^X//" >'./help/global' <<'END_OF_FILE'
X global varname varname ...
X This command is ignored unless a Tcl procedure is being
X interpreted. If so, then it declares the given
X varname's to be global variables rather than local
X ones. For the duration of the current procedure (and
X only while executing in the current procedure), any
X reference to any of the varnames will be bound to a
X global variable instead of a local one.
X
END_OF_FILE
if test 424 -ne `wc -c <'./help/global'`; then
echo shar: \"'./help/global'\" unpacked with wrong size!
fi
# end of './help/global'
fi
if test -f './help/programs' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/programs'\"
else
echo shar: Extracting \"'./help/programs'\" \(214 characters\)
sed "s/^X//" >'./help/programs' <<'END_OF_FILE'
XThe "programs" command takes no arguments and returns a list containing
Xthe program names (port names) of all other programs that have Tcl ports,
Xwhich is all currently running programs that have called TclaInit.
X
END_OF_FILE
if test 214 -ne `wc -c <'./help/programs'`; then
echo shar: \"'./help/programs'\" unpacked with wrong size!
fi
# end of './help/programs'
fi
if test -f './help/info' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/info'\"
else
echo shar: Extracting \"'./help/info'\" \(3369 characters\)
sed "s/^X//" >'./help/info' <<'END_OF_FILE'
X info option arg arg ...
X Provide information about various internals to the Tcl
X interpreter. The legal option's (which may be
X abbreviated) are:
X
X info args procname
X Returns a list containing the names of the
X arguments to procedure procname, in order.
X Procname must be the name of a Tcl command
X procedure.
X
X info body procname
X Returns the body of procedure procname. Procname
X must be the name of a Tcl command procedure.
X
X info commands [pattern]
X If pattern isn't specified, returns a list of
X names of all the Tcl commands, including both the
X built-in commands written in C and the command
X procedures defined using the proc command. If
X pattern is specified, only those names matching
X pattern are returned. Matching is determined
X using the same rules as for string match.
X
X info cmdcount
X Returns a count of the total number of commands
X that have been invoked in this interpreter.
X
X info default procname arg varname
X Procname must be the name of a Tcl command
X procedure and arg must be the name of an argument
X to that procedure. If arg doesn't have a default
X value then the command returns 0. Otherwise it
X returns 1 and places the default value of arg into
X variable varname.
X
X info globals [pattern]
X If pattern isn't specified, returns a list of all
X the names of currently-defined global variables.
X If pattern is specified, only those names matching
X pattern are returned. Matching is determined
X using the same rules as for string match.
X
X info level [number]
X If number is not specified, this command returns a
X number giving the stack level of the invoking
X procedure, or 0 if the command is invoked at top-
X level. If number is specified, then the result is
X a list consisting of the name and arguments for
X the procedure call at level number on the stack.
X If number is positive then it selects a particular
X stack level (1 refers to the top-most active
X procedure, 2 to the procedure it called, and so
X on); otherwise it gives a level relative to the
X current level (0 refers to the current procedure,
X -1 to its caller, and so on). See the uplevel
X command for more information on what stack levels
X mean.
X
X info locals [pattern]
X If pattern isn't specified, returns a list of all
X the names of currently-defined local variables,
X including arguments to the current procedure, if
X any. If pattern is specified, only those names
X matching pattern are returned. Matching is
X determined using the same rules as for string
X match.
X
X info procs [pattern]
X If pattern isn't specified, returns a list of all
X the names of Tcl command procedures. If pattern
X is specified, only those names matching pattern
X are returned. Matching is determined using the
X same rules as for string match.
X
X info tclversion
X Returns the version number for this version of Tcl
X in the form x.y, where changes to x represent
X major changes with probable incompatibilities and
X changes to y represent small enhancements and bug
X fixes that retain backward compatibility.
X
X info vars
X Returns a list of all the names of currently-
X visible variables, including both locals and
X currently-visible globals.
X
END_OF_FILE
if test 3369 -ne `wc -c <'./help/info'`; then
echo shar: \"'./help/info'\" unpacked with wrong size!
fi
# end of './help/info'
fi
if test -f './help/resources' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/resources'\"
else
echo shar: Extracting \"'./help/resources'\" \(183 characters\)
sed "s/^X//" >'./help/resources' <<'END_OF_FILE'
X
X resource list banks
X
Xreturns a list containing the names of all the banks, and
X
X
X resource list entries foo
X
Xwill return a list containing the names of all the entries in bank foo.
END_OF_FILE
if test 183 -ne `wc -c <'./help/resources'`; then
echo shar: \"'./help/resources'\" unpacked with wrong size!
fi
# end of './help/resources'
fi
if test -f './help/range' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/range'\"
else
echo shar: Extracting \"'./help/range'\" \(1124 characters\)
sed "s/^X//" >'./help/range' <<'END_OF_FILE'
X range value first last [chars]
X Return a range of fields or characters from value. If
X the chars keyword isn't specified, then value must be a
X list and range will return a new list consisting of
X elements first through last, inclusive. The special
X keyword end may be specified for last; in this case all
X the elements of value starting at first are returned.
X If the chars keyword, or any abbreviation of it, is
X specified, then range treats value as a character
X string and returns characters first through last of it,
X inclusive. Once again, the end keyword may be used for
X last. In both cases if a last value is specified
X greater than the size of value it is equivalent to
X specifying end; if last is less than first then an
X empty string is returned. Note: ``range value first
X first'' does not always produce the same results as
X ``index value first'' (although it often does for
X simple fields that aren't enclosed in braces); it
X does, however, produce exactly the same results as
X ``list [index value first]''
X
END_OF_FILE
if test 1124 -ne `wc -c <'./help/range'`; then
echo shar: \"'./help/range'\" unpacked with wrong size!
fi
# end of './help/range'
fi
if test -f './help/tcl' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/tcl'\"
else
echo shar: Extracting \"'./help/tcl'\" \(962 characters\)
sed "s/^X//" >'./help/tcl' <<'END_OF_FILE'
X
XTcl stands for Tool Command Language, and was created by Dr. John
XOusterhout of the University of California at Berkeley, as a library
Xpackage to be embedded in various tools (editors, debuggers, terminal
Xemulators, etc) as the tool's command interpreter. Tcl provides a simple
Xprogramming language, a set of built-in commands, and has a C interface
Xthat tools can use to add application-specific commands to the base set
Xprovided by Tcl.
X
XTcl is supposed to be pronounced "tickle," but most people seem to end
Xup calling it T C L.
X
XTcl was brought to fairly widespread attention by the paper "Tcl: An
XEmbeddable Command Language," which was presented at the Winter '90
XUSENIX conference. The development of Tcl by Dr. Ousterhout and his
Xgraduate students was supported in part by the National Science
XFoundation under Grant ECS-8351961.
X
XTcl is freely distributable, subject to a minimal requirement that
Xcopyright notices be maintained where present.
END_OF_FILE
if test 962 -ne `wc -c <'./help/tcl'`; then
echo shar: \"'./help/tcl'\" unpacked with wrong size!
fi
# end of './help/tcl'
fi
if test -f './help/expr' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/expr'\"
else
echo shar: Extracting \"'./help/expr'\" \(115 characters\)
sed "s/^X//" >'./help/expr' <<'END_OF_FILE'
X expr arg
X Calls the expression processor to evaluate arg, and
X returns the result as a decimal string.
X
END_OF_FILE
if test 115 -ne `wc -c <'./help/expr'`; then
echo shar: \"'./help/expr'\" unpacked with wrong size!
fi
# end of './help/expr'
fi
if test -f './help/glob' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/glob'\"
else
echo shar: Extracting \"'./help/glob'\" \(161 characters\)
sed "s/^X//" >'./help/glob' <<'END_OF_FILE'
X glob filename
X This command performs filename globbing, using csh |
X rules. The returned value from glob is the list of |
X expanded filenames.
X
END_OF_FILE
if test 161 -ne `wc -c <'./help/glob'`; then
echo shar: \"'./help/glob'\" unpacked with wrong size!
fi
# end of './help/glob'
fi
if test -f './help/display' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/display'\"
else
echo shar: Extracting \"'./help/display'\" \(1194 characters\)
sed "s/^X//" >'./help/display' <<'END_OF_FILE'
XThe display command draws into the current window as set by the "window
Xcurrent" command.
X
X display draw x y
X draw from the current drawing position to window-relative (x,y)
X
X display move x y
X move the current drawing position to window-relative (x,y)
X
X display text message
X write text message at the current drawing position
X
X display apen value
X set the color of the A-pen to value
X
X display bpen value
X set the color of the B-pen to value
X
X display mode [jam1] [jam2] [complement] [inversvid]
X set the draw mode to the logical OR of all the specifiers
X following "mode"
X
X display pixel x y
X draw a pixel at window-relative location (x,y)
X
X display textwidth text
X determine the width "text" would occupy if output
X to the current window with the current attributes
X
X display fontheight
X return the height of the current font in pixels
X
X display font fonthandle
X select for the current window the font identified by fonthandle,
X where fonthandle was returned by a "font open" command
X
X display fontstyle [normal] [underlined] [bold] [italic] [extended]
X do a SetSoftStyle on the font for the current window to be
X the logical "or" of underlined, bold, italic and extended.
X
X
END_OF_FILE
if test 1194 -ne `wc -c <'./help/display'`; then
echo shar: \"'./help/display'\" unpacked with wrong size!
fi
# end of './help/display'
fi
if test -f './help/expressions' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/expressions'\"
else
echo shar: Extracting \"'./help/expressions'\" \(3723 characters\)
sed "s/^X//" >'./help/expressions' <<'END_OF_FILE'
XEXPRESSIONS
X A Tcl expression has C-like syntax and evaluates to an integer
X result. Expressions may contain integer values, variable
X names in $ notation (the variables' values must be integer
X strings), commands (embedded in brackets) that produce
X integer string results, parentheses for grouping, and
X operators. Numeric values, whether they are passed directly
X or through variable or command substitution, may be
X specified either in decimal (the normal case), in octal (if
X the first character of the value is 0), or in hexadecimal
X (if the first two characters of the value are 0x). The
X valid operators are listed below, grouped in decreasing
X order of precedence:
X
X - ~ ! Unary minus, bit-wise NOT, logical NOT.
X
X * / % Multiply, divide, remainder.
X
X + - Add and subtract.
X
X << >> Left and right shift.
X
X < > <= >= Boolean less, greater, less than or
X equal, and greater than or equal. Each
X operator produces 1 if the condition is
X true, 0 otherwise.
X
X == != Boolean equal and not equal. Each
X operator produces a zero/one result.
X
X & Bit-wise AND.
X
X ^ Bit-wise exclusive OR.
X
X | Bit-wise OR.
X
X && Logical AND. Produces a 1 result if
X both operands are non-zero, 0 otherwise.
X
X || Logical OR. Produces a 0 result if both
X operands are zero, 1 otherwise.
X
X See the C manual for more details on the results produced by
X each operator. All of the binary operators group left-to-
X right within the same precedence level. For example, the
X expression
X
X (4*2) < 7
X
X evaluates to 0. Evaluating the expression string
X
X ($a + 3) < [set b]
X
X will cause the values of the variables a and b to be
X examined; the result will be 1 if b is greater than a by at
X least 3; otherwise the result will be 0.
X
X In general it is safest to enclose an expression in braces
X when entering it in a command: otherwise, if the expression
X contains any white space then the Tcl interpreter will split
X it among several arguments. For example, the command
X
X expr $a + $b
X
X results in three arguments being passed to expr: $a, +, and
X $b. In addition, if the expression isn't in braces then the
X Tcl interpreter will perform variable and command
X substitution immediately (it will happen in the command
X parser rather than in the expression parser). In many cases
X the expression is being passed to a command that will
X evaluate the expression later (or even many times if, for
X example, the expression is to be used to decide when to exit
X a loop). Usually the desired goal is to re-do the variable
X or command substitutions each time the expression is
X evaluated, rather than once and for all at the beginning.
X For example, the command
X
X for {set i 1} $i<=10 {set i [expr $i+1]} {...}
X
X is probably intended to iterate over all values of i from 1
X to 10. After each iteration of the body of the loop, for
X will pass its second argument to the expression evaluator to
X see whether or not to continue processing. Unfortunately,
X in this case the value of i in the second argument will be
X substituted once and for all when the for command is parsed.
X If i was 0 before the for command was invoked then for's
X second argument will be 0<=10 which will always evaluate to
X 1, even though i's value eventually becomes greater than 10.
X In the above case the loop will never terminate. By placing
X the expression in braces, the substitution of i's value will
X be delayed; it will be re-done each time the expression is
X evaluated, which is probably the desired result.
X
END_OF_FILE
if test 3723 -ne `wc -c <'./help/expressions'`; then
echo shar: \"'./help/expressions'\" unpacked with wrong size!
fi
# end of './help/expressions'
fi
if test -f './help/rename' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/rename'\"
else
echo shar: Extracting \"'./help/rename'\" \(254 characters\)
sed "s/^X//" >'./help/rename' <<'END_OF_FILE'
X rename oldName newName
X Rename the command that used to be called oldName so
X that it is now called newName. If newName is an empty
X string (e.g. {}) then oldName is deleted. The rename
X command returns an empty string as result.
X
END_OF_FILE
if test 254 -ne `wc -c <'./help/rename'`; then
echo shar: \"'./help/rename'\" unpacked with wrong size!
fi
# end of './help/rename'
fi
if test -f './help/catch' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/catch'\"
else
echo shar: Extracting \"'./help/catch'\" \(880 characters\)
sed "s/^X//" >'./help/catch' <<'END_OF_FILE'
X catch command [varName]
X The catch command may be used to prevent errors from
X aborting command interpretation. Catch calls the Tcl
X interpreter recursively to execute command, and always
X returns a TCL_OK code, regardless of any errors that
X might occur while executing command. The return value
X from catch is a decimal string giving the code returned
X by the Tcl interpreter after executing command. This
X will be 0 (TCL_OK) if there were no errors in command;
X otherwise it will have a non-zero value corresponding
X to one of the exceptional return codes (see tcl.h for
X the definitions of code values). If the varName
X argument is given, then it gives the name of a
X variable; catch will set the value of the variable to
X the string returned from command (either a result or an
X error message).
X
END_OF_FILE
if test 880 -ne `wc -c <'./help/catch'`; then
echo shar: \"'./help/catch'\" unpacked with wrong size!
fi
# end of './help/catch'
fi
if test -f './help/menu' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/menu'\"
else
echo shar: Extracting \"'./help/menu'\" \(518 characters\)
sed "s/^X//" >'./help/menu' <<'END_OF_FILE'
Xmenu
X----
X
X menu add windowhandle menuname itemname subitemname proc
X
XThe "menu add" command takes a window name, menu name, item name and
Xoptional subitem name (send an empty string if your item doesn't have
Xsubitems), creates a corresponding menu entry for the named window,
Xand tags the item with the procedure (proc) or code to execute. When
Xthe menu entry is selected, the attached Tcl code will be selected.
X
XThe menu is changed for the current window. Use the "window current"
Xcommand to change windows.
X
END_OF_FILE
if test 518 -ne `wc -c <'./help/menu'`; then
echo shar: \"'./help/menu'\" unpacked with wrong size!
fi
# end of './help/menu'
fi
if test -f './help/window' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/window'\"
else
echo shar: Extracting \"'./help/window'\" \(1321 characters\)
sed "s/^X//" >'./help/window' <<'END_OF_FILE'
X
X
XWindow commands are:
X
X window open left top width height title
X create the specified window, set up a null menu strip, add
X the window to the interpreter's window list (handled through
X the clientdata structure -- no changes were made to the
X interpreter to support this), make it the current window,
X and return a window handle
X
X window close windowhandle
X close the specified window, remove it from the window list,
X discard its menu list, etc, etc
X
X window limits windowhandle minwidth minheight maxwidth maxheight
X set new max and min size limits for the specified window
X
X window title windowhandle newtitle
X set the titles for the window (buggy)
X
X window front windowhandle
X move the specified window to the front
X
X window back windowhandle
X move the specified window to the back
X
X window move windowhandle deltax deltay
X move the specified window by delta
X
X window size windowhandle deltax deltay
X resize the specified window
X
X window current windowhandle
X make the specified window the current window (for the display
X command)
X
X window blank windowhandle
X blanks the specified window draw area, more or less
X
X window width windowhandle
X returns the width of the specified window
X
X window height windowhandle
X returns the height of the specified window
X
X
XBUGS
X
Xtitles don't work right
X
END_OF_FILE
if test 1321 -ne `wc -c <'./help/window'`; then
echo shar: \"'./help/window'\" unpacked with wrong size!
fi
# end of './help/window'
fi
if test -f './help/set' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/set'\"
else
echo shar: Extracting \"'./help/set'\" \(500 characters\)
sed "s/^X//" >'./help/set' <<'END_OF_FILE'
X set varname [value]
X If value isn't specified, then return the current value
X of varname. If value is specified, then set the value
X of varname to value, creating a new variable if one
X doesn't already exist. If no procedure is active, then
X varname refers to a global variable. If a procedure is
X active, then varname refers to a parameter or local
X variable of the procedure, unless the global command
X has been invoked to declare varname to be global.
X
END_OF_FILE
if test 500 -ne `wc -c <'./help/set'`; then
echo shar: \"'./help/set'\" unpacked with wrong size!
fi
# end of './help/set'
fi
if test -f './help/time' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/time'\"
else
echo shar: Extracting \"'./help/time'\" \(382 characters\)
sed "s/^X//" >'./help/time' <<'END_OF_FILE'
X time command [count]
X This command will call the Tcl interpreter count times
X to execute command (or once if count isn't specified).
X It will then return a string of the form
X
X 503 microseconds per iteration
X
X which indicates the average amount of time required per
X iteration, in microseconds. Time is measured in
X elapsed time, not CPU time.
X
END_OF_FILE
if test 382 -ne `wc -c <'./help/time'`; then
echo shar: \"'./help/time'\" unpacked with wrong size!
fi
# end of './help/time'
fi
if test -f './help/endeventloop' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/endeventloop'\"
else
echo shar: Extracting \"'./help/endeventloop'\" \(178 characters\)
sed "s/^X//" >'./help/endeventloop' <<'END_OF_FILE'
X
X'endeventloop'
X
XThe command 'endeventloop' ends the event loop. Please do a "help
Xeventloop" and check the documentation for more information on how
Xevent loops work in Tcla.
END_OF_FILE
if test 178 -ne `wc -c <'./help/endeventloop'`; then
echo shar: \"'./help/endeventloop'\" unpacked with wrong size!
fi
# end of './help/endeventloop'
fi
if test -f './help/case' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/case'\"
else
echo shar: Extracting \"'./help/case'\" \(1007 characters\)
sed "s/^X//" >'./help/case' <<'END_OF_FILE'
X case string [in] patList body patList body ...
X Match string against each of the patList arguments in
X order. If one matches, then evaluate the following
X body argument by passing it recursively to the Tcl
X interpreter, and return the result of that evaluation.
X Each patList argument consists of a single pattern or
X list of patterns. Each pattern may contain any of the
X wild-cards described under string match. If a patList
X argument is default, the corresponding body will be
X evaluated if no patList matches string. If no patList
X argument matches string and no default is given, then
X the case command returns an empty string. For example,
X
X case abc in {a b} {format 1} default {format 2} a* {format 3}
X
X will return 3,
X
X case a in {a b} {format 1} default {format 2} a* {format 3}
X
X will return 1, and
X
X case xyz {a b} {format 1} default {format 2} a* {format 3}
X
X will return 2.
X
END_OF_FILE
if test 1007 -ne `wc -c <'./help/case'`; then
echo shar: \"'./help/case'\" unpacked with wrong size!
fi
# end of './help/case'
fi
if test -f './help/source' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/source'\"
else
echo shar: Extracting \"'./help/source'\" \(581 characters\)
sed "s/^X//" >'./help/source' <<'END_OF_FILE'
X source fileName
X Read file fileName and pass the contents to the Tcl
X interpreter as a sequence of commands to execute in the
X normal fashion. The return value of source is the
X return value of the last command executed from the
X file. If an error occurs in executing the contents of
X the file, then the source command will return that
X error. If a return command is invoked from within the
X file, the remainder of the file will be skipped and the
X source command will return normally with the result
X from the return command.
X
END_OF_FILE
if test 581 -ne `wc -c <'./help/source'`; then
echo shar: \"'./help/source'\" unpacked with wrong size!
fi
# end of './help/source'
fi
if test -f './help/lists' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/lists'\"
else
echo shar: Extracting \"'./help/lists'\" \(1265 characters\)
sed "s/^X//" >'./help/lists' <<'END_OF_FILE'
XLISTS
X
X A list is just a string with a list-like structure consisting
X of fields separated by white space. For example, the string
X
X Al Sue Anne John
X
X is a list with four elements or fields. Lists have the same
X basic structure as command strings, except that a newline
X character in a list is treated as a field separator just
X like space or tab. Conventions for braces and backslashes
X are the same for lists as for commands. For example, the
X string
X
X a b\ c {d e {f g h}}
X
X is a list with three elements: a, b c, and d e {f g h}.
X Whenever an element is extracted from a list, the same rules
X about backslashes and braces are applied as for commands.
X Thus in the example above when the third element is
X extracted from the list, the result is
X
X d e {f g h}
X
X (when the field was extracted, all that happened was to
X strip off the outermost layer of braces). Command
X substitution is never made on a list (at least, not by the
X list-processing commands; the list can always be passed to
X the Tcl interpreter for evaluation).
X
X The Tcl commands concat, foreach, index, length, list, and
X range allow you to build lists, extract elements from them,
X search them, and perform other list-related functions.
X
END_OF_FILE
if test 1265 -ne `wc -c <'./help/lists'`; then
echo shar: \"'./help/lists'\" unpacked with wrong size!
fi
# end of './help/lists'
fi
if test -f './help/eventloop' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/eventloop'\"
else
echo shar: Extracting \"'./help/eventloop'\" \(692 characters\)
sed "s/^X//" >'./help/eventloop' <<'END_OF_FILE'
X
X'eventloop'
X
XWhen your Tcl program executes "eventloop", it will then enter the
Xeventloop. This loop receives Intuition messages and commands from
Xother Tcl programs and processes them.
X
XOnly when a program is executing 'eventloop' can it receive, process
Xand reply to commands sent from other Tcl programs. If you send a
Xmessage to a Tcl program that isn't executing 'eventloop', you will
Xhang until it does and receives and processes your message. Asynchronous
Xmessages sent by the "post" command will not cause the sender to hang.
X
XThe command 'endeventloop' ends the event loop. If program foo is
Xexecuting eventloop, doing a 'send foo endeventloop' will cause it
Xto exit the loop.
END_OF_FILE
if test 692 -ne `wc -c <'./help/eventloop'`; then
echo shar: \"'./help/eventloop'\" unpacked with wrong size!
fi
# end of './help/eventloop'
fi
if test -f './help/commands' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/commands'\"
else
echo shar: Extracting \"'./help/commands'\" \(729 characters\)
sed "s/^X//" >'./help/commands' <<'END_OF_FILE'
XBUILT-IN COMMANDS
X The Tcl library provides the following built-in commands,
X which will be available in any application using Tcl. In
X addition to these built-in commands, there may be additional
X commands defined by each application, plus commands defined
X as Tcl procedures. In the command syntax descriptions
X below, optional arguments are indicated by enclosing their
X names in brackets; apologies in advance for the confusion
X between this descriptive use of brackets and the use of
X brackets to invoke command substitution. Words in boldface
X are literals that you type verbatim to Tcl. Words in
X italics are meta-symbols; they act as names to refer to a
X class of values that you can type.
X
END_OF_FILE
if test 729 -ne `wc -c <'./help/commands'`; then
echo shar: \"'./help/commands'\" unpacked with wrong size!
fi
# end of './help/commands'
fi
if test -f './help/procedures' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/procedures'\"
else
echo shar: Extracting \"'./help/procedures'\" \(478 characters\)
sed "s/^X//" >'./help/procedures' <<'END_OF_FILE'
XPROCEDURES
X Tcl allows you to extend the command interface by defining
X procedures. A Tcl procedure can be invoked just like any
X other Tcl command (it has a name and it receives one or more
X arguments). The only difference is that its body isn't a
X piece of C code linked into the program; it is a string
X containing one or more other Tcl commands. See the proc
X command for information on how to define procedures and what
X happens when they are invoked.
X
END_OF_FILE
if test 478 -ne `wc -c <'./help/procedures'`; then
echo shar: \"'./help/procedures'\" unpacked with wrong size!
fi
# end of './help/procedures'
fi
if test -f './help/post' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/post'\"
else
echo shar: Extracting \"'./help/post'\" \(1078 characters\)
sed "s/^X//" >'./help/post' <<'END_OF_FILE'
Xpost
X
Xpost program callback_routine command
X
XThe post command provides a means of sending commands to other Tcla
Xprograms that are currently running on your Amiga. "post" functions
Xlike the send command, except that post does immediately returns (rather
Xthan waiting for the remote command to execute and be replied to), and
Xthe user calling post can supply an optional callback routine, which will
Xbe sent to it by the remote program when that program finishes executing
Xthe requested Tcl command. For example,
X
X send smusloader song load foo
X
Xwould send a command to program "smusloader" to load song "foo" and
Xwait for smusloader to reply.
X
X post smusloader loaddone song load foo
X
Xwould also send a command to smusloader to load foo, but it would return
Ximmediately. Later, when foo finishes the request, it will send a
Xcommand, in this case "loaddone" to your program, with arguments being
Xthe result string and TCL_OK/TCL_ERROR return value passed as arguments
Xto your routine.
X
XIf an empty string is sent, return is still immediate but no callback
Xis performed.
X
END_OF_FILE
if test 1078 -ne `wc -c <'./help/post'`; then
echo shar: \"'./help/post'\" unpacked with wrong size!
fi
# end of './help/post'
fi
if test -f './help/tcla' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/tcla'\"
else
echo shar: Extracting \"'./help/tcla'\" \(1200 characters\)
sed "s/^X//" >'./help/tcla' <<'END_OF_FILE'
XTcla stands for Tool Command Language - Amiga, and it provides several
Xcommands (via the C interface) that have been added to Tcl to support
XAmigas, including support for CLI commands, windows, menus, resources,
Xfile requesters, alerts and message passing between Tcla programs.
XTcla was created by Karl Lehenbauer of Hackercorp.
X
XThis package contains both Tcl and Tcla, packaged as an Amiga shared
Xlibrary, tcla.library. The Tcla code is copyrighted by Hackercorp,
Xbut we allow redistribution for any purpose subject to minimal
Xrequirements regarding maintaining copyright and disclaimer messages.
X
Xtcla.library, in addition to providing the basic capabilities of Tcl, has
Xadditional support for many Amiga-specific functions, such as executing
XCLI commands and getting the result back as a string, opening and
Xmanipulating windows and processing window events, file requesters, alerts,
Xsupport for menus and gadgets, and provides sharable Tcl-based handles to
Xvarious application-specific data entities (resource banks). Further, all
XTcla programs have the ability to send and receive Tcl commands to and
Xfrom other Tcla programs. (See the Tcla documentation, or help within
XTcla.
X
END_OF_FILE
if test 1200 -ne `wc -c <'./help/tcla'`; then
echo shar: \"'./help/tcla'\" unpacked with wrong size!
fi
# end of './help/tcla'
fi
if test -f './help/displayrequest' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'./help/displayrequest'\"
else
echo shar: Extracting \"'./help/displayrequest'\" \(473 characters\)
sed "s/^X//" >'./help/displayrequest' <<'END_OF_FILE'
X
X
Xdisplayrequest - display a requester from Tcl
X
XUsage:
X
X displayrequest message yestext notext
X
XWhen executed, you will get a requester with the message text on the
Xscreen, and yestext and notext as the names of what are usually "Continue"
Xand "Cancel" gadgets.
X
Xdisplayrequest returns the string "1" to report selection of the "yes"
Xoption, and "0" to report selection of the "no" option.
X
Xexample:
X
X set result [displayrequest "Exit without saving changes?" "YES" "NO"]
END_OF_FILE
if test 473 -ne `wc -c <'./help/displayrequest'`; then
echo shar: \"'./help/displayrequest'\" unpacked with wrong size!
fi
# end of './help/displayrequest'
fi
echo shar: End of shell archive.
exit 0
--
-- uunet!sugar!karl "As long as there is a legion of superheros, all else
-- can surely be made right." -- Sensor Girl
-- Usenet access: (713) 438-5018