usd/06.bc/bc

         $FreeBSD$
 $OpenBSD: bc,v 1.9 2004/07/09 10:23:05 jmc Exp $

 Copyright (C) Caldera International Inc. 2001-2002.
 All rights reserved.

 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions
 are met:
 1. Redistributions of source code and documentation must retain the above
 copyright notice, this list of conditions and the following disclaimer.
 2. Redistributions in binary form must reproduce the above copyright
 notice, this list of conditions and the following disclaimer in the
 documentation and/or other materials provided with the distribution.
 3. All advertising materials mentioning features or use of this software
 must display the following acknowledgement:
 This product includes software developed or owned by Caldera
 International, Inc.
 4. Neither the name of Caldera International, Inc. nor the names of other
 contributors may be used to endorse or promote products derived from
 this software without specific prior written permission.

 USE OF THE SOFTWARE PROVIDED FOR UNDER THIS LICENSE BY CALDERA
 INTERNATIONAL, INC. AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR
 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 IN NO EVENT SHALL CALDERA INTERNATIONAL, INC. BE LIABLE FOR ANY DIRECT,
 INDIRECT INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.

 @(#)bc 6.2 (Berkeley) 4/17/91

.nr PO 5n
.nr LL 70n
.\}
.EH 'USD:6-%''BC - An Arbitrary Precision Desk-Calculator Language'
.OH 'BC - An Arbitrary Precision Desk-Calculator Language''USD:6-%'
.RP
.ND
BC - An Arbitrary Precision Desk-Calculator Language
.AU
Lorinda Cherry
.AU
Robert Morris
.AI
 .MH
.AB
BC is a language and a compiler for doing arbitrary precision arithmetic
on the PDP-11 under the
X time-sharing
system. The output of the compiler is interpreted and executed by
a collection of routines which can input, output, and do
arithmetic on indefinitely large integers and on scaled fixed-point
numbers.

These routines are themselves based on a dynamic storage allocator.
Overflow does not occur until all available core storage
is exhausted.

The language has a complete control structure as well as immediate-mode
operation. Functions can be defined and saved for later execution.

Two five hundred-digit numbers can be multiplied to give a
thousand digit result in about ten seconds.

A small collection of library functions is also available,
including sin, cos, arctan, log, exponential, and Bessel functions of
integer order.

Some of the uses of this compiler are
 -
to do computation with large integers,
 -
to do computation accurate to many decimal places,
 -
conversion of numbers from one base to another base.
.AE

Introduction

BC is a language and a compiler for doing arbitrary precision
arithmetic on the
X time-sharing system [1].
The compiler was written to make conveniently available a
collection of routines (called DC [5]) which are capable of doing
arithmetic on integers of arbitrary size. The compiler
is by no means intended to provide a complete programming
language.
It is a minimal language facility.

There is a scaling provision that permits the
use of decimal point notation.
Provision is made for input and output in bases other than
decimal. Numbers can be converted from decimal to octal by
simply setting the output base to equal 8.

The actual limit on the number of digits that can
be handled depends on the amount of storage available on the machine.
Manipulation of numbers with many hundreds of digits
is possible even on the smallest versions of
X .
The syntax of BC has been deliberately selected to agree
substantially with the C language [2]. Those who
are familiar with C will find few surprises in this language.
Simple Computations with Integers

The simplest kind of statement is an arithmetic expression
on a line by itself.
For instance, if you type in the line:

142857 + 285714

the program responds immediately with the line

428571

The operators -, *, /, %, and ^ can also be used; they
indicate subtraction, multiplication, division, remaindering, and
exponentiation, respectively. Division of integers produces an
integer result truncated toward zero.
Division by zero produces an error
comment.

Any term in an expression may be prefixed by a minus sign to
indicate that it is to be negated (the `unary' minus sign).
The expression

7+-3

is interpreted to mean that -3 is to be added to 7.

More complex expressions with several operators and with
parentheses are interpreted just as in
Fortran, with ^ having the greatest binding
power, then * and % and /, and finally + and -.
Contents of parentheses are evaluated before material
outside the parentheses.
Exponentiations are
performed from right to left and the other operators
from left to right.
The two expressions

a^b^c and a^(b^c)

are equivalent, as are the two expressions

a*b*c and (a*b)*c

BC shares with Fortran and C the undesirable convention that

a/b*c is equivalent to (a/b)*c


Internal storage registers to hold numbers have single lower-case
letter names. The value of an expression can be assigned to
a register in the usual way. The statement

x = x + 3

has the effect of increasing by three the value of the contents of the
register named x.
When, as in this case, the outermost operator is an =, the
assignment is performed but the result is not printed.
Only 26 of these named storage registers are available.

There is a built-in square root function whose
result is truncated to an integer (but see scaling below).
The lines

x = sqrt(191)
x

produce the printed result

13

Bases

There are special internal quantities, called `ibase' and `obase'.
The contents of `ibase', initially set to 10,
determines the base used for interpreting numbers read in.
For example, the lines

ibase = 8
11

will produce the output line

9

and you are all set up to do octal to decimal conversions.
Beware, however of trying to change the input base back
to decimal by typing

ibase = 10

Because the number 10 is interpreted as octal, this statement will
have no effect.
For those who deal in hexadecimal notation,
the characters A-F are permitted in numbers
(no matter what base is in effect)
and are
interpreted as digits having values 10-15 respectively.
The statement

ibase = A

will change you back to decimal input base no matter what the
current input base is.
Negative and large positive input bases are
permitted but useless.
No mechanism has been provided for the input of arbitrary
numbers in bases less than 1 and greater than 16.

The contents of `obase', initially set to 10, are used as the base for output
numbers. The lines

obase = 16
1000

will produce the output line

3E8

which is to be interpreted as a 3-digit hexadecimal number.
Very large output bases are permitted, and they are sometimes useful.
For example, large numbers can be output in groups of five digits
by setting `obase' to 100000.
Strange (i.e. 1, 0, or negative) output bases are
handled appropriately.

Very large numbers are split across lines with 70 characters per line.
Lines which are continued end with \\.
Decimal output conversion is practically instantaneous, but output
of very large numbers (i.e., more than 100 digits) with other bases
is rather slow.
Non-decimal output conversion of
a one hundred digit number takes about
three seconds.

It is best to remember that `ibase' and `obase' have no effect
whatever on the course of internal computation or
on the evaluation of expressions, but only affect input and
output conversion, respectively.
Scaling

A third special internal quantity called `scale' is
used to determine the scale of calculated
quantities.
Numbers may have
up to a specific number of decimal digits after the decimal point.
This fractional part is retained in further computations.
We refer to the number of digits after the decimal point of
a number as its scale.
The current implementation allows scales to be as large as can be
represented by a 32-bit unsigned number minus one.
This is a non-portable extension.
The original implementation allowed for a maximum scale of 99.

When two scaled numbers are combined by
means of one of the arithmetic operations, the result
has a scale determined by the following rules. For
addition and subtraction, the scale of the result is the larger
of the scales of the two operands. In this case,
there is never any truncation of the result.
For multiplications, the scale of the result is never
less than the maximum of the two scales of the operands,
never more than the sum of the scales of the operands
and, subject to those two restrictions,
the scale of the result is set equal to the contents of the internal
quantity `scale'.
The scale of a quotient is the contents of the internal
quantity `scale'. The scale of a remainder is
the sum of the scales of the quotient and the divisor.
The result of an exponentiation is scaled as if
the implied multiplications were performed.
An exponent must be an integer.
The scale of a square root is set to the maximum of the scale
of the argument and the contents of `scale'.

All of the internal operations are actually carried out in terms
of integers, with digits being discarded when necessary.
In every case where digits are discarded, truncation and
not rounding is performed.

The contents of
`scale' must be no greater than
4294967294 and no less than 0. It is initially set to 0.

The internal quantities `scale', `ibase', and `obase' can be
used in expressions just like other variables.
The line

scale = scale + 1

increases the value of `scale' by one, and the line

scale

causes the current value of `scale' to be printed.

The value of `scale' retains its meaning as a
number of decimal digits to be retained in internal
computation even when `ibase' or `obase' are not equal to 10.
The internal computations (which are still conducted in decimal,
regardless of the bases) are performed to the specified number
of decimal digits, never hexadecimal or octal or any
other kind of digits.
Functions

The name of a function is a single lower-case letter.
Function names are permitted to collide with simple
variable names.
Twenty-six different defined functions are permitted
in addition to the twenty-six variable names.
The line

 define a(x){

begins the definition of a function with one argument.
This line must be followed by one or more statements,
which make up the body of the function, ending
with a right brace }.
Return of control from a function occurs when a return
statement is executed or when the end of the function is reached.
The return statement can take either
of the two forms

return
return(x)

In the first case, the value of the function is 0, and in
the second, the value of the expression in parentheses.

Variables used in the function can be declared as automatic
by a statement of the form

auto x,y,z

There can be only one `auto' statement in a function and it must
be the first statement in the definition.
These automatic variables are allocated space and initialized
to zero on entry to the function and thrown away on return. The
values of any variables with the same names outside the function
are not disturbed.
Functions may be called recursively and the automatic variables
at each level of call are protected.
The parameters named in a function definition are treated in
the same way as the automatic variables of that function
with the single exception that they are given a value
on entry to the function.
An example of a function definition is

 define a(x,y){
 auto z
 z = x*y
 return(z)
 }

The value of this function, when called, will be the
product of its
two arguments.

A function is called by the appearance of its name
followed by a string of arguments enclosed in
parentheses and separated by commas.
The result
is unpredictable if the wrong number of arguments is used.

Functions with no arguments are defined and called using
parentheses with nothing between them: b().

If the function
a
above has been defined, then the line

a(7,3.14)

would cause the result 21.98 to be printed and the line

x = a(a(3,4),5)

would cause the value of x to become 60.
Subscripted Variables

A single lower-case letter variable name
followed by an expression in brackets is called a subscripted
variable (an array element).
The variable name is called the array name and the expression
in brackets is called the subscript.
Only one-dimensional arrays are
permitted. The names of arrays are permitted to
collide with the names of simple variables and function names.
Any fractional
part of a subscript is discarded before use.
Subscripts must be greater than or equal to zero and
less than or equal to 2047.

Subscripted variables may be freely used in expressions, in
function calls, and in return statements.

An array name may be used as an argument to a function,
or may be declared as automatic in
a function definition by the use of empty brackets:

f(a[\|])
define f(a[\|])
auto a[\|]

When an array name is so used, the whole contents of the array
are copied for the use of the function, and thrown away on exit
from the function.
Array names which refer to whole arrays cannot be used
in any other contexts.
Control Statements

The `if', the `while', and the `for' statements
may be used to alter the flow within programs or to cause iteration.
The range of each of them is a statement or
a compound statement consisting of a collection of
statements enclosed in braces.
They are written in the following way

if(relation) statement
if(relation) statement else statement
while(relation) statement
for(expression1; relation; expression2) statement

or

if(relation) {statements}
if(relation) {statements} else {statements}
while(relation) {statements}
for(expression1; relation; expression2) {statements}


A relation in one of the control statements is an expression of the form

x>y

where two expressions are related by one of the six relational
operators `<', `>', `<=', `>=', `==', or `!='.
The relation `=='
stands for `equal to' and `!=' stands for `not equal to'.
The meaning of the remaining relational operators is
clear.

BEWARE of using `=' instead of `==' in a relational. Unfortunately,
both of them are legal, so you will not get a diagnostic
message, but `=' really will not do a comparison.

The `if' statement causes execution of its range
if and only if the relation is true.
Then control passes to the next statement in sequence.
If an `else' branch is present, the statements in this branch are
executed if the relation is false.
The `else' keyword is a non-portable extension.

The `while' statement causes execution of its range
repeatedly as long as the relation
is true. The relation is tested before each execution
of its range and if the relation
is false, control passes to the next statement beyond the range
of the while.

The `for' statement begins
by executing `expression1'. Then the relation is tested
and, if true, the statements in the range of the `for' are executed.
Then `expression2' is executed. The relation is tested, and so on.
The typical use of the `for' statement is for a controlled iteration,
as in the statement

for(i=1; i<=10; i=i+1) i

which will print the integers from 1 to 10.
Here are some examples of the use of the control statements.

define f(n){
auto i, x
x=1
for(i=1; i<=n; i=i+1) x=x*i
return(x)
}

The line

 f(a)

will print
a
factorial if
a
is a positive integer.
Here is the definition of a function which will
compute values of the binomial coefficient
(m and n are assumed to be positive integers).

define b(n,m){
auto x, j
x=1
for(j=1; j<=m; j=j+1) x=x*(n-j+1)/j
return(x)
}

The following function computes values of the exponential function
by summing the appropriate series
without regard for possible truncation errors:

scale = 20
define e(x){
 auto a, b, c, d, n
 a = 1
 b = 1
 c = 1
 d = 0
 n = 1
 while(1==1){
 a = a*x
 b = b*n
 c = c + a/b
 n = n + 1
 if(c==d) return(c)
 d = c
 }
}

Some Details

There are some language features that every user should know
about even if he will not use them.

Normally statements are typed one to a line. It is also permissible
to type several statements on a line separated by semicolons.

If an assignment statement is parenthesized, it then has
a value and it can be used anywhere that an expression can.
For example, the line

(x=y+17)

not only makes the indicated assignment, but also prints the
resulting value.

Here is an example of a use of the value of an
assignment statement even when it is not parenthesized.

x = a[i=i+1]

causes a value to be assigned to x and also increments i
before it is used as a subscript.

The following constructs work in BC in exactly the same manner
as they do in the C language. Consult the appendix or the
C manuals [2] for their exact workings.

x=y=z is the same as x=(y=z)
x += y x = x+y
x -= y x = x-y
x *= y x = x*y
x /= y x = x/y
x %= y x = x%y
x ^= y x = x^y
x++ (x=x+1)-1
x-- (x=x-1)+1
++x x = x+1
--x x = x-1

Even if you don't intend to use the constructs,
if you type one inadvertently, something correct but unexpected
may happen.
Three Important Things

1. To exit a BC program, type `quit'.

2. There is a comment convention identical to that of C and
of PL/I. Comments begin with `/*' and end with `*/'.
As a non-portable extension, comments may also start with a `#' and end with
a newline.
The newline is not part of the comment.

3. There is a library of math functions which may be obtained by
typing at command level

bc -l

This command will load a set of library functions
which, at the time of writing, consists of sine (named `s'),
cosine (`c'), arctangent (`a'), natural logarithm (`l'),
exponential (`e') and Bessel functions of integer order (`j(n,x)'). Doubtless more functions will be added
in time.
The library sets the scale to 20. You can reset it to something
else if you like.
The design of these mathematical library routines
is discussed elsewhere [3].

If you type

bc file ...

BC will read and execute the named file or files before accepting
commands from the keyboard. In this way, you may load your
favorite programs and function definitions.
Acknowledgement

The compiler is written in YACC [4]; its original
version was written by S. C. Johnson.
References
 [1]
K. Thompson and D. M. Ritchie,
UNIX Programmer's Manual,
Bell Laboratories,
1978.
 [2]
B. W. Kernighan and
D. M. Ritchie,
The C Programming Language,
Prentice-Hall, 1978.
 [3]
R. Morris,
A Library of Reference Standard Mathematical Subroutines,
Bell Laboratories internal memorandum, 1975.
 [4]
S. C. Johnson,
YACC \(em Yet Another Compiler-Compiler.
Bell Laboratories Computing Science Technical Report #32, 1978.
 [5]
R. Morris and L. L. Cherry,
DC - An Interactive Desk Calculator.

.bp
 C
Appendix

Notation

In the following pages syntactic categories are in italics;
literals are in bold; material in brackets [\|] is optional.
Tokens

Tokens consist of keywords, identifiers, constants, operators,
and separators.
Token separators may be blanks, tabs or comments.
Newline characters or semicolons separate statements.

Comments

Comments are introduced by the characters /* and terminated by
*/.
As a non-portable extension, comments may also start with a # and
end with a newline.
The newline is not part of the comment.

Identifiers

There are three kinds of identifiers - ordinary identifiers, array identifiers
and function identifiers.
All three types consist of single lower-case letters.
Array identifiers are followed by square brackets, possibly
enclosing an expression describing a subscript.
Arrays are singly dimensioned and may contain up to 2048
elements.
Indexing begins at zero so an array may be indexed from 0 to 2047.
Subscripts are truncated to integers.
Function identifiers are followed by parentheses, possibly enclosing arguments.
The three types of identifiers do not conflict;
a program can have a variable named x,
an array named x and a function named x, all of which are separate and
distinct.

Keywords

The following are reserved keywords:
 ibase if
 obase break
 scale define
 sqrt auto
 length return
 while quit
 for continue
 else last
 print


Constants

Constants consist of arbitrarily long numbers
with an optional decimal point.
The hexadecimal digits A-F are also recognized as digits with
values 10-15, respectively.

Expressions

The value of an expression is printed unless the main
operator is an assignment.
The value printed is assigned to the special variable last.
A single dot may be used as a synonym for last.
This is a non-portable extension.
Precedence is the same as the order
of presentation here, with highest appearing first.
Left or right associativity, where applicable, is
discussed with each operator.
.bp

Primitive expressions

Named expressions

Named expressions are
places where values are stored.
Simply stated,
named expressions are legal on the left
side of an assignment.
The value of a named expression is the value stored in the place named.

identifiers

Simple identifiers are named expressions.
They have an initial value of zero.

array-name\|[\|expression\|]

Array elements are named expressions.
They have an initial value of zero.

scale, ibase and obase

The internal registers
scale, ibase and obase are all named expressions.
scale is the number of digits after the decimal point to be
retained in arithmetic operations.
scale has an initial value of zero.
ibase and obase are the input and output number
radix respectively.
Both ibase and obase have initial values of 10.

Function calls

function-name\|([expression\|[,\|expression\|.\|.\|.\|]\|])

A function call consists of a function name followed by parentheses
containing a comma-separated list of
expressions, which are the function arguments.
A whole array passed as an argument is specified by the
array name followed by empty square brackets.
All function arguments are passed by
value.
As a result, changes made to the formal parameters have
no effect on the actual arguments.
If the function terminates by executing a return
statement, the value of the function is
the value of the expression in the parentheses of the return
statement or is zero if no expression is provided
or if there is no return statement.

sqrt\|(\|expression\|)

The result is the square root of the expression.
The result is truncated in the least significant decimal place.
The scale of the result is
the scale of the expression or the
value of
scale,
whichever is larger.

length\|(\|expression\|)

The result is the total number of significant decimal digits in the expression.
The scale of the result is zero.

scale\|(\|expression\|)

The result is the scale of the expression.
The scale of the result is zero.

Constants

Constants are primitive expressions.

Parentheses

An expression surrounded by parentheses is
a primitive expression.
The parentheses are used to alter the
normal precedence.

Unary operators

The unary operators
bind right to left.

-\|expression

The result is the negative of the expression.

++\|named-expression

The named expression is
incremented by one.
The result is the value of the named expression after
incrementing.

--\|named-expression

The named expression is
decremented by one.
The result is the value of the named expression after
decrementing.

named-expression\|++

The named expression is
incremented by one.
The result is the value of the named expression before
incrementing.

named-expression\|--

The named expression is
decremented by one.
The result is the value of the named expression before
decrementing.

Exponentiation operator

The exponentiation operator binds right to left.

expression ^ expression

The result is the first
expression raised to the power of the
second expression.
The second expression must be an integer.
If a
is the scale of the left expression
and b is the absolute value
of the right expression,
then the scale of the result is:

min\|(\|a\(mub,\|max\|(\|scale,\|a\|)\|)

Multiplicative operators

The operators *, /, % bind left to right.

expression * expression

The result is the product
of the two expressions.
If a and b are the
scales of the two expressions,
then the scale of the result is:

min\|(\|a+b,\|max\|(\|scale,\|a,\|b\|)\|)

expression / expression

The result is the quotient of the two expressions.
The scale of the result is the value of scale.

expression % expression

The % operator produces the remainder of the division
of the two expressions.
More precisely,
a%b is a-a/b*b.

The scale of the result is the sum of the scale of
the divisor and the value of
scale

Additive operators

The additive operators bind left to right.

expression + expression

The result is the sum of the two expressions.
The scale of the result is
the maximum of the scales of the expressions.

expression - expression

The result is the difference of the two expressions.
The scale of the result is the
maximum of the scales of the expressions.

assignment operators

The assignment operators bind right to left.

named-expression = expression

This expression results in assigning the value of the expression
on the right
to the named expression on the left.

named-expression += expression

named-expression -= expression

named-expression *= expression

named-expression /= expression

named-expression %= expression

named-expression ^= expression

The result of the above expressions is equivalent
to ``named expression = named expression OP expression'',
where OP is the operator after the = sign.

Relations

Unlike all other operators, the relational operators
are only valid as the object of an if, while,
or inside a for statement.

expression < expression

expression > expression

expression <= expression

expression >= expression

expression == expression

expression != expression

Storage classes

There are only two storage classes in BC, global and automatic
(local).
Only identifiers that are to be local to a function need be
declared with the auto command.
The arguments to a function
are local to the function.
All other identifiers are assumed to be global
and available to all functions.
All identifiers, global and local, have initial values
of zero.
Identifiers declared as auto are allocated on entry to the function
and released on returning from the function.
They therefore do not retain values between function calls.
auto arrays are specified by the array name followed by empty square brackets.

Automatic variables in BC do not work in exactly the same way
as in either C or PL/I. On entry to a function, the old values of
the names that appear as parameters and as automatic
variables are pushed onto a stack.
Until return is made from the function, reference to these
names refers only to the new values.

Statements

Statements must be separated by semicolon or newline.
Except where altered by control statements, execution
is sequential.

Expression statements

When a statement is an expression, unless
the main operator is an assignment, the value
of the expression is printed, followed by a newline character.

Compound statements

Statements may be grouped together and used when one statement is expected
by surrounding them with { }.

Quoted string statements

"any string"
This statement prints the string inside the quotes.

If statements
if\|(\|relation\|)\|statement

The substatement is executed if the relation is true.

If-else statements
if\|(\|relation\|)\|statement\|else\|statement

The first substatement is executed if the relation is true, the second
substatement if the relation is false.
The if-else statement is a non-portable extension.

While statements
while\|(\|relation\|)\|statement

The statement is executed while the relation
is true.
The test occurs before each execution of the statement.

For statements
for\|(\|expression; relation; expression\|)\|statement

The for statement is the same as
 first-expression
 while\|(relation\|) {
 statement
 last-expression
 }


All three expressions may be left out.
This is a non-portable extension.

Break statements
break

break causes termination of a for or while statement.

Continue statements
continue

continue causes the next iteration of a for or while
statement to start, skipping the remainder of the loop.
For a while statement, execution continues with the evaluation
of the condition.
For a for statement, execution continues with evaluation of
the last-expression.
The continue statement is a non-portable extension.

Auto statements
auto identifier\|[\|,identifier\|]

The auto statement causes the values of the identifiers to be pushed down.
The identifiers can be ordinary identifiers or array identifiers.
Array identifiers are specified by following the array name by empty square
brackets.
The auto statement must be the first statement
in a function definition.

Define statements
define(\|[parameter\|[\|,\|parameter\|.\|.\|.\|]\|]\|)\|{
 statements\|}


The define statement defines a function.
The parameters may
be ordinary identifiers or array names.
Array names must be followed by empty square brackets.
As a non-portable extension, the opening brace may also appear on the
next line.

Return statements
return
return(\|expression\|)

The return statement causes termination of a function,
popping of its auto variables, and
specifies the result of the function.
The first form is equivalent to return(0).
The result of the function is the result of the expression
in parentheses.
Leaving out the expression between parentheses is equivalent to
return(0).
As a non-portable extension, the parentheses may be left out.

Print

The print statement takes a list of comma-separated expressions.
Each expression in the list is evaluated and the computed
value is printed and assigned to the variable `last'.
No trailing newline is printed.
The expression may also be a string enclosed in double quotes.
Within these strings the following escape sequences may be used:
\ea
for bell (alert),
`\eb'
for backspace,
`\ef'
for formfeed,
`\en'
for newline,
`\er'
for carriage return,
`\et'
`for tab,
`\eq'
for double quote and
`\e\e'
for backslash.
Any other character following a backslash will be ignored.
Strings will not be assigned to `last'.
The print statement is a non-portable extension.

Quit

The quit statement stops execution of a BC program and returns
control to UNIX when it is first encountered.
Because it is not treated as an executable statement,
it cannot be used
in a function definition or in an
if, for,
or
while
statement.