=head1 NAME
bc - An arbitrary precision calculator language
=head1 SYNTAX
bc [ -lwsqv ] [long-options] [ file ... ]
=head1 VERSION
This man page documents PPT I<bc>, which implementations tries to
follow the GNU implementation.
Please note that this is the man page for GNU bc(1). The PPT
implementation has significant limitations and bugs which are
described in the PPT LIMITATIONS and PPT BUGS sections. It has also
(few) extensions, which are listed in PPT EXTENSIONS.
=head1 DESCRIPTION
I<bc> is a language that supports arbitrary precision numbers with
interactive execution of statements. There are some similarities in
the syntax to the C programming language. A standard math library is
available by command line option. If requested, the math library is
defined before processing any files. I<bc> starts by processing code
from all the files listed on the command line in the order listed.
After all files have been processed, I<bc> reads from the standard
input. All code is executed as it is read. (If a file contains a
command to halt the processor, I<bc> will never read from the standard
input.)
This version of I<bc> contains several extensions beyond traditional I<bc>
implementations and the POSIX draft standard. Command line options
can cause these extensions to print a warning or to be rejected. This
document describes the language accepted by this processor.
Extensions will be identified as such.
=head2 OPTIONS
=over 4
=item -l
Define the standard math library.
=item -w
Give warnings for extensions to POSIX I<bc>.
=item -s
Process exactly the POSIX I<bc> language.
=item -q
Do not print the normal GNU I<bc> welcome.
=item -v
Print the version number and copyright and quit.
=item --mathlib
Define the standard math library.
=item --warn
Give warnings for extensions to POSIX I<bc>.
=item --standard
Process exactly the POSIX I<bc> language.
=item --quiet
Do not print the normal GNU I<bc> welcome.
=item --version
Print the version number and copyright and quit.
=back
=head2 NUMBERS
The most basic element in I<bc> is the number. Numbers are arbitrary
precision numbers. This precision is both in the integer part and the
fractional part. All numbers are represented internally in decimal
and all computation is done in decimal. (This version truncates
results from divide and multiply operations.) There are two
attributes of numbers, the length and the scale. The length is the
total number of significant decimal digits in a number and the scale
is the total number of decimal digits after the decimal point. For
example: .000001 has a length of 6 and scale of 6. 1935.000 has a
length of 7 and a scale of 3.
=head2 VARIABLES
Numbers are stored in two types of variables, simple variables and
arrays. Both simple variables and array variables are named. Names
begin with a letter followed by any number of letters, digits and
underscores. All letters must be lower case. (Full alpha-numeric
names are an extension. In POSIX I<bc> all names are a single lower case
letter.) The type of variable is clear by the context because all
array variable names will be followed by brackets ([]).
There are four special variables, B<scale>, B<ibase>, B<obase>, and
B<last>. B<scale> defines how some operations use digits after the
decimal point. The default value of B<scale> is 0. B<ibase> and
B<obase> define the conversion base for input and output numbers. The
default for both input and output is base 10. B<last> (an extension)
is a variable that has the value of the last printed number. These
will be discussed in further detail where appropriate. All of these
variables may have values assigned to them as well as used in
expressions.
=head2 COMMENTS
Comments in I<bc> start with the characters /* and end with the
characters */. Comments may start anywhere and appear as a single
space in the input. (This causes comments to delimit other input
items. For example, a comment can not be found in the middle of a
variable name.) Comments include any newlines (end of line) between
the start and the end of the comment.
To support the use of scripts for I<bc>, a single line comment has been
added as an extension. A single line comment starts at a #
character and continues to the next end of the line. The end of line
character is not part of the comment and is processed normally.
=head2 EXPRESSIONS
The numbers are manipulated by expressions and statements. Since the
language was designed to be interactive, statements and expressions
are executed as soon as possible. There is no "main" program.
Instead, code is executed as it is encountered. (Functions,
discussed in detail later, are defined when encountered.)
A simple expression is just a constant. I<bc> converts constants into
internal decimal numbers using the current input base, specified by
the variable B<ibase>. (There is an exception in functions.) The
legal values of B<ibase> are 2 through 16. Assigning a value outside
this range to B<ibase> will result in a value of 2 or 16. Input
numbers may contain the characters 0-9 and A-F. (Note: They must be
capitals. Lower case letters are variable names.) Single digit
numbers always have the value of the digit regardless of the value of
ibase. (i.e. A = 10.) For multidigit numbers, I<bc> changes all input
digits greater or equal to B<ibase> to the value of C<ibase-1>. This
makes the number FFF always be the largest 3 digit number of the input
base.
Full expressions are similar to many other high level languages.
Since there is only one kind of number, there are no rules for mixing
types. Instead, there are rules on the scale of expressions. Every
expression has a scale. This is derived from the scale of original
numbers, the operation performed and in many cases, the value of the
variable scale. Legal values of the variable scale are 0 to the
maximum number representable by a C integer.
In the following descriptions of legal expressions, "expr" refers to a
complete expression and "var" refers to a simple or an array variable.
A simple variable is just a name and an array variable is specified as
name[expr] Unless specifically mentioned the scale of the result is
the maximum scale of the expressions involved.
=over 4
=item - expr
The result is the negation of the expression.
=item ++ var
The variable is incremented by one and the new value is the result of
the expression.
=item -- var
The variable is decremented by one and the new value is the result of
the expression.
=item var ++
The result of the expression is the value of the variable and then the
variable is incremented by one.
=item var --
The result of the expression is the value of the variable and then the
variable is decremented by one.
=item expr + expr
The result of the expression is the sum of the two expressions.
=item expr - expr
The result of the expression is the difference of the two expressions.
=item expr * expr
The result of the expression is the product of the two expressions.
=item expr / expr
The result of the expression is the quotient of the two expressions.
The scale of the result is the value of the variable scale.
=item expr % expr
The result of the expression is the "remainder" and it is computed in
the following way. To compute a%b, first a/b is computed to scale
digits. That result is used to compute a-(a/b)*b to the scale of the
maximum of scale+scale(b) and scale(a). If scale is set to zero and
both expressions are integers this expression is the integer remainder
function.
=item expr ^ expr
The result of the expression is the value of the first raised to the
second. The second expression must be an integer. (If the second
expression is not an integer, a warning is generated and the
expression is truncated to get an integer value.) The scale of the
result is scale if the exponent is negative. If the exponent is
positive the scale of the result is the minimum of the scale of the
first expression times the value of the exponent and the maximum of
scale and the scale of the first expression. (e.g. scale(a^b) =
min(scale(a)*b, max(scale, scale(a))).) It should be noted that
expr^0 will always return the value of 1.
=item ( expr )
This alters the standard precedence to force the evaluation of the
expression.
=item var = expr
The variable is assigned the value of the expression.
=item var <op>= expr
This is equivalent to "var = var <op> expr" with the exception that
the "var" part is evaluated only once. This can make a difference if
"var" is an array.
Relational expressions are a special kind of expression that always
evaluate to 0 or 1, 0 if the relation is false and 1 if the relation
is true. These may appear in any legal expression. (POSIX I<bc>
requires that relational expressions are used only in if, while, and
for statements and that only one relational test may be done in them.)
The relational operators are
=item expr1 < expr2
The result is 1 if expr1 is strictly less than expr2.
=item expr1 <= expr2
The result is 1 if expr1 is less than or equal to expr2.
=item expr1 > expr2
The result is 1 if expr1 is strictly greater than expr2.
=item expr1 >= expr2
The result is 1 if expr1 is greater than or equal to expr2.
=item expr1 == expr2
The result is 1 if expr1 is equal to expr2.
=item expr1 != expr2
The result is 1 if expr1 is not equal to expr2.
=back
Boolean operations are also legal. (POSIX I<bc> does NOT have boolean
operations). The result of all boolean operations are 0 and 1 (for
false and true) as in relational expressions. The boolean operators
are:
=over 4
=item !expr
The result is 1 if expr is 0.
=item expr && expr
The result is 1 if both expressions are non-zero.
=item expr || expr
The result is 1 if either expression is non-zero.
=back
The expression precedence is as follows: (lowest to highest)
|| operator, left associative
&& operator, left associative
! operator, nonassociative
Relational operators, left associative
Assignment operator, right associative
+ and - operators, left associative
*, / and % operators, left associative
^ operator, right associative
unary - operator, nonassociative
++ and -- operators, nonassociative
This precedence was chosen so that POSIX compliant I<bc> pro- grams
will run correctly. This will cause the use of the relational and
logical operators to have some unusual behavior when used with
assignment expressions. Consider the expression:
C<a = 3 < 5>
Most C programmers would assume this would assign the result of "3 <
5" (the value 1) to the variable "a". What this does in I<bc> is
assign the value 3 to the variable "a" and then compare 3 to 5. It is
best to use parenthesis when using relational and logical operators
with the assignment operators.
There are a few more special expressions that are provided in I<bc>.
These have to do with user defined functions and standard functions.
They all appear as "name(parameters)". See the section on functions
for user defined functions. The standard functions are:
=over 4
=item length ( expression )
The value of the length function is the number of significant digits
in the expression.
=item read ( )
The read function (an extension) will read a number from the standard
input, regardless of where the function occurs. Beware, this can
cause problems with the mixing of data and program in the standard
input. The best use for this function is in a previously written
program that needs input from the user, but never allows program code
to be input from the user. The value of the read function is the
number read from the standard input using the current value of the
variable B<ibase> for the conversion base.
=item scale ( expression )
The value of the scale function is the number of digits after the
decimal point in the expression.
=item sqrt ( expression )
The value of the sqrt function is the square root of the expression.
If the expression is negative, a run time error is generated.
=head2 STATEMENTS
Statements (as in most algebraic languages) provide the sequencing of
expression evaluation. In I<bc> statements are executed "as soon as
possible." Execution happens when a newline in encountered and there
is one or more complete statements. Due to this immediate execution,
newlines are very important in I<bc>. In fact, both a semicolon and a
newline are used as statement separators. An improperly placed
newline will cause a syntax error. Because newlines are statement
separators, it is possible to hide a newline by using the backslash
character. The sequence "<nl>", where <nl> is the newline appears to
I<bc> as whitespace instead of a newline. A statement list is a
series of statements separated by semicolons and newlines. The
following is a list of I<bc> statements and what they do: (Things
enclosed in brackets ([]) are optional parts of
the statement.)
=over 4
=item expression
This statement does one of two things. If the expression starts with
"<variable> <assignment>...", it is considered to be an assignment
statement. If the expression is not an assignment statement, the
expression is evaluated and printed to the output. After the number
is printed, a newline is printed. For example, "a=1" is an assign-
ment statement and "(a=1)" is an expression that has an embedded
assignment. All numbers that are printed are printed in the base
specified by the variable B<obase>. The legal values for B<obase> are
2 through BC_BASE_MAX. (See the section LIMITS.) For bases 2 through
16, the usual method of writing numbers is used. For bases greater
than 16, I<bc> uses a multi-character digit method of printing the
numbers where each higher base digit is printed as a base 10 number.
The multi-character digits are separated by spaces. Each digit
contains the number of characters required to represent the base ten
value of "obase-1". Since numbers are of arbitrary precision, some
numbers may not be printable on a single output line. These long
numbers will be split across lines using the "character on a line.
The maximum number of characters printed per line is 70. Due to the
interactive nature of I<bc> printing a number cause the side effect of
assigning the printed value the the special variable B<last>. This allows
the user to recover the last value printed without having to retype
the expression that printed the number. Assigning to B<last> is legal
and will overwrite the last printed value with the assigned value.
The newly assigned value will remain until the next number is printed
or another value is assigned to last. (Some installations may allow
the use of a single period (.) which is not part of a number as a
short hand notation for for B<last>.)
=item string
The string is printed to the output. Strings start with a double
quote character and contain all characters until the next double quote
character. All characters are take literally, including any newline.
No newline character is printed after the string.
=item print list
The print statement (an extension) provides another method of output.
The "list" is a list of strings and expressions separated by commas.
Each string or expression is printed in the order of the list. No
terminating newline is printed. Expressions are evaluated and their
value is printed and assigned the the variable last. Strings in the
print statement are printed to the output and may contain special
characters. Special characters start with the backslash character (.
The special characters recognized by I<bc> are "a" (alert or bell),
"b" (backspace), "f" (form feed), "n" (newline), "r" (carriage
return), "q" (double quote), "t" (tab), and "\\" the backslash will be
ignored.
=item { statement_list }
This is the compound statement. It allows multiple statements to be
grouped together for execution.
=item if ( expression ) statement1 [else statement2]
The if statement evaluates the expression and executes B<statement1>
or B<statement2> depending on the value of the expression. If the
expression is non-zero, B<statement1> is executed. If B<statement2>
is present and the value of the expression is 0, then B<statement2> is
executed. (The else clause is an extension.)
=item while ( expression ) statement
The while statement will execute the statement
while the expression is non-zero. It evaluates the
expression before each execution of the statement.
Termination of the loop is caused by a zero expres-
sion value or the execution of a break statement.
=item for ( [expression1] ; [expression2] ; [expression3] ) statement
The for statement controls repeated execution of the statement.
B<Expression1> is evaluated before the loop. B<Expression2> is
evaluated before each execution of the statement. If it is non-zero,
the statement is evaluated. If it is zero, the loop is terminated.
After each execution of the statement, B<expression3> is evaluated
before the reevaluation of B<expression2>. If B<expression1> or
B<expression3> are missing, nothing is evaluated at the point they
would be evaluated. If B<expression2> is missing, it is the same as
substituting the value 1 for B<expression2>. (The optional
expressions are an extension. POSIX I<bc> requires all three
expressions.) The following is equivalent code for the for statement:
C<expression1;
while (expression2) {
statement;
expression3;
}>
=item break
This statement causes a forced exit of the most recent enclosing while
statement or for statement.
=item continue
The continue statement (an extension) causes the most recent enclosing
for statement to start the next iteration.
=item halt
The halt statement (an extension) is an executed statement that causes
the I<bc> processor to quit only when it is executed. For example,
"if (0 == 1) halt" will not cause I<bc> to terminate because the
halt is not executed.
=item return
Return the value 0 from a function. (See the section on functions.)
=item return ( expression )
Return the value of the expression from a function. (See the section
on functions.)
=back
=head2 PSEUDO STATEMENTS
These statements are not statements in the traditional sense. They
are not executed statements. Their function is performed at "compile"
time.
=over 4
=item limits
Print the local limits enforced by the local version of I<bc>. This
is an extension.
=item quit
When the quit statement is read, the I<bc> processor is terminated,
regardless of where the quit statement is found. For example, "if (0
== 1) quit" will cause I<bc> to terminate.
=item warranty
Print a longer warranty notice. This is an extension.
=back
=head2 FUNCTIONS
Functions provide a method of defining a computation that can be
executed later. Functions in I<bc> always compute a value and return
it to the caller. Function definitions are "dynamic" in the sense
that a function is undefined until a definition is encountered in the
input. That definition is then used until another definition function
for the same name is encountered. The new definition then replaces
the older definition. A function is defined as
follows:
C<define name ( parameters ) { newline auto_list statement_list }>
A function call is just an expression of the form "name(parameters)".
Parameters are numbers or arrays (an extension). In the function
definition, zero or more parameters are defined by listing their names
separated by commas. Numbers are only call by value parameters.
Arrays are only call by variable. Arrays are specified in the
parameter definition by the notation "name[]". In the function call,
actual parameters are full expressions for number parameters. The
same notation is used for passing arrays as for defining array
parameters. The named array is passed by variable to the function.
Since function definitions are dynamic, parameter numbers and types
are checked when a function is called. Any mismatch in number or
types of parameters will cause a runtime error. A runtime error will
also occur for the call to an undefined function.
The auto_list is an optional list of variables that are for "local"
use. The syntax of the auto list (if present) is "auto name, ... ;".
(The semicolon is optional.) Each name is the name of an auto
variable. Arrays may be specified by using the same notation as used
in parameters. These variables have their values pushed onto a stack
at the start of the function. The variables are then initialized to
zero and used throughout the execution of the function. At function
exit, these variables are popped so that the original value (at the
time of the function call) of these variables are restored. The
parameters are really auto variables that are initialized to a value
provided in the function call. Auto variables are different than
traditional local variables in the fact that if function A calls
function B, B may access function A's auto variables by just using the
same name, unless function B has called them auto variables. Due to
the fact that auto variables and parameters are pushed onto a stack,
I<bc> supports recursive functions.
The function body is a list of I<bc> statements. Again, statements
are separated by semicolons or newlines. B<Return> statements cause
the termination of a function and the return of a value. There are
two versions of the B<return> statement. The first form, "return",
returns the value 0 to the calling expression. The second form,
"return ( expression )", computes the value of the expression and
returns that value to the calling expression. There is an implied
"return (0)" at the end of every function. This allows a function to
terminate and return 0 without an explicit return statement.
Functions also change the usage of the variable B<ibase>. All
constants in the function body will be converted using the value of
B<ibase> at the time of the function call. Changes of B<ibase> will
be ignored during the execution of the function except for the
standard function read, which will always use the current value of
B<ibase> for conversion of numbers.
=head2 MATH LIBRARY
If I<bc> is invoked with the B<-l> option, a math library is preloaded
and the default B<scale> is set to 20. The math functions will calculate
their results to the scale set at the time of their call. The math
library defines the following functions:
=over 4
=item s (x)
The sine of x, x is in radians.
=item c (x)
The cosine of x, x is in radians.
=item a (x)
The arctangent of x, arctangent returns radians.
=item l (x)
The natural logarithm of x.
=item e (x)
The exponential function of raising e to the value x.
=item j (n,x)
The bessel function of integer order n of x.
=back
=head2 EXAMPLES
In /bin/sh, the following will assign the value of "pi" to the shell
variable pi.
C<pi=$(echo "scale=10; 4*a(1)" | bc -l)>
The following is the definition of the exponential function used in
the math library. This function is written in POSIX I<bc>.
scale = 20
/* Uses the fact that e^x = (e^(x/2))^2
When x is small enough, we use the series:
e^x = 1 + x + x^2/2! + x^3/3! + ...
*/
define e(x) {
auto a, d, e, f, i, m, v, z
/* Check the sign of x. */
if (x<0) {
m = 1
x = -x
}
/* Precondition x. */
z = scale;
scale = 4 + z + .44*x;
while (x > 1) {
f += 1;
x /= 2;
}
/* Initialize the variables. */
v = 1+x
a = x
d = 1
for (i=2; 1; i++) {
e = (a *= x) / (d *= i)
if (e == 0) {
if (f>0) while (f--) v = v*v;
scale = z
if (m) return (1/v);
return (v/1);
}
v += e
}
}
The following is code that uses the extended features of I<bc> to
implement a simple program for calculating checkbook balances. This
program is best kept in a file so that it can be used many times
without having to retype it at every use.
scale=2
print "0heck book program!0
print " Remember, deposits are negative transac-
tions.0
print " Exit by a 0 transaction.0
print "Initial balance? "; bal = read()
bal /= 1
print "0
while (1) {
"current balance = "; bal
"transaction? "; trans = read()
if (trans == 0) break;
bal -= trans
bal /= 1
}
quit
The following is the definition of the recursive factorial function.
define f (x) {
if (x <= 1) return (1);
return (f(x-1) * x);
}
=head2 READLINE OPTION
GNU I<bc> can be compiled (via a configure option) to use the GNU
readline input editor library. This allows the user to do more
editing of lines before sending them to I<bc>. It also allows for a
history of previous lines typed. When this option is selected, I<bc>
has one more special variable. This special variable, B<history> is
the number of lines of history retained. A value of -1 means that an
unlimited number of history lines are retained. This is the default
value. Setting the value of B<history> to a positive number restricts
the number of history lines to the number given. The value of 0
disables the history feature. For more information, read the user
manuals for the GNU readline and history libraries.
=head2 DIFFERENCES
This version of I<bc> was implemented from the POSIX P1003.2/D11 draft
and contains several differences and extensions relative to the draft
and traditional implementations. It is not implemented in the
traditional way using dc(1). This version is a single process which
parses and runs a byte code translation of the program. There is an
"undocumented" option (B<-c>) that causes the program to output the byte
code to the standard output instead of running it. It was mainly used
for debugging the parser and preparing the math library.
A major source of differences is extensions, where a feature is
extended to add more functionality and additions, where new features
are added. The following is the list of differences and extensions.
=over 4
=item LANG
This version does not conform to the POSIX standard in the processing
of the LANG environment variable and all environment variables
starting with LC_.
=item names
Traditional and POSIX I<bc> have single letter names for functions,
variables and arrays. They have been extended to be multi-character
names that start with a letter and may contain letters, numbers and
the underscore character.
=item Strings
Strings are not allowed to contain NUL characters. POSIX says all
characters must be included in strings.
=item last
POSIX I<bc> does not have a B<last> variable. Some implementations of
I<bc> use the period (.) in a similar way.
=item comparisons
POSIX I<bc> allows comparisons only in the if statement, the while
statement, and the second expression of the for statement. Also, only
one relational operation is allowed in each of those statements.
=item if statement, else clause
POSIX I<bc> does not have an else clause.
=item for statement
POSIX I<bc> requires all expressions to be present in the for
statement.
=item &&, ||, !
POSIX I<bc> does not have the logical operators.
=item read function
POSIX I<bc> does not have a read function.
=item print statement
POSIX I<bc> does not have a print statement .
=item continue statement
POSIX I<bc> does not have a continue statement.
=item array parameters
POSIX I<bc> does not (currently) support array parameters in full.
The POSIX grammar allows for arrays in function definitions, but does
not provide a method to specify an array as an actual parameter.
(This is most likely an oversight in the grammar.) Traditional
implementations of I<bc> have only call by value array parameters.
=item =+, =-, =*, =/, =%, =^
POSIX I<bc> does not require these "old style" assignment operators to
be defined. This version may allow these "old style" assignments.
Use the B<limits> statement to see if the installed version supports
them. If it does support the "old style" assignment operators, the
statement "a =- 1" will decrement a by 1 instead of setting a to the
value -1.
=item spaces in numbers
Other implementations of I<bc> allow spaces in numbers. For example,
"x=1 3" would assign the value 13 to the variable x. The same
statement would cause a syntax error in this version of I<bc>.
=item errors and execution
This implementation varies from other implementations in terms of what
code will be executed when syntax and other errors are found in the
program. If a syntax error is found in a function definition, error
recovery tries to find the beginning of a statement and continue to
parse the function. Once a syntax error is found in the function, the
function will not be callable and becomes undefined. Syntax errors in
the interactive execution code will invalidate the current execution
block. The execution block is terminated by an end of line that
appears after a complete sequence of statements. For example,
C<a = 1
b = 2>
has two execution blocks and
C<{ a = 1
b = 2 }>
has one execution block. Any runtime error will terminate the
execution of the current execution block. A runtime warning will not
terminate the current execution block.
=item Interrupts
During an interactive session, the SIGINT signal (usually generated by
the control-C character from the terminal) will cause execution of the
current execution block to be interrupted. It will display a
"runtime" error indicating which function was interrupted. After all
runtime structures have been cleaned up, a message will be printed to
notify the user that I<bc> is ready for more input. All previously
defined functions remain defined and the value of all non-auto
variables are the value at the point of interruption. All auto
variables and function parameters are removed during the clean up
process. During a non-interactive ses- sion, the SIGINT signal will
terminate the entire run of I<bc>.
=back
=head2 LIMITS
The following are the limits currently in place for this I<bc>
processor. Some of them may have been changed by an installation.
Use the limits statement to see the actual values.
=over 4
=item BC_BASE_MAX
The maximum output base is currently set at 999. The maximum input
base is 16.
=item BC_DIM_MAX
This is currently an arbitrary limit of 65535 as distributed. Your
installation may be different.
=item BC_SCALE_MAX
The number of digits after the decimal point is limited to INT_MAX
digits. Also, the number of digits before the decimal point is
limited to INT_MAX digits.
=item BC_STRING_MAX
The limit on the number of characters in a string is INT_MAX
characters.
=item exponent
The value of the exponent in the raise operation (^) is limited to
LONG_MAX.
=item multiply
The multiply routine may yield incorrect results if a number has more
than LONG_MAX / 90 total digits. For 32 bit longs, this number is
23,860,929 digits.
=item code size
Each function and the "main" program are limited to 16384 bytes of
compiled byte code each. This limit (BC_MAX_SEGS) can be easily
changed to have more than 16 segments of 1024 bytes.
=item variable names
The current limit on the number of unique names is 32767 for each of
simple variables, arrays and functions.
=back
=head2 ENVIRONMENT VARIABLES
The following environment variables are processed by I<bc>:
=over 4
=item POSIXLY_CORRECT
This is the same as the B<-s> option.
=item BC_ENV_ARGS
This is another mechanism to get arguments to I<bc>. The format is
the same as the command line arguments. These arguments are processed
first, so any files listed in the environent arguments are processed
before any command line argument files. This allows the user to set
up "standard" options and files to be processed at every invocation of
I<bc>. The files in the environment variables would typically contain
function definitions for functions the user wants defined every time
I<bc> is run.
=item BC_LINE_LENGTH
This should be an integer specifing the number of characters in an
output line for numbers. This includes the backslash and newline
characters for long numbers.
=back
=head1 FILES
In most installations, I<bc> is completely self-contained. Where
executable size is of importance or the C compiler does not deal with
very long strings, I<bc> will read the standard math library from the
file /usr/local/lib/libmath.b. (The actual location may vary. It may
be /lib/libmath.b.)
=head1 DIAGNOSTICS
If any file on the command line can not be opened, I<bc> will report
that the file is unavailable and terminate. Also, there are compile
and run time diagnostics that should be self-explanatory.
=head1 BUGS
Error recovery is not very good yet.
Email bug reports to bug-gnu-utils@prep.ai.mit.edu. Be sure to
include the word ``I<bc>'' somewhere in the ``Subject:'' field.
=head1 AUTHOR
Thierry Bezecourt, thbzcrt@worldnet.fr - Perl Power Tools, March 1999.
The implementation tries to follow the GNU version by Philip A. Nelson.
=head1 ACKNOWLEDGEMENTS
The author would like to thank Steve Sommars (Steve.Sommars@att.com)
for his extensive help in testing the implementation. Many great
suggestions were given. This is a much better product due to his
involvement.
=head1 PPT LIMITATIONS
This sections enumerates the limitations and extensions of this
implementations, compared with the POSIX specification and the GNU
implementation.
=over 4
=item Command line options
Only the B<-l> and B<-v> options are implemented. A B<-h> option (an
extension) gives a brief usage message. Long options are not (and will
probably not be) implemented.
=item Arbitrary precision
Due to problems using the Math::BigFloat package (and laziness), this
version does not provide arbitrary precision, but only Perl standard
precision in calculations. The B<scale>, B<ibase>, B<obase> variables
are not implemented. However, they are defined, so programs which use
them may still work.
=item Hexadecimal numbers
Not yet supported.
=item Special variables
The special variables scale, ibase, obase, last are not supported.
=item read()
Not supported (supported by GNU, not required by POSIX).
=item continue, halt
Not supported (supported by GNU, not required by POSIX).
=item limits, warranty
Not supported (supported by GNU, not required by POSIX).
=item Arrays in function parameters
Not supported (supported by GNU, not required by POSIX).
=item Readline option
Not supported (supported by GNU, not required by POSIX).
=item LANG
Not supported.
=item else clause
Not supported (supported by GNU, not required by POSIX).
=item =+, =-, =*, =/, =%, =^
Not supported (supported by GNU, not required by POSIX).
=item spaces in numbers
Not supported.
=item Interrupts
Not implemented, but some may work if you're lucky.
=item Limits
No limits (BC_BASE_MAX, etc) are defined.
=item Environment variables
Environment variables are not taken into account.
=back
=head1 PPT EXTENSIONS
The following are extensions over the POSIX specification.
=over 4
=item Long variable and function names
Identifiers may contain several lower-case characters (only one in POSIX).
This extension is also supported by GNU B<bc>.
=item operators
This implementation supports the B<&&>, B<||> and B<!> logical
operators (also supported by GNU).
=item print
Also supported by B<bc>.
=item for
Supports empty statements (also supported by GNU).
=item C<&>
You may execute a Perl command by prefixing a string with &:
C<&"print 'Hello'">
Any Perl command which contains no newline and no double quote is
allowed.
=back
=head1 PPT BUGS
In the math library, the s() (sinus) and c() (cosinus) function do not
work, bvecause they depend on the scale variable.
It's slow.
Error recovery is bad.
The documentation should be fixed.
=cut