|
Packit |
70b277 |
This is ../../doc/bc.info, produced by makeinfo version 4.8 from
|
|
Packit |
70b277 |
../../doc/bc.texi.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
START-INFO-DIR-ENTRY
|
|
Packit |
70b277 |
* bc: (bc). An arbitrary precision calculator language.
|
|
Packit |
70b277 |
END-INFO-DIR-ENTRY
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
?
|
|
Packit |
70b277 |
File: bc.info, Node: Top, Next: Introduction, Prev: (dir), Up: (dir)
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
* Menu:
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
* Introduction::
|
|
Packit |
70b277 |
* Basic Elements::
|
|
Packit |
70b277 |
* Expressions::
|
|
Packit |
70b277 |
* Statements::
|
|
Packit |
70b277 |
* Functions::
|
|
Packit |
70b277 |
* Examples::
|
|
Packit |
70b277 |
* Readline and Libedit Options::
|
|
Packit |
70b277 |
* Comparison with Other Implementations::
|
|
Packit |
70b277 |
* Limits::
|
|
Packit |
70b277 |
* Environment Variables::
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
?
|
|
Packit |
70b277 |
File: bc.info, Node: Introduction, Next: Basic Elements, Prev: Top, Up: Top
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
1 Introduction
|
|
Packit |
70b277 |
**************
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
* Menu:
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
* Description::
|
|
Packit |
70b277 |
* Command Line Options::
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
?
|
|
Packit |
70b277 |
File: bc.info, Node: Description, Next: Command Line Options, Prev: Introduction, Up: Introduction
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
1.1 Description
|
|
Packit |
70b277 |
===============
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`bc' [ -hlwsqv ] [long-options] [ FILE ... ]
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`bc' is a language that supports arbitrary precision numbers with
|
|
Packit |
70b277 |
interactive execution of statements. There are some similarities in
|
|
Packit |
70b277 |
the syntax to the C programming language. A standard math library is
|
|
Packit |
70b277 |
available by command line option. If requested, the math library is
|
|
Packit |
70b277 |
defined before processing any files. `bc' starts by processing code
|
|
Packit |
70b277 |
from all the files listed on the command line in the order listed.
|
|
Packit |
70b277 |
After all files have been processed, `bc' reads from the standard
|
|
Packit |
70b277 |
input. All code is executed as it is read. (If a file contains a
|
|
Packit |
70b277 |
command to halt the processor, `bc' will never read from the standard
|
|
Packit |
70b277 |
input.)
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
This version of `bc' contains several extensions beyond traditional
|
|
Packit |
70b277 |
`bc' implementations and the POSIX draft standard. Command line
|
|
Packit |
70b277 |
options can cause these extensions to print a warning or to be
|
|
Packit |
70b277 |
rejected. This document describes the language accepted by this
|
|
Packit |
70b277 |
processor. Extensions will be identified as such.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
The author would like to thank Steve Sommars
|
|
Packit |
70b277 |
(<Steve.Sommars@att.com>) for his extensive help in testing the
|
|
Packit |
70b277 |
implementation. Many great suggestions were given. This is a much
|
|
Packit |
70b277 |
better product due to his involvement.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
Email bug reports to <bug-bc@gnu.org>. Be sure to include the word
|
|
Packit |
70b277 |
"bc" somewhere in the "Subject:" field.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
?
|
|
Packit |
70b277 |
File: bc.info, Node: Command Line Options, Next: Numbers, Prev: Description, Up: Introduction
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
1.2 Command Line Options
|
|
Packit |
70b277 |
========================
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`bc' takes the following options from the command line:
|
|
Packit |
70b277 |
`-h, --help'
|
|
Packit |
70b277 |
Print the usage and exit.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`-l, --mathlib'
|
|
Packit |
70b277 |
Define the standard math library.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`-w, --warn'
|
|
Packit |
70b277 |
Give warnings for extensions to POSIX `bc'.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`-s, --standard'
|
|
Packit |
70b277 |
Process exactly the POSIX `bc' language.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`-q, --quiet'
|
|
Packit |
70b277 |
Do not print the normal GNU `bc' welcome.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`-v, --version'
|
|
Packit |
70b277 |
Print the version number and copyright and quit.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
?
|
|
Packit |
70b277 |
File: bc.info, Node: Basic Elements, Next: Expressions, Prev: Introduction, Up: Top
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
2 Basic Elements
|
|
Packit |
70b277 |
****************
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
* Menu:
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
* Numbers::
|
|
Packit |
70b277 |
* Variables::
|
|
Packit |
70b277 |
* Comments::
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
?
|
|
Packit |
70b277 |
File: bc.info, Node: Numbers, Next: Variables, Prev: Command Line Options, Up: Basic Elements
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
2.1 Numbers
|
|
Packit |
70b277 |
===========
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
The most basic element in `bc' is the number. Numbers are arbitrary
|
|
Packit |
70b277 |
precision numbers. This precision is both in the integer part and the
|
|
Packit |
70b277 |
fractional part. All numbers are represented internally in decimal and
|
|
Packit |
70b277 |
all computation is done in decimal. (This version truncates results
|
|
Packit |
70b277 |
from divide and multiply operations.) There are two attributes of
|
|
Packit |
70b277 |
numbers, the length and the scale. The length is the total number of
|
|
Packit |
70b277 |
digits used by `bc' to represent a number and the scale is the total
|
|
Packit |
70b277 |
number of decimal digits after the decimal point. For example, .000001
|
|
Packit |
70b277 |
has a length of 6 and scale of 6, while 1935.000 has a length of 7 and
|
|
Packit |
70b277 |
a scale of 3.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
?
|
|
Packit |
70b277 |
File: bc.info, Node: Variables, Next: Comments, Prev: Numbers, Up: Basic Elements
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
2.2 Variables
|
|
Packit |
70b277 |
=============
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
Numbers are stored in two types of variables, simple variables and
|
|
Packit |
70b277 |
arrays. Both simple variables and array variables are named. Names
|
|
Packit |
70b277 |
begin with a letter followed by any number of letters, digits and
|
|
Packit |
70b277 |
underscores. All letters must be lower case. (Full alphanumeric names
|
|
Packit |
70b277 |
are an extension. In POSIX `bc' all names are a single lower case
|
|
Packit |
70b277 |
letter.) The type of variable is clear by the context because all
|
|
Packit |
70b277 |
array variable names will be followed by brackets ( [ ] ).
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
There are four special variables, SCALE, IBASE, OBASE, and LAST.
|
|
Packit |
70b277 |
SCALE defines how some operations use digits after the decimal point.
|
|
Packit |
70b277 |
The default value of SCALE is 0. IBASE and OBASE define the conversion
|
|
Packit |
70b277 |
base for input and output numbers. The default for both input and
|
|
Packit |
70b277 |
output is base 10. LAST (an extension) is a variable that has the
|
|
Packit |
70b277 |
value of the last printed number. These will be discussed in further
|
|
Packit |
70b277 |
detail where appropriate. All of these variables may have values
|
|
Packit |
70b277 |
assigned to them as well as used in expressions.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
?
|
|
Packit |
70b277 |
File: bc.info, Node: Comments, Prev: Variables, Up: Basic Elements
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
2.3 Comments
|
|
Packit |
70b277 |
============
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
Comments in `bc' start with the characters `/*' and end with the
|
|
Packit |
70b277 |
characters `*/'. Comments may start anywhere and appear as a single
|
|
Packit |
70b277 |
space in the input. (This causes comments to delimit other input
|
|
Packit |
70b277 |
items. For example, a comment can not be found in the middle of a
|
|
Packit |
70b277 |
variable name.) Comments include any newlines (end of line) between
|
|
Packit |
70b277 |
the start and the end of the comment.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
To support the use of scripts for `bc', a single line comment has
|
|
Packit |
70b277 |
been added as an extension. A single line comment starts at a `#'
|
|
Packit |
70b277 |
character and continues to the next end of the line. The end of line
|
|
Packit |
70b277 |
character is not part of the comment and is processed normally.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
?
|
|
Packit |
70b277 |
File: bc.info, Node: Expressions, Next: Statements, Prev: Basic Elements, Up: Top
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
3 Expressions
|
|
Packit |
70b277 |
*************
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
* Menu:
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
* About Expressions and Special Variables::
|
|
Packit |
70b277 |
* Basic Expressions::
|
|
Packit |
70b277 |
* Relational Expressions::
|
|
Packit |
70b277 |
* Boolean Expressions::
|
|
Packit |
70b277 |
* Precedence::
|
|
Packit |
70b277 |
* Special Expressions::
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
?
|
|
Packit |
70b277 |
File: bc.info, Node: About Expressions and Special Variables, Next: Basic Expressions, Prev: Expressions, Up: Expressions
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
3.1 About Expressions and Special Variables
|
|
Packit |
70b277 |
===========================================
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
The numbers are manipulated by expressions and statements. Since the
|
|
Packit |
70b277 |
language was designed to be interactive, statements and expressions are
|
|
Packit |
70b277 |
executed as soon as possible. There is no main program. Instead, code
|
|
Packit |
70b277 |
is executed as it is encountered. (Functions, discussed in detail
|
|
Packit |
70b277 |
later, are defined when encountered.)
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
A simple expression is just a constant. `bc' converts constants into
|
|
Packit |
70b277 |
internal decimal numbers using the current input base, specified by the
|
|
Packit |
70b277 |
variable IBASE. (There is an exception in functions.) The legal values
|
|
Packit |
70b277 |
of IBASE are 2 through 36. (Bases greater than 16 are an extension.)
|
|
Packit |
70b277 |
Assigning a value outside this range to IBASE will result in a value of
|
|
Packit |
70b277 |
2 or 36. Input numbers may contain the characters 0-9 and A-Z. (Note:
|
|
Packit |
70b277 |
They must be capitals. Lower case letters are variable names.) Single
|
|
Packit |
70b277 |
digit numbers always have the value of the digit regardless of the
|
|
Packit |
70b277 |
value of IBASE. (i.e. A = 10.) For multi-digit numbers, `bc' changes
|
|
Packit |
70b277 |
all input digits greater or equal to IBASE to the value of IBASE-1.
|
|
Packit |
70b277 |
This makes the number `ZZZ' always be the largest 3 digit number of the
|
|
Packit |
70b277 |
input base.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
Full expressions are similar to many other high level languages.
|
|
Packit |
70b277 |
Since there is only one kind of number, there are no rules for mixing
|
|
Packit |
70b277 |
types. Instead, there are rules on the scale of expressions. Every
|
|
Packit |
70b277 |
expression has a scale. This is derived from the scale of original
|
|
Packit |
70b277 |
numbers, the operation performed and in many cases, the value of the
|
|
Packit |
70b277 |
variable SCALE. Legal values of the variable SCALE are 0 to the maximum
|
|
Packit |
70b277 |
number representable by a C integer.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
?
|
|
Packit |
70b277 |
File: bc.info, Node: Basic Expressions, Next: Relational Expressions, Prev: About Expressions and Special Variables, Up: Expressions
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
3.2 Basic Expressions
|
|
Packit |
70b277 |
=====================
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
In the following descriptions of legal expressions, "expr" refers to a
|
|
Packit |
70b277 |
complete expression and "VAR" refers to a simple or an array variable.
|
|
Packit |
70b277 |
A simple variable is just a
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
NAME
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
and an array variable is specified as
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
NAME[EXPR]
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
Unless specifically mentioned the scale of the result is the maximum
|
|
Packit |
70b277 |
scale of the expressions involved.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`- expr'
|
|
Packit |
70b277 |
The result is the negation of the expression.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`++ VAR'
|
|
Packit |
70b277 |
The variable is incremented by one and the new value is the result
|
|
Packit |
70b277 |
of the expression.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`-- VAR'
|
|
Packit |
70b277 |
The variable is decremented by one and the new value is the result
|
|
Packit |
70b277 |
of the expression.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`VAR ++'
|
|
Packit |
70b277 |
The result of the expression is the value of the variable and then
|
|
Packit |
70b277 |
the variable is incremented by one.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`VAR --'
|
|
Packit |
70b277 |
The result of the expression is the value of the variable and then
|
|
Packit |
70b277 |
the variable is decremented by one.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`expr + expr'
|
|
Packit |
70b277 |
The result of the expression is the sum of the two expressions.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`expr - expr'
|
|
Packit |
70b277 |
The result of the expression is the difference of the two
|
|
Packit |
70b277 |
expressions.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`expr * expr'
|
|
Packit |
70b277 |
The result of the expression is the product of the two expressions.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`expr / expr'
|
|
Packit |
70b277 |
The result of the expression is the quotient of the two
|
|
Packit |
70b277 |
expressions. The scale of the result is the value of the variable
|
|
Packit |
70b277 |
`scale'
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`expr % expr'
|
|
Packit |
70b277 |
The result of the expression is the "remainder" and it is computed
|
|
Packit |
70b277 |
in the following way. To compute a%b, first a/b is computed to
|
|
Packit |
70b277 |
SCALE digits. That result is used to compute a-(a/b)*b to the
|
|
Packit |
70b277 |
scale of the maximum of SCALE+scale(b) and scale(a). If SCALE is
|
|
Packit |
70b277 |
set to zero and both expressions are integers this expression is
|
|
Packit |
70b277 |
the integer remainder function.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`expr ^ expr'
|
|
Packit |
70b277 |
The result of the expression is the value of the first raised to
|
|
Packit |
70b277 |
the second. The second expression must be an integer. (If the
|
|
Packit |
70b277 |
second expression is not an integer, a warning is generated and the
|
|
Packit |
70b277 |
expression is truncated to get an integer value.) The scale of the
|
|
Packit |
70b277 |
result is SCALE if the exponent is negative. If the exponent is
|
|
Packit |
70b277 |
positive the scale of the result is the minimum of the scale of the
|
|
Packit |
70b277 |
first expression times the value of the exponent and the maximum of
|
|
Packit |
70b277 |
SCALE and the scale of the first expression. (e.g. scale(a^b) =
|
|
Packit |
70b277 |
min(scale(a)*b, max(SCALE, scale(a))).) It should be noted that
|
|
Packit |
70b277 |
expr^0 will always return the value of 1.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`( expr )'
|
|
Packit |
70b277 |
This alters the standard precedence to force the evaluation of the
|
|
Packit |
70b277 |
expression.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`VAR = expr'
|
|
Packit |
70b277 |
The variable is assigned the value of the expression.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`VAR <op>= expr'
|
|
Packit |
70b277 |
This is equivalent to "VAR = VAR <op> expr" with the exception
|
|
Packit |
70b277 |
that the "VAR" part is evaluated only once. This can make a
|
|
Packit |
70b277 |
difference if "VAR" is an array.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
?
|
|
Packit |
70b277 |
File: bc.info, Node: Relational Expressions, Next: Boolean Expressions, Prev: Basic Expressions, Up: Expressions
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
3.3 Relational Expressions
|
|
Packit |
70b277 |
==========================
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
Relational expressions are a special kind of expression that always
|
|
Packit |
70b277 |
evaluate to 0 or 1, 0 if the relation is false and 1 if the relation is
|
|
Packit |
70b277 |
true. These may appear in any legal expression. (POSIX `bc' requires
|
|
Packit |
70b277 |
that relational expressions are used only in `if', `while', and `for'
|
|
Packit |
70b277 |
statements and that only one relational test may be done in them.) The
|
|
Packit |
70b277 |
relational operators are
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`expr1 < expr2'
|
|
Packit |
70b277 |
The result is 1 if expr1 is strictly less than expr2.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`expr1 <= expr2'
|
|
Packit |
70b277 |
The result is 1 if expr1 is less than or equal to expr2.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`expr1 > expr2'
|
|
Packit |
70b277 |
The result is 1 if expr1 is strictly greater than expr2.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`expr1 >= expr2'
|
|
Packit |
70b277 |
The result is 1 if expr1 is greater than or equal to expr2.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`expr1 == expr2'
|
|
Packit |
70b277 |
The result is 1 if expr1 is equal to expr2.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`expr1 != expr2'
|
|
Packit |
70b277 |
The result is 1 if expr1 is not equal to expr2.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
?
|
|
Packit |
70b277 |
File: bc.info, Node: Boolean Expressions, Next: Precedence, Prev: Relational Expressions, Up: Expressions
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
3.4 Boolean Expressions
|
|
Packit |
70b277 |
=======================
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
Boolean operations are also legal. (POSIX `bc' does NOT have boolean
|
|
Packit |
70b277 |
operations). The result of all boolean operations are 0 and 1 (for
|
|
Packit |
70b277 |
false and true) as in relational expressions. The boolean operators
|
|
Packit |
70b277 |
are:
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`!expr'
|
|
Packit |
70b277 |
The result is 1 if expr is 0.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`expr && expr'
|
|
Packit |
70b277 |
The result is 1 if both expressions are non-zero.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`expr || expr'
|
|
Packit |
70b277 |
The result is 1 if either expression is non-zero.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
?
|
|
Packit |
70b277 |
File: bc.info, Node: Precedence, Next: Special Expressions, Prev: Boolean Expressions, Up: Expressions
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
3.5 Precedence
|
|
Packit |
70b277 |
==============
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
The expression precedence is as follows: (lowest to highest)
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
|| operator, left associative
|
|
Packit |
70b277 |
&& operator, left associative
|
|
Packit |
70b277 |
! operator, nonassociative
|
|
Packit |
70b277 |
Relational operators, left associative
|
|
Packit |
70b277 |
Assignment operator, right associative
|
|
Packit |
70b277 |
+ and - operators, left associative
|
|
Packit |
70b277 |
*, / and % operators, left associative
|
|
Packit |
70b277 |
^ operator, right associative
|
|
Packit |
70b277 |
unary - operator, nonassociative
|
|
Packit |
70b277 |
++ and -- operators, nonassociative
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
This precedence was chosen so that POSIX compliant `bc' programs
|
|
Packit |
70b277 |
will run correctly. This will cause the use of the relational and
|
|
Packit |
70b277 |
logical operators to have some unusual behavior when used with
|
|
Packit |
70b277 |
assignment expressions. Consider the expression:
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
a = 3 < 5
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
Most C programmers would assume this would assign the result of "3 <
|
|
Packit |
70b277 |
5" (the value 1) to the variable "a". What this does in `bc' is assign
|
|
Packit |
70b277 |
the value 3 to the variable "a" and then compare 3 to 5. It is best to
|
|
Packit |
70b277 |
use parentheses when using relational and logical operators with the
|
|
Packit |
70b277 |
assignment operators.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
?
|
|
Packit |
70b277 |
File: bc.info, Node: Special Expressions, Prev: Precedence, Up: Expressions
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
3.6 Special Expressions
|
|
Packit |
70b277 |
=======================
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
There are a few more special expressions that are provided in `bc'.
|
|
Packit |
70b277 |
These have to do with user-defined functions and standard functions.
|
|
Packit |
70b277 |
They all appear as "NAME`('PARAMETERS`)'". *Note Functions::, for
|
|
Packit |
70b277 |
user-defined functions. The standard functions are:
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`length ( EXPRESSION )'
|
|
Packit |
70b277 |
The value of the length function is the number of significant
|
|
Packit |
70b277 |
digits in the expression.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`read ( )'
|
|
Packit |
70b277 |
The `read' function (an extension) will read a number from the
|
|
Packit |
70b277 |
standard input, regardless of where the function occurs. Beware,
|
|
Packit |
70b277 |
this can cause problems with the mixing of data and program in the
|
|
Packit |
70b277 |
standard input. The best use for this function is in a previously
|
|
Packit |
70b277 |
written program that needs input from the user, but never allows
|
|
Packit |
70b277 |
program code to be input from the user. The value of the `read'
|
|
Packit |
70b277 |
function is the number read from the standard input using the
|
|
Packit |
70b277 |
current value of the variable IBASE for the conversion base.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`scale ( EXPRESSION )'
|
|
Packit |
70b277 |
The value of the `scale' function is the number of digits after the
|
|
Packit |
70b277 |
decimal point in the expression.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`sqrt ( EXPRESSION )'
|
|
Packit |
70b277 |
The value of the `sqrt' function is the square root of the
|
|
Packit |
70b277 |
expression. If the expression is negative, a run time error is
|
|
Packit |
70b277 |
generated.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
?
|
|
Packit |
70b277 |
File: bc.info, Node: Statements, Next: Functions, Prev: Expressions, Up: Top
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
4 Statements
|
|
Packit |
70b277 |
************
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
* Menu:
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
* Pseudo Statements::
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
Statements (as in most algebraic languages) provide the sequencing of
|
|
Packit |
70b277 |
expression evaluation. In `bc' statements are executed "as soon as
|
|
Packit |
70b277 |
possible." Execution happens when a newline in encountered and there
|
|
Packit |
70b277 |
is one or more complete statements. Due to this immediate execution,
|
|
Packit |
70b277 |
newlines are very important in `bc'. In fact, both a semicolon and a
|
|
Packit |
70b277 |
newline are used as statement separators. An improperly placed newline
|
|
Packit |
70b277 |
will cause a syntax error. Because newlines are statement separators,
|
|
Packit |
70b277 |
it is possible to hide a newline by using the backslash character. The
|
|
Packit |
70b277 |
sequence "\<nl>", where <nl> is the newline appears to `bc' as
|
|
Packit |
70b277 |
whitespace instead of a newline. A statement list is a series of
|
|
Packit |
70b277 |
statements separated by semicolons and newlines. The following is a
|
|
Packit |
70b277 |
list of `bc' statements and what they do: (Things enclosed in brackets
|
|
Packit |
70b277 |
( [ ] ) are optional parts of the statement.)
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`EXPRESSION'
|
|
Packit |
70b277 |
This statement does one of two things. If the expression starts
|
|
Packit |
70b277 |
with "<variable> <assignment> ...", it is considered to be an
|
|
Packit |
70b277 |
assignment statement. If the expression is not an assignment
|
|
Packit |
70b277 |
statement, the expression is evaluated and printed to the output.
|
|
Packit |
70b277 |
After the number is printed, a newline is printed. For example,
|
|
Packit |
70b277 |
"a=1" is an assignment statement and "(a=1)" is an expression that
|
|
Packit |
70b277 |
has an embedded assignment. All numbers that are printed are
|
|
Packit |
70b277 |
printed in the base specified by the variable OBASE. The legal
|
|
Packit |
70b277 |
values for OBASE are 2 through BC_BASE_MAX (*note Environment
|
|
Packit |
70b277 |
Variables::). For bases 2 through 16, the usual method of writing
|
|
Packit |
70b277 |
numbers is used. For bases greater than 16, `bc' uses a
|
|
Packit |
70b277 |
multi-character digit method of printing the numbers where each
|
|
Packit |
70b277 |
higher base digit is printed as a base 10 number. The
|
|
Packit |
70b277 |
multi-character digits are separated by spaces. Each digit
|
|
Packit |
70b277 |
contains the number of characters required to represent the base
|
|
Packit |
70b277 |
ten value of "OBASE -1". Since numbers are of arbitrary
|
|
Packit |
70b277 |
precision, some numbers may not be printable on a single output
|
|
Packit |
70b277 |
line. These long numbers will be split across lines using the "\"
|
|
Packit |
70b277 |
as the last character on a line. The maximum number of characters
|
|
Packit |
70b277 |
printed per line is 70. Due to the interactive nature of `bc',
|
|
Packit |
70b277 |
printing a number causes the side effect of assigning the printed
|
|
Packit |
70b277 |
value to the special variable LAST. This allows the user to
|
|
Packit |
70b277 |
recover the last value printed without having to retype the
|
|
Packit |
70b277 |
expression that printed the number. Assigning to LAST is legal
|
|
Packit |
70b277 |
and will overwrite the last printed value with the assigned value.
|
|
Packit |
70b277 |
The newly assigned value will remain until the next number is
|
|
Packit |
70b277 |
printed or another value is assigned to LAST. (Some installations
|
|
Packit |
70b277 |
may allow the use of a single period (.) which is not part of a
|
|
Packit |
70b277 |
number as a short hand notation for for LAST.)
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`STRING'
|
|
Packit |
70b277 |
The string is printed to the output. Strings start with a double
|
|
Packit |
70b277 |
quote character and contain all characters until the next double
|
|
Packit |
70b277 |
quote character. All characters are taken literally, including
|
|
Packit |
70b277 |
any newline. No newline character is printed after the string.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`print LIST'
|
|
Packit |
70b277 |
The `print' statement (an extension) provides another method of
|
|
Packit |
70b277 |
output. The LIST is a list of strings and expressions separated by
|
|
Packit |
70b277 |
commas. Each string or expression is printed in the order of the
|
|
Packit |
70b277 |
list. No terminating newline is printed. Expressions are
|
|
Packit |
70b277 |
evaluated and their value is printed and assigned to the variable
|
|
Packit |
70b277 |
`last'. Strings in the print statement are printed to the output
|
|
Packit |
70b277 |
and may contain special characters. Special characters start with
|
|
Packit |
70b277 |
the backslash character (\e). The special characters recognized
|
|
Packit |
70b277 |
by `bc' are "a" (alert or bell), "b" (backspace), "f" (form feed),
|
|
Packit |
70b277 |
"n" (newline), "r" (carriage return), "q" (double quote), "t"
|
|
Packit |
70b277 |
(tab), and "\e" (backslash). Any other character following the
|
|
Packit |
70b277 |
backslash will be ignored.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`{ STATEMENT_LIST }'
|
|
Packit |
70b277 |
This is the compound statement. It allows multiple statements to
|
|
Packit |
70b277 |
be grouped together for execution.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`if ( EXPRESSION ) STATEMENT1 [else STATEMENT2]'
|
|
Packit |
70b277 |
The if statement evaluates the expression and executes statement1
|
|
Packit |
70b277 |
or statement2 depending on the value of the expression. If the
|
|
Packit |
70b277 |
expression is non-zero, statement1 is executed. If statement2 is
|
|
Packit |
70b277 |
present and the value of the expression is 0, then statement2 is
|
|
Packit |
70b277 |
executed. (The `else' clause is an extension.)
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`while ( EXPRESSION ) STATEMENT'
|
|
Packit |
70b277 |
The while statement will execute the statement while the expression
|
|
Packit |
70b277 |
is non-zero. It evaluates the expression before each execution of
|
|
Packit |
70b277 |
the statement. Termination of the loop is caused by a zero
|
|
Packit |
70b277 |
expression value or the execution of a `break' statement.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`for ( [EXPRESSION1] ; [EXPRESSION2] ; [EXPRESSION3] ) STATEMENT'
|
|
Packit |
70b277 |
The `for' statement controls repeated execution of the statement.
|
|
Packit |
70b277 |
EXPRESSION1 is evaluated before the loop. EXPRESSION2 is
|
|
Packit |
70b277 |
evaluated before each execution of the statement. If it is
|
|
Packit |
70b277 |
non-zero, the statement is evaluated. If it is zero, the loop is
|
|
Packit |
70b277 |
terminated. After each execution of the statement, EXPRESSION3 is
|
|
Packit |
70b277 |
evaluated before the reevaluation of expression2. If EXPRESSION1
|
|
Packit |
70b277 |
or EXPRESSION3 are missing, nothing is evaluated at the point they
|
|
Packit |
70b277 |
would be evaluated. If EXPRESSION2 is missing, it is the same as
|
|
Packit |
70b277 |
substituting the value 1 for EXPRESSION2. (The optional
|
|
Packit |
70b277 |
expressions are an extension. POSIX `bc' requires all three
|
|
Packit |
70b277 |
expressions.) The following is equivalent code for the `for'
|
|
Packit |
70b277 |
statement:
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
expression1;
|
|
Packit |
70b277 |
while (expression2) {
|
|
Packit |
70b277 |
statement;
|
|
Packit |
70b277 |
expression3;
|
|
Packit |
70b277 |
}
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`break'
|
|
Packit |
70b277 |
This statement causes a forced exit of the most recent enclosing
|
|
Packit |
70b277 |
`while' statement or `for' statement.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`continue'
|
|
Packit |
70b277 |
The `continue' statement (an extension) causes the most recent
|
|
Packit |
70b277 |
enclosing `for' statement to start the next iteration.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`halt'
|
|
Packit |
70b277 |
The `halt' statement (an extension) is an executed statement that
|
|
Packit |
70b277 |
causes the `bc' processor to quit only when it is executed. For
|
|
Packit |
70b277 |
example, "if (0 == 1) halt" will not cause `bc' to terminate
|
|
Packit |
70b277 |
because the `halt' is not executed.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`return'
|
|
Packit |
70b277 |
Return the value 0 from a function. (*Note Functions::.)
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`return ( EXPRESSION )'
|
|
Packit |
70b277 |
Return the value of the expression from a function. (*Note
|
|
Packit |
70b277 |
Functions::.) As an extension, the parenthesis are not required.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
?
|
|
Packit |
70b277 |
File: bc.info, Node: Pseudo Statements, Prev: Statements, Up: Statements
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
4.1 Pseudo Statements
|
|
Packit |
70b277 |
=====================
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
These statements are not statements in the traditional sense. They are
|
|
Packit |
70b277 |
not executed statements. Their function is performed at "compile" time.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`limits'
|
|
Packit |
70b277 |
Print the local limits enforced by the local version of `bc'. This
|
|
Packit |
70b277 |
is an extension.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`quit'
|
|
Packit |
70b277 |
When the `quit' statement is read, the `bc' processor is
|
|
Packit |
70b277 |
terminated, regardless of where the `quit' statement is found. For
|
|
Packit |
70b277 |
example, "if (0 == 1) quit" will cause `bc' to terminate.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`warranty'
|
|
Packit |
70b277 |
Print a longer warranty notice. This is an extension.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
?
|
|
Packit |
70b277 |
File: bc.info, Node: Functions, Next: Examples, Prev: Statements, Up: Top
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
5 Functions
|
|
Packit |
70b277 |
***********
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
* Menu:
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
* Math Library Functions::
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
Functions provide a method of defining a computation that can be
|
|
Packit |
70b277 |
executed later. Functions in `bc' always compute a value and return it
|
|
Packit |
70b277 |
to the caller. Function definitions are "dynamic" in the sense that a
|
|
Packit |
70b277 |
function is undefined until a definition is encountered in the input.
|
|
Packit |
70b277 |
That definition is then used until another definition function for the
|
|
Packit |
70b277 |
same name is encountered. The new definition then replaces the older
|
|
Packit |
70b277 |
definition. A function is defined as follows:
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`define' NAME `(' PARAMETERS `)' `{' NEWLINE
|
|
Packit |
70b277 |
AUTO_LIST STATEMENT_LIST `}'
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
A function call is just an expression of the form "`name'
|
|
Packit |
70b277 |
`('PARAMETERS`)'".
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
Parameters are numbers or arrays (an extension). In the function
|
|
Packit |
70b277 |
definition, zero or more parameters are defined by listing their names
|
|
Packit |
70b277 |
separated by commas. All parameters are call by value parameters.
|
|
Packit |
70b277 |
Arrays are specified in the parameter definition by the notation
|
|
Packit |
70b277 |
"NAME`[ ]'". In the function call, actual parameters are full
|
|
Packit |
70b277 |
expressions for number parameters. The same notation is used for
|
|
Packit |
70b277 |
passing arrays as for defining array parameters. The named array is
|
|
Packit |
70b277 |
passed by value to the function. Since function definitions are
|
|
Packit |
70b277 |
dynamic, parameter numbers and types are checked when a function is
|
|
Packit |
70b277 |
called. Any mismatch in number or types of parameters will cause a
|
|
Packit |
70b277 |
runtime error. A runtime error will also occur for the call to an
|
|
Packit |
70b277 |
undefined function.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
The AUTO_LIST is an optional list of variables that are for "local"
|
|
Packit |
70b277 |
use. The syntax of the auto list (if present) is "`auto' NAME, ... ;".
|
|
Packit |
70b277 |
(The semicolon is optional.) Each NAME is the name of an auto
|
|
Packit |
70b277 |
variable. Arrays may be specified by using the same notation as used
|
|
Packit |
70b277 |
in parameters. These variables have their values pushed onto a stack
|
|
Packit |
70b277 |
at the start of the function. The variables are then initialized to
|
|
Packit |
70b277 |
zero and used throughout the execution of the function. At function
|
|
Packit |
70b277 |
exit, these variables are popped so that the original value (at the
|
|
Packit |
70b277 |
time of the function call) of these variables are restored. The
|
|
Packit |
70b277 |
parameters are really auto variables that are initialized to a value
|
|
Packit |
70b277 |
provided in the function call. Auto variables are different than
|
|
Packit |
70b277 |
traditional local variables because if function A calls function B, B
|
|
Packit |
70b277 |
may access function A's auto variables by just using the same name,
|
|
Packit |
70b277 |
unless function B has called them auto variables. Due to the fact that
|
|
Packit |
70b277 |
auto variables and parameters are pushed onto a stack, `bc' supports
|
|
Packit |
70b277 |
recursive functions.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
The function body is a list of `bc' statements. Again, statements
|
|
Packit |
70b277 |
are separated by semicolons or newlines. Return statements cause the
|
|
Packit |
70b277 |
termination of a function and the return of a value. There are two
|
|
Packit |
70b277 |
versions of the return statement. The first form, "`return'", returns
|
|
Packit |
70b277 |
the value 0 to the calling expression. The second form, "`return' (
|
|
Packit |
70b277 |
EXPRESSION )", computes the value of the expression and returns that
|
|
Packit |
70b277 |
value to the calling expression. There is an implied "`return' (0)" at
|
|
Packit |
70b277 |
the end of every function. This allows a function to terminate and
|
|
Packit |
70b277 |
return 0 without an explicit `return' statement.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
Functions also change the usage of the variable IBASE. All
|
|
Packit |
70b277 |
constants in the function body will be converted using the value of
|
|
Packit |
70b277 |
IBASE at the time of the function call. Changes of IBASE will be
|
|
Packit |
70b277 |
ignored during the execution of the function except for the standard
|
|
Packit |
70b277 |
function `read', which will always use the current value of IBASE for
|
|
Packit |
70b277 |
conversion of numbers.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
Several extensions have been added to functions. First, the format
|
|
Packit |
70b277 |
of the definition has been slightly relaxed. The standard requires the
|
|
Packit |
70b277 |
opening brace be on the same line as the `define' keyword and all other
|
|
Packit |
70b277 |
parts must be on following lines. This version of `bc' will allow any
|
|
Packit |
70b277 |
number of newlines before and after the opening brace of the function.
|
|
Packit |
70b277 |
For example, the following definitions are legal.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
define d (n) { return (2*n); }
|
|
Packit |
70b277 |
define d (n)
|
|
Packit |
70b277 |
{ return (2*n); }
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
Functions may be defined as `void'. A void funtion returns no value
|
|
Packit |
70b277 |
and thus may not be used in any place that needs a value. A void
|
|
Packit |
70b277 |
function does not produce any output when called by itself on an input
|
|
Packit |
70b277 |
line. The key word `void' is placed between the key word `define' and
|
|
Packit |
70b277 |
the function name. For example, consider the following session.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
define py (y) { print "--->", y, "<---", "\n"; }
|
|
Packit |
70b277 |
define void px (x) { print "--->", x, "<---", "\n"; }
|
|
Packit |
70b277 |
py(1)
|
|
Packit |
70b277 |
--->1<---
|
|
Packit |
70b277 |
0
|
|
Packit |
70b277 |
px(1)
|
|
Packit |
70b277 |
--->1<---
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
Since `py' is not a void function, the call of `py(1)' prints the
|
|
Packit |
70b277 |
desired output and then prints a second line that is the value of the
|
|
Packit |
70b277 |
function. Since the value of a function that is not given an explicit
|
|
Packit |
70b277 |
return statement is zero, the zero is printed. For `px(1)', no zero is
|
|
Packit |
70b277 |
printed because the function is a void function.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
Also, call by variable for arrays was added. To declare a call by
|
|
Packit |
70b277 |
variable array, the declaration of the array parameter in the function
|
|
Packit |
70b277 |
definition looks like "`*'NAME`[]'". The call to the function remains
|
|
Packit |
70b277 |
the same as call by value arrays.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
?
|
|
Packit |
70b277 |
File: bc.info, Node: Math Library Functions, Prev: Functions, Up: Functions
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
5.1 Math Library Functions
|
|
Packit |
70b277 |
==========================
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
If `bc' is invoked with the `-l' option, a math library is preloaded
|
|
Packit |
70b277 |
and the default SCALE is set to 20. The math functions will calculate
|
|
Packit |
70b277 |
their results to the scale set at the time of their call. The math
|
|
Packit |
70b277 |
library defines the following functions:
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`s (X)'
|
|
Packit |
70b277 |
The sine of X, X is in radians.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`c (X)'
|
|
Packit |
70b277 |
The cosine of X, X is in radians.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`a (X)'
|
|
Packit |
70b277 |
The arctangent of X, arctangent returns radians.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`l (X)'
|
|
Packit |
70b277 |
The natural logarithm of X.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`e (X)'
|
|
Packit |
70b277 |
The exponential function of raising E to the value X.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`j (N, X)'
|
|
Packit |
70b277 |
The Bessel function of integer order N of X.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
?
|
|
Packit |
70b277 |
File: bc.info, Node: Examples, Next: Readline and Libedit Options, Prev: Functions, Up: Top
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
6 Examples
|
|
Packit |
70b277 |
**********
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
In /bin/sh, the following will assign the value of "pi" to the shell
|
|
Packit |
70b277 |
variable PI.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
pi=$(echo "scale=10; 4*a(1)" | bc -l)
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
The following is the definition of the exponential function used in
|
|
Packit |
70b277 |
the math library. This function is written in POSIX `bc'.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
scale = 20
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
/* Uses the fact that e^x = (e^(x/2))^2
|
|
Packit |
70b277 |
When x is small enough, we use the series:
|
|
Packit |
70b277 |
e^x = 1 + x + x^2/2! + x^3/3! + ...
|
|
Packit |
70b277 |
*/
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
define e(x) {
|
|
Packit |
70b277 |
auto a, d, e, f, i, m, v, z
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
/* Check the sign of x. */
|
|
Packit |
70b277 |
if (x<0) {
|
|
Packit |
70b277 |
m = 1
|
|
Packit |
70b277 |
x = -x
|
|
Packit |
70b277 |
}
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
/* Precondition x. */
|
|
Packit |
70b277 |
z = scale;
|
|
Packit |
70b277 |
scale = 4 + z + .44*x;
|
|
Packit |
70b277 |
while (x > 1) {
|
|
Packit |
70b277 |
f += 1;
|
|
Packit |
70b277 |
x /= 2;
|
|
Packit |
70b277 |
}
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
/* Initialize the variables. */
|
|
Packit |
70b277 |
v = 1+x
|
|
Packit |
70b277 |
a = x
|
|
Packit |
70b277 |
d = 1
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
for (i=2; 1; i++) {
|
|
Packit |
70b277 |
e = (a *= x) / (d *= i)
|
|
Packit |
70b277 |
if (e == 0) {
|
|
Packit |
70b277 |
if (f>0) while (f--) v = v*v;
|
|
Packit |
70b277 |
scale = z
|
|
Packit |
70b277 |
if (m) return (1/v);
|
|
Packit |
70b277 |
return (v/1);
|
|
Packit |
70b277 |
}
|
|
Packit |
70b277 |
v += e
|
|
Packit |
70b277 |
}
|
|
Packit |
70b277 |
}
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
The following is code that uses the extended features of `bc' to
|
|
Packit |
70b277 |
implement a simple program for calculating checkbook balances. This
|
|
Packit |
70b277 |
program is best kept in a file so that it can be used many times
|
|
Packit |
70b277 |
without having to retype it at every use.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
scale=2
|
|
Packit |
70b277 |
print "\nCheck book program\n!"
|
|
Packit |
70b277 |
print " Remember, deposits are negative transactions.\n"
|
|
Packit |
70b277 |
print " Exit by a 0 transaction.\n\n"
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
print "Initial balance? "; bal = read()
|
|
Packit |
70b277 |
bal /= 1
|
|
Packit |
70b277 |
print "\n"
|
|
Packit |
70b277 |
while (1) {
|
|
Packit |
70b277 |
"current balance = "; bal
|
|
Packit |
70b277 |
"transaction? "; trans = read()
|
|
Packit |
70b277 |
if (trans == 0) break;
|
|
Packit |
70b277 |
bal -= trans
|
|
Packit |
70b277 |
bal /= 1
|
|
Packit |
70b277 |
}
|
|
Packit |
70b277 |
quit
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
The following is the definition of the recursive factorial function.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
define f (x) {
|
|
Packit |
70b277 |
if (x <= 1) return (1);
|
|
Packit |
70b277 |
return (f(x-1) * x);
|
|
Packit |
70b277 |
}
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
?
|
|
Packit |
70b277 |
File: bc.info, Node: Readline and Libedit Options, Next: Comparison with Other Implementations, Prev: Examples, Up: Top
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
7 Readline and Libedit Options
|
|
Packit |
70b277 |
******************************
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
GNU `bc' can be compiled (via a configure option) to use the GNU
|
|
Packit |
70b277 |
`readline' input editor library or the BSD `libedit' library. This
|
|
Packit |
70b277 |
allows the user to do more editing of lines before sending them to
|
|
Packit |
70b277 |
`bc'. It also allows for a history of previous lines typed. When this
|
|
Packit |
70b277 |
option is selected, `bc' has one more special variable. This special
|
|
Packit |
70b277 |
variable, HISTORY is the number of lines of history retained. A value
|
|
Packit |
70b277 |
of -1 means that an unlimited number of history lines are retained.
|
|
Packit |
70b277 |
This is the default value. Setting the value of HISTORY to a positive
|
|
Packit |
70b277 |
number restricts the number of history lines to the number given. The
|
|
Packit |
70b277 |
value of 0 disables the history feature. For more information, read
|
|
Packit |
70b277 |
the user manuals for the GNU `readline', `history' and BSD `libedit'
|
|
Packit |
70b277 |
libraries. One can not enable both `readline' and `libedit' at the
|
|
Packit |
70b277 |
same time.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
?
|
|
Packit |
70b277 |
File: bc.info, Node: Comparison with Other Implementations, Next: Limits, Prev: Readline and Libedit Options, Up: Top
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
8 Comparison with Other Implementations
|
|
Packit |
70b277 |
***************************************
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
This version of `bc' was implemented from the POSIX P1003.2/D11 draft
|
|
Packit |
70b277 |
and contains several differences and extensions relative to the draft
|
|
Packit |
70b277 |
and traditional implementations. It is not implemented in the
|
|
Packit |
70b277 |
traditional way using `dc'. This version is a single process which
|
|
Packit |
70b277 |
parses and runs a byte code translation of the program. There is an
|
|
Packit |
70b277 |
"undocumented" option (-c) that causes the program to output the byte
|
|
Packit |
70b277 |
code to the standard output instead of running it. It was mainly used
|
|
Packit |
70b277 |
for debugging the parser and preparing the math library.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
A major source of differences is extensions, where a feature is
|
|
Packit |
70b277 |
extended to add more functionality and additions, where new features
|
|
Packit |
70b277 |
are added. The following is the list of differences and extensions.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
LANG environment
|
|
Packit |
70b277 |
This version does not conform to the POSIX standard in the
|
|
Packit |
70b277 |
processing of the LANG environment variable and all environment
|
|
Packit |
70b277 |
variables starting with LC_.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
names
|
|
Packit |
70b277 |
Traditional and POSIX `bc' have single letter names for functions,
|
|
Packit |
70b277 |
variables and arrays. They have been extended to be
|
|
Packit |
70b277 |
multi-character names that start with a letter and may contain
|
|
Packit |
70b277 |
letters, numbers and the underscore character.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
Strings
|
|
Packit |
70b277 |
Strings are not allowed to contain NUL characters. POSIX says all
|
|
Packit |
70b277 |
characters must be included in strings.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
last
|
|
Packit |
70b277 |
POSIX `bc' does not have a \fBlast variable. Some implementations
|
|
Packit |
70b277 |
of `bc' use the period (.) in a similar way.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
comparisons
|
|
Packit |
70b277 |
POSIX `bc' allows comparisons only in the `if' statement, the
|
|
Packit |
70b277 |
`while' statement, and the second expression of the `for'
|
|
Packit |
70b277 |
statement. Also, only one relational operation is allowed in each
|
|
Packit |
70b277 |
of those statements.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`if' statement, `else' clause
|
|
Packit |
70b277 |
POSIX `bc' does not have an `else' clause.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`for' statement
|
|
Packit |
70b277 |
POSIX `bc' requires all expressions to be present in the `for'
|
|
Packit |
70b277 |
statement.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`&&,' `||', `!'
|
|
Packit |
70b277 |
POSIX `bc' does not have the logical operators.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`read' function
|
|
Packit |
70b277 |
POSIX `bc' does not have a `read' function.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`print' statement
|
|
Packit |
70b277 |
POSIX `bc' does not have a `print' statement.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`continue' statement
|
|
Packit |
70b277 |
POSIX `bc' does not have a continue statement.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
array parameters
|
|
Packit |
70b277 |
POSIX `bc' does not (currently) support array parameters in full.
|
|
Packit |
70b277 |
The POSIX grammar allows for arrays in function definitions, but
|
|
Packit |
70b277 |
does not provide a method to specify an array as an actual
|
|
Packit |
70b277 |
parameter. (This is most likely an oversight in the grammar.)
|
|
Packit |
70b277 |
Traditional implementations of `bc' have only call by value array
|
|
Packit |
70b277 |
parameters.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
function format
|
|
Packit |
70b277 |
POSIX `bc' requires the opening brace on the same line as the
|
|
Packit |
70b277 |
`define' key word and the `auto' statement on the next line.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`=+', `=-', `=*', `=/', `=%', `=^'
|
|
Packit |
70b277 |
POSIX `bc' does not require these "old style" assignment operators
|
|
Packit |
70b277 |
to be defined. This version may allow these "old style"
|
|
Packit |
70b277 |
assignments. Use the `limits' statement to see if the installed
|
|
Packit |
70b277 |
version supports them. If it does support the "old style"
|
|
Packit |
70b277 |
assignment operators, the statement "a =- 1" will decrement `a' by
|
|
Packit |
70b277 |
1 instead of setting `a' to the value -1.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
spaces in numbers
|
|
Packit |
70b277 |
Other implementations of `bc' allow spaces in numbers. For
|
|
Packit |
70b277 |
example, "x=1 3" would assign the value 13 to the variable x. The
|
|
Packit |
70b277 |
same statement would cause a syntax error in this version of `bc'.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
errors and execution
|
|
Packit |
70b277 |
This implementation varies from other implementations in terms of
|
|
Packit |
70b277 |
what code will be executed when syntax and other errors are found
|
|
Packit |
70b277 |
in the program. If a syntax error is found in a function
|
|
Packit |
70b277 |
definition, error recovery tries to find the beginning of a
|
|
Packit |
70b277 |
statement and continue to parse the function. Once a syntax error
|
|
Packit |
70b277 |
is found in the function, the function will not be callable and
|
|
Packit |
70b277 |
becomes undefined. Syntax errors in the interactive execution
|
|
Packit |
70b277 |
code will invalidate the current execution block. The execution
|
|
Packit |
70b277 |
block is terminated by an end of line that appears after a
|
|
Packit |
70b277 |
complete sequence of statements. For example,
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
a = 1
|
|
Packit |
70b277 |
b = 2
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
has two execution blocks and
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
{ a = 1
|
|
Packit |
70b277 |
b = 2 }
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
has one execution block. Any runtime error will terminate the
|
|
Packit |
70b277 |
execution of the current execution block. A runtime warning will
|
|
Packit |
70b277 |
not terminate the current execution block.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
Interrupts
|
|
Packit |
70b277 |
During an interactive session, the SIGINT signal (usually
|
|
Packit |
70b277 |
generated by the control-C character from the terminal) will cause
|
|
Packit |
70b277 |
execution of the current execution block to be interrupted. It
|
|
Packit |
70b277 |
will display a "runtime" error indicating which function was
|
|
Packit |
70b277 |
interrupted. After all runtime structures have been cleaned up, a
|
|
Packit |
70b277 |
message will be printed to notify the user that `bc' is ready for
|
|
Packit |
70b277 |
more input. All previously defined functions remain defined and
|
|
Packit |
70b277 |
the value of all non-auto variables are the value at the point of
|
|
Packit |
70b277 |
interruption. All auto variables and function parameters are
|
|
Packit |
70b277 |
removed during the clean up process. During a non-interactive
|
|
Packit |
70b277 |
session, the SIGINT signal will terminate the entire run of `bc'.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
?
|
|
Packit |
70b277 |
File: bc.info, Node: Limits, Next: Environment Variables, Prev: Comparison with Other Implementations, Up: Top
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
9 Limits
|
|
Packit |
70b277 |
********
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
The following are the limits currently in place for this `bc'
|
|
Packit |
70b277 |
processor. Some of them may have been changed by an installation. Use
|
|
Packit |
70b277 |
the `limits' statement to see the actual values.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`BC_BASE_MAX'
|
|
Packit |
70b277 |
The maximum output base is currently set at 999. The maximum
|
|
Packit |
70b277 |
input base is 16.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`BC_DIM_MAX'
|
|
Packit |
70b277 |
This is currently an arbitrary limit of 65535 as distributed. Your
|
|
Packit |
70b277 |
installation may be different.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`BC_SCALE_MAX'
|
|
Packit |
70b277 |
The number of digits after the decimal point is limited to INT_MAX
|
|
Packit |
70b277 |
digits. Also, the number of digits before the decimal point is
|
|
Packit |
70b277 |
limited to INT_MAX digits.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`BC_STRING_MAX'
|
|
Packit |
70b277 |
The limit on the number of characters in a string is INT_MAX
|
|
Packit |
70b277 |
characters.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`exponent'
|
|
Packit |
70b277 |
The value of the exponent in the raise operation (^) is limited to
|
|
Packit |
70b277 |
LONG_MAX.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`multiply'
|
|
Packit |
70b277 |
The multiply routine may yield incorrect results if a number has
|
|
Packit |
70b277 |
more than LONG_MAX / 90 total digits. For 32 bit longs, this
|
|
Packit |
70b277 |
number is 23,860,929 digits.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`variable names'
|
|
Packit |
70b277 |
The current limit on the number of unique names is 32767 for each
|
|
Packit |
70b277 |
of simple variables, arrays and functions.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
?
|
|
Packit |
70b277 |
File: bc.info, Node: Environment Variables, Prev: Limits, Up: Top
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
10 Environment Variables
|
|
Packit |
70b277 |
************************
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
The following environment variables are processed by `bc':
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`POSIXLY_CORRECT'
|
|
Packit |
70b277 |
This is the same as the -s option (*note Command Line Options::).
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`BC_ENV_ARGS'
|
|
Packit |
70b277 |
This is another mechanism to get arguments to `bc'. The format is
|
|
Packit |
70b277 |
the same as the command line arguments. These arguments are
|
|
Packit |
70b277 |
processed first, so any files listed in the environment arguments
|
|
Packit |
70b277 |
are processed before any command line argument files. This allows
|
|
Packit |
70b277 |
the user to set up "standard" options and files to be processed at
|
|
Packit |
70b277 |
every invocation of `bc'. The files in the environment variables
|
|
Packit |
70b277 |
would typically contain function definitions for functions the user
|
|
Packit |
70b277 |
wants defined every time `bc' is run.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
`BC_LINE_LENGTH'
|
|
Packit |
70b277 |
This should be an integer specifying the number of characters in an
|
|
Packit |
70b277 |
output line for numbers. This includes the backslash and newline
|
|
Packit |
70b277 |
characters for long numbers. As an extension, the value of zero
|
|
Packit |
70b277 |
disables the multi-line feature. Any other value of this variable
|
|
Packit |
70b277 |
that is less than 3 sets the line length to 70.
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
|
|
Packit |
70b277 |
?
|
|
Packit |
70b277 |
Tag Table:
|
|
Packit |
70b277 |
Node: Top201
|
|
Packit |
70b277 |
Node: Introduction493
|
|
Packit |
70b277 |
Node: Description658
|
|
Packit |
70b277 |
Node: Command Line Options2117
|
|
Packit |
70b277 |
Node: Basic Elements2687
|
|
Packit |
70b277 |
Node: Numbers2862
|
|
Packit |
70b277 |
Node: Variables3633
|
|
Packit |
70b277 |
Node: Comments4747
|
|
Packit |
70b277 |
Node: Expressions5493
|
|
Packit |
70b277 |
Node: About Expressions and Special Variables5777
|
|
Packit |
70b277 |
Node: Basic Expressions7560
|
|
Packit |
70b277 |
Node: Relational Expressions10506
|
|
Packit |
70b277 |
Node: Boolean Expressions11516
|
|
Packit |
70b277 |
Node: Precedence12076
|
|
Packit |
70b277 |
Node: Special Expressions13241
|
|
Packit |
70b277 |
Node: Statements14628
|
|
Packit |
70b277 |
Node: Pseudo Statements21261
|
|
Packit |
70b277 |
Node: Functions21914
|
|
Packit |
70b277 |
Node: Math Library Functions27077
|
|
Packit |
70b277 |
Node: Examples27793
|
|
Packit |
70b277 |
Node: Readline and Libedit Options29777
|
|
Packit |
70b277 |
Node: Comparison with Other Implementations30808
|
|
Packit |
70b277 |
Node: Limits36090
|
|
Packit |
70b277 |
Node: Environment Variables37347
|
|
Packit |
70b277 |
?
|
|
Packit |
70b277 |
End Tag Table
|