Calc command line

    Calc has the following command line:

	calc [-c] [-C] [-d] [-D calc_debug[:resource_debug[:user_debug]]]
	     [-e] [-h] [-i] [-m mode] [-n] [-p] [-q] [-s] [-u] [-v]
	     [calc_cmd ...]

	#!/usr/local/bin/calc -S [other_flags]

	  -c   Continue reading command lines even after an scan/parse
	       error has caused the abandonment of a line.  Note that this
	       option only deals with scanning and parsing of the calc
	       language.  It does not deal with execution or run-time errors.

	       For example:

		    calc read many_errors.cal

	       will cause calc to abort on the first syntax error, whereas:

		    calc -c read many_errors.cal

	       will cause calc to try to process each line being read
	       despite the scan/parse errors that it encounters.

	       By default, calc startup resource files are
	       silently ignored if not found.  This flag will report
	       missing startup scripts unless -d is also given.


	  -C   Permit the execution of custom builtin functions.
	       Without this flag, calling the custom() builtin
	       function will simply generate an error.

	       Use of this flag may cause calc to execute functions
	       that are non-standard and that are not portable.
	       Custom builtin functions are disabled by default for
	       this reason.


	  -d   Disable the printing of the opening title.  The
	       printing of resource file debug and informational messages is
	       also disabled as if config("resource_debug", 0) had been
	       executed.

	       For example:

		    calc 'read qtime; qtime(2)'

	       will output something like:

		    qtime(utc_hr_offset) defined
		    It's nearly ten past six.

	       whereas:

		    calc -d 'read qtime; qtime(2)'

	       will just say:

		    It's nearly ten past six.

	       This flag disables the reporting of missing calc
	       startup scripts.


	  -D calc_debug[:resource_debug:[user_debug]]
	       Force the initial value of config("calc_debug"),
	       config("resource_debug") and config("user_debug").

	       The : separated strings are interpreted as signed 32
	       bit integers.  After an optional leading sign a leading
	       zero indicates octal conversion, and a leading ``0x''
	       or ``0X'' hexadecimal conversion.  Otherwise, decimal
	       conversion is assumed.

	       By default, calc_debug is 0, resource_debug is 3 and
	       user_debug is 0.

	       For more information use the following calc command:

		    help config


	  -e   Ignore any environment variables on startup.  The
	       getenv() builtin will still return values, however.


	  -h   Print a help message.  This option implies -q.  This is
	       equivalent to the calc command help help.  The help
	       facility is disabled unless the mode is 5 or 7.	See
	       -m.


	  -i   Become interactive if possible.	If calc_cmd args are given,
   	       by default, calc will execute them and exit.  This flag causes
	       calc to drop into interactive mode after the commands are
	       executed.

	       For example:

		    calc 2+5

	       will print the value 7 and exit whereas:

		    calc -i 2+5

	       will print the value 7 and prompt the user for more
	       calc commands.


	  -m mode
	       This flag sets the permission mode of calc.  It
	       controls the ability for calc to open files and execute
	       programs.  Mode may be a number from 0 to 7.

	       The mode value is interpreted in a way similar to that
	       of the chmod(1) octal mode:

		    0  do not open any file, do not execute progs
		    1  do not open any file
		    2  do not open files for reading, do not execute progs
		    3  do not open files for reading
		    4  do not open files for writing, do not execute progs
		    5  do not open files for writing
		    6  do not execute any program
		    7  allow everything (default mode)

	       If one wished to run calc from a privileged user, one
	       might want to use -m 0 in an effort to make calc
	       somewhat more secure.

	       Mode bits for reading and writing apply only on an
	       open.  Files already open are not effected.  Thus if
	       one wanted to use the -m 0 in an effort to make calc
	       somewhat more secure, but still wanted to read and
	       write a specific file, one might want to do in sh(1),
	       ksh(1), bash(1)-like shells:

		    calc -m 0 3<a.file

	       Files presented to calc in this way are opened in an
	       unknown mode.  Calc will attempt to read or write them
	       if directed.

	       If the mode disables opening of files for reading, then
	       the startup resource files are disabled as if -q was
	       given.  The reading of key bindings is also disabled
	       when the mode disables opening of files for reading.


	  -O   Use the old classic defaults instead of the default
	       configuration.  This flag as the same effect as executing
	       config("all", "oldcfg") at startup time.

	       NOTE: Older versions of calc used -n to setup a modified
	       form of the default calc configuration.  The -n flag
	       currently does  nothing.   Use of the -n flag is now
	       deprecated and may used for something else in the future.

	  -p   Pipe processing is enabled by use of -p.	 For example:

		    calc -p '2^21701-1' | fizzbin

	       In pipe mode, calc does not prompt, does not print
	       leading tabs and does not print the initial header.
	       The -p flag overrides -i.


	  -q   Disable the reading of the startup scripts.


	  -s   By default, all calc_cmd args are evaluated and
	       executed.  This flag will disable their evaluation and
	       instead make them available as strings for the argv()
	       builtin function.


	  -u   Disable buffering of stdin and stdout.


	  -v   Print the calc version number and exit.


	  CALC COMMAND ARGUMENTS

	  With no calc_cmd arguments, calc operates interactively.  If one
	  or more arguments are given on the command line and -s is NOT
	  given, then calc will read and execute them and either attempt
	  to go interactive according as the -i flag was present or absent.

	  If -s is given, calc will not evaluate any calc_cmd
	  arguments but instead make them available as strings to the
	  argv() builtin function.

	  Sufficiently simple commands with no no characters like
	  parentheses, brackets, semicolons, '*', which have special
	  interpretations in UNIX commands may be entered, possibly with
	  spaces, until the terminating newline.  For example:

			calc 23 + 47

	  should respond with display of 70, but:

			calc 23 * 47

	  may fail.  Such cases can usually be made to work as expected by
	  enclosing the command between single quotation marks as in:

			calc '23 * 47'

	  and

			calc 'print sqrt(2), exp(1)'

	  If '!' is to be used to indicate the factorial function, for
	  shells like csh for which '!' followed by a non-space character
	  is used for history substitution, it may be necessary to
	  include a space or use a backslash to escape the special
	  meaning of '!'.  For example, the command "print 27!^2" may have
	  to be replaced by "print 27! ^2" or "print 27\!^2".


	  CALC STARTUP FILES

	  Normally on startup, if the environment variable $CALCRC is
	  undefined and calc is invoked without the -q flag, or if
	  $CALCRC is defined and calc is invoked with -e, calc looks
	  for a file "startup" in the calc resource directory, .calcrc in
	  the user's home directory, and .calcinit in the current directory.
	  If one or more of these are found, they are read in succession
	  as calc scripts and their commands executed.  When defined,
	  $CALCRC is to contain a ':' separated list of names of files,
	  and if calc is then invoked without either the -q or -e flags,
	  these files are read in succession and their commands executed.
	  No error condition is produced if a listed file is not found.

	  If the mode specified by -m disables opening of files for
	  reading, then the reading of startup files is also disabled
	  as if -q was given.


	  CALC FILE SEARCH PATH

	  If the environment variable $CALCPATH is undefined, or if it
	  is defined and calc is invoked with the -e flag, when a file
	  name not beginning with /, ~ or ./, is specified as in:

			calc read myfile

	  calc searches in succession:

			./myfile
			./myfile.cal
			${LIBDIR}/myfile
			${LIBDIR}/myfile.cal
			${CUSTOMCALDIR}/myfile
			${CUSTOMCALDIR}/myfile.cal

	  If the file is found, the search stops and the commands in
	  the file are executed.  It is an error if no readable file
	  with the specified name is found.  An alternative search
	  path can be specified by defining $CALCPATH in the same way
	  as PATH is defined, as a ':' separated list of directories,
	  and then invoking calc without the -e flag.

	  Calc treats all open files, other than stdin, stdout and
	  stderr as files available for reading and writing.  One may
	  present calc with an already open file using sh(1), ksh(1),
	  bash(1)-like shells is to:

	       calc 3<open_file 4<open_file2


	  SHELL SCRIPT MODE

	  If first line of an executable file begins #! followed by the
	  absolute pathname of the calc program and the flag -S as in

	       #!/usr/local/bin/calc -S [other_flags]

	  the rest of the file will be processed in shell script mode.
	  Note that -S (UPPER CASE S) must be the first -flag on the
	  ``#!'' line.	Any optional ``other_flags'' must come after
	  the -S.

	  In shell script mode the contents of the file are read and
	  executed as if they were in a file being processed by a read
	  command, except that a "command" beginning with '#' followed by
	  whitespace and ending at the next newline is treated as a comment.
	  Any optional ``other_flags'' will be parsed first followed by
	  the later lines within the script itself.

	  In shell script mode, -s (lower case s) is always assumed.
	  In addition, -d and -p are automatically set if -i is not
	  given.

	  For example, if the file /tmp/mersenne:

	       #!/usr/local/bin/calc -S -q
	       #
	       # mersenne - an example of a calc shell script file

	       /* parse args */
	       if (argv() != 1) {
		   fprintf(files(2), "usage: %s exp\n", config("program"));
		   abort "must give one exponent arg";
	       }

	       /* print the mersenne number */
	       print "2^": argv(0) : "-1 =", 2^eval(argv(0))-1;

	  is made an executable file by:

	       chmod +x /tmp/mersenne

	  then the command line:

	       /tmp/mersenne 127

	  will print:

	       2^127-1 = 170141183460469231731687303715884105727

	  Note that because -s is assumed in shell script mode and
	  non-dashed args are made available as strings via the argv()
	  builtin function.  Therefore:

	       2^eval(argv(0))-1

	  will print the decimal value of 2^n-1 but

	       2^argv(0)-1

	  will not.

For more information use the following calc commands:

   help help
   help overview
   help config
   help argv
   help environment

## Copyright (C) 1999  Landon Curt Noll
##
## Calc is open software; you can redistribute it and/or modify it under
## the terms of the version 2.1 of the GNU Lesser General Public License
## as published by the Free Software Foundation.
##
## Calc is distributed in the hope that it will be useful, but WITHOUT
## ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
## or FITNESS FOR A PARTICULAR PURPOSE.	 See the GNU Lesser General
## Public License for more details.
##
## A copy of version 2.1 of the GNU Lesser General Public License is
## distributed with calc under the filename COPYING-LGPL.  You should have
## received a copy with calc; if not, write to Free Software Foundation, Inc.
## 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
##
## @(#) $Revision: 29.8 $
## @(#) $Id: usage,v 29.8 2006/06/01 12:04:16 chongo Exp $
## @(#) $Source: /usr/local/src/cmd/calc/help/RCS/usage,v $
##
## Under source code control:	1991/07/21 04:37:25
## File existed as early as:	1991
##
## chongo <was here> /\oo/\	http://www.isthe.com/chongo/
## Share and enjoy!  :-)	http://www.isthe.com/chongo/tech/comp/calc/