


bc(1)                                                       bc(1)


NAME
       bc - An arbitrary precision calculator language

SYNTAX
       bc [ -lwsqv ] [long-options] [  file ... ]

VERSION
       This man page documents GNU bc version 1.04.

DESCRIPTION
       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.  bc starts by processing  code  from
       all  the  files  listed  on  the command line in the order
       listed.  After all files have  been  processed,  bc  reads
       from  the  standard  input.  All code is executed as it is
       read.  (If a file contains a command to halt  the  proces-
       sor, bc will never read from the standard input.)

       This version of bc contains several extensions beyond tra-
       ditional 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.

   OPTIONS
       -l     Define the standard math library.

       -w     Give warnings for extensions to POSIX bc.

       -s     Process exactly the POSIX bc language.

       -q     Do not print the normal GNU bc welcome.

       -v     Print the version number and copyright and quit.

       --mathlib
              Define the standard math library.

       --warn Give warnings for extensions to POSIX bc.

       --standard
              Process exactly the POSIX bc language.

       --quiet
              Do not print the normal GNU bc welcome.

       --version
              Print the version number and copyright and quit.




                                .                               1





bc(1)                                                       bc(1)


   NUMBERS
       The most basic element in 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.

   VARIABLES
       Numbers are stored in two types of variables, simple vari-
       ables and arrays.  Both simple variables and  array  vari-
       ables  are  named.   Names begin with a letter followed by
       any number of letters, digits and underscores.   All  let-
       ters must be lower case.  (Full alpha-numeric names are an
       extension. In POSIX 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, scale, ibase, obase, and
       last.  scale defines how some operations use digits  after
       the decimal point.  The default value of scale is 0. ibase
       and obase define the conversion base for input and  output
       numbers.   The  default  for both input and output is base
       10.  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.

   COMMENTS
       Comments in 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 bc, a single  line  com-
       ment  has  been added as an extension.  A single line com-
       ment 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.

   EXPRESSIONS
       The numbers are manipulated by expressions and statements.
       Since   the  language  was  designed  to  be  interactive,



                                .                               2





bc(1)                                                       bc(1)


       statements and expressions are executed as soon as  possi-
       ble.   There  is no "main" program.  Instead, code is exe-
       cuted as it  is  encountered.   (Functions,  discussed  in
       detail later, are defined when encountered.)

       A  simple  expression is just a constant. bc converts con-
       stants into internal decimal  numbers  using  the  current
       input  base, specified by the variable ibase. (There is an
       exception in functions.)  The legal values of ibase are  2
       through 16.  Assigning a value outside this range to ibase
       will result in a value of 2 or 16.  Input numbers may con-
       tain the characters 0-9 and A-F. (Note: They must be capi-
       tals.  Lower case letters  are  variable  names.)   Single
       digit  numbers  always have the value of the digit regard-
       less of the value of ibase. (i.e. A  =  10.)   For  multi-
       digit  numbers,  bc  changes  all  input digits greater or
       equal to ibase to the value of 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 lan-
       guages.  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 sim-
       ple 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.

       - expr The result is the negation of the expression.

       ++ var The variable is incremented  by  one  and  the  new
              value is the result of the expression.

       -- var The  variable  is  decremented  by  one and the new
              value is the result of the expression.

       var ++  The result of the expression is the value  of  the
              variable  and  then  the variable is incremented by
              one.

       var -- The result of the expression is the  value  of  the
              variable  and  then  the variable is decremented by
              one.




                                .                               3





bc(1)                                                       bc(1)


       expr + expr
              The result of the expression is the sum of the  two
              expressions.

       expr - expr
              The  result  of the expression is the difference of
              the two expressions.

       expr * expr
              The result of the expression is the product of  the
              two expressions.

       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.

       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 inte-
              gers this expression is the integer remainder func-
              tion.

       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 expres-
              sion.   (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.

       ( expr )
              This alters the standard precedence  to  force  the
              evaluation of the expression.

       var = expr
              The  variable  is assigned the value of the expres-
              sion.

       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



                                .                               4





bc(1)                                                       bc(1)


              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  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

       expr1 < expr2
              The  result  is  1  if  expr1 is strictly less than
              expr2.

       expr1 <= expr2
              The result is 1 if expr1 is less than or  equal  to
              expr2.

       expr1 > expr2
              The  result  is 1 if expr1 is strictly greater than
              expr2.

       expr1 >= expr2
              The result is 1 if expr1 is greater than  or  equal
              to expr2.

       expr1 == expr2
              The result is 1 if expr1 is equal to expr2.

       expr1 != expr2
              The result is 1 if expr1 is not equal to expr2.

       Boolean  operations  are  also  legal.  (POSIX bc does NOT
       have boolean operations). The result of all boolean opera-
       tions  are  0  and 1 (for false and true) as in relational
       expressions.  The boolean operators are:

       !expr  The result is 1 if expr is 0.

       expr && expr
              The result is 1 if both expressions are non-zero.

       expr || expr
              The result is 1 if either expression is non-zero.

       The expression precedence is as follows: (lowest to  high-
       est)
              || operator, left associative
              && operator, left associative
              ! operator, nonassociative
              Relational operators, left associative
              Assignment operator, right associative
              + and - operators, left associative
              *, / and % operators, left associative



                                .                               5





bc(1)                                                       bc(1)


              ^ operator, right associative
              unary - operator, nonassociative
              ++ and -- operators, nonassociative

       This precedence was chosen so that POSIX compliant 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:
              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 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  bc.   These have to do with user defined functions and
       standard functions.   They  all  appear  as  "name(parame-
       ters)".   See  the  section  on functions for user defined
       functions.  The standard functions are:

       length ( expression )
              The value of the length function is the  number  of
              significant digits in the expression.

       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 pre-
              viously 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 ibase for the conver-
              sion base.

       scale ( expression )
              The  value  of  the scale function is the number of
              digits after the decimal point in the expression.

       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.

   STATEMENTS
       Statements (as in most algebraic  languages)  provide  the
       sequencing of expression evaluation.  In bc statements are
       executed "as soon as possible."  Execution happens when  a



                                .                               6





bc(1)                                                       bc(1)


       newline  in  encountered and there is one or more complete
       statements.  Due to this immediate execution, newlines are
       very important in bc. In fact, both a semicolon and a new-
       line are used  as  statement  separators.   An  improperly
       placed  newline  will  cause a syntax error.  Because new-
       lines 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  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 bc statements and what they do:
       (Things enclosed in brackets ([]) are  optional  parts  of
       the statement.)

       expression
              This  statement  does  one  of  two things.  If the
              expression  starts  with  "<variable>  <assignment>
              ...",  it  is considered to be an assignment state-
              ment.  If  the  expression  is  not  an  assignment
              statement,  the expression is evaluated and printed
              to the output.  After the number is printed, a new-
              line  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  obase.  The  legal values for 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,  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  num-
              ber  of  characters  required to represent the base
              ten value of "obase-1".  Since numbers are of arbi-
              trary  precision, some numbers may not be printable
              on a single output line.  These long  numbers  will
              be  split  across  lines  using the "\" as the last
              character on a line.  The maximum number of charac-
              ters  printed  per line is 70.  Due to the interac-
              tive nature of bc printing a number causes the side
              effect  of  assigning the printed value the special
              variable last. This allows the user to recover  the
              last  value  printed  without  having to retype the
              expression that printed the number.   Assigning  to
              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 last.)

       string The string is printed to the output.  Strings start



                                .                               7





bc(1)                                                       bc(1)


              with a double quote character and contain all char-
              acters  until the next double quote character.  All
              characters are take literally, including  any  new-
              line.   No  newline  character is printed after the
              string.

       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 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 bc  are  "a"  (alert  or  bell),  "b"
              (backspace),  "f"  (form  feed), "n" (newline), "r"
              (carriage return), "q" (double quote),  "t"  (tab),
              and "\" (backslash).  Any other character following
              the backslash will be ignored.

       { statement_list }
              This is the compound statement.  It allows multiple
              statements to be grouped together for execution.

       if ( expression ) statement1 [else statement2]
              The  if statement evaluates the expression and exe-
              cutes statement1 or  statement2  depending  on  the
              value of the expression.  If the expression is non-
              zero, statement1 is  executed.   If  statement2  is
              present  and the value of the expression is 0, then
              statement2 is executed.  (The  else  clause  is  an
              extension.)

       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.

       for ( [expression1] ; [expression2] ; [expression3] )
       statement
              The for statement controls  repeated  execution  of
              the statement.  Expression1 is evaluated before the
              loop.  Expression2 is evaluated before each  execu-
              tion  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,
              expression3 is evaluated before the reevaluation of
              expression2.   If  expression1  or  expression3 are
              missing, nothing is evaluated  at  the  point  they



                                .                               8





bc(1)                                                       bc(1)


              would  be evaluated.  If expression2 is missing, it
              is the same as substituting the value 1 for expres-
              sion2.  (The optional expressions are an extension.
              POSIX bc requires all three expressions.)  The fol-
              lowing is equivalent code for the for statement:
              expression1;
              while (expression2) {
                 statement;
                 expression3;
              }

       break  This  statement  causes  a  forced exit of the most
              recent enclosing while statement or for  statement.

       continue
              The  continue  statement (an extension)  causes the
              most recent enclosing for statement  to  start  the
              next iteration.

       halt   The  halt  statement  (an extension) is an executed
              statement that causes the bc processor to quit only
              when  it  is  executed.   For example, "if (0 == 1)
              halt" will not cause bc to  terminate  because  the
              halt is not executed.

       return Return  the value 0 from a function.  (See the sec-
              tion on functions.)

       return ( expression )
              Return the value of the expression from a function.
              (See the section on functions.)

   PSEUDO STATEMENTS
       These  statements  are  not  statements in the traditional
       sense.  They are not executed statements.  Their  function
       is performed at "compile" time.

       limits Print  the  local limits enforced by the local ver-
              sion of bc.  This is an extension.

       quit   When the quit statement is read, the  bc  processor
              is  terminated, regardless of where the quit state-
              ment is found.  For example, "if  (0  ==  1)  quit"
              will cause bc to terminate.

       warranty
              Print  a longer warranty notice.  This is an exten-
              sion.

   FUNCTIONS
       Functions provide a method of defining a computation  that
       can  be  executed later.  Functions in bc always compute a
       value and return it to the caller.   Function  definitions
       are  "dynamic"  in  the sense that a function is undefined



                                .                               9





bc(1)                                                       bc(1)


       until a definition is encountered in the input.  That def-
       inition 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:
              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 defini-
       tion by the notation "name[]".    In  the  function  call,
       actual  parameters are full expressions for number parame-
       ters.  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 spec-
       ified 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  ini-
       tialized  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 pro-
       vided in the function call.  Auto variables are  different
       than traditional local variables in the fact that if func-
       tion 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, bc sup-
       ports recursive functions.

       The function body is a  list  of  bc  statements.   Again,
       statements   are  separated  by  semicolons  or  newlines.
       Return statements cause the termination of a function  and
       the  return  of  a  value.   There are two versions of the
       return statement.  The first form, "return",  returns  the
       value  0  to  the  calling  expression.   The second form,
       "return ( expression )", computes the value of the expres-
       sion  and  returns  that  value to the calling expression.
       There is an implied "return  (0)"  at  the  end  of  every



                                .                              10





bc(1)                                                       bc(1)


       function.   This allows a function to terminate and return
       0 without an explicit return statement.

       Functions also change the usage  of  the  variable  ibase.
       All constants in the function body will be converted using
       the value of ibase at  the  time  of  the  function  call.
       Changes  of  ibase will be ignored during the execution of
       the function except for the standard function read,  which
       will  always use the current value of ibase for conversion
       of numbers.

   MATH LIBRARY
       If bc is invoked with the -l option,  a  math  library  is
       preloaded  and  the default 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 fol-
       lowing functions:

       s (x)  The sine of x, x is in radians.

       c (x)  The cosine of x, x is in radians.

       a (x)  The arctangent of x, arctangent returns radians.

       l (x)  The natural logarithm of x.

       e (x)  The exponential function of raising e to the  value
              x.

       j (n,x)
              The bessel function of integer order n of x.

   EXAMPLES
       In  /bin/sh,   the following will assign the value of "pi"
       to the shell variable pi.

              pi=$(echo "scale=10; 4*a(1)" | bc -l)


       The following is the definition of the  exponential  func-
       tion  used  in the math library.  This function is written
       in POSIX 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. */



                                .                              11





bc(1)                                                       bc(1)


                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
       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 "\nCheck book program!\n"
              print "  Remember, deposits are negative transactions.\n"
              print "  Exit by a 0 transaction.\n\n"

              print "Initial balance? "; bal = read()
              bal /= 1
              print "\n"
              while (1) {
                "current balance = "; bal
                "transaction? "; trans = read()
                if (trans == 0) break;
                bal -= trans
                bal /= 1
              }
              quit




                                .                              12





bc(1)                                                       bc(1)


       The following is the definition of the recursive factorial
       function.

              define f (x) {
                if (x <= 1) return (1);
                return (f(x-1) * x);
              }


   READLINE OPTION
       GNU 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 bc.  It
       also allows for a history of previous lines  typed.   When
       this option is selected, bc has one more special variable.
       This special variable, 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 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.

   DIFFERENCES
       This   version  of  bc  was  implemented  from  the  POSIX
       P1003.2/D11 draft and  contains  several  differences  and
       extensions relative to the draft and traditional implemen-
       tations.  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 (-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  fea-
       ture  is extended to add more functionality and additions,
       where new features are added.  The following is  the  list
       of differences and extensions.

       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_.

       names  Traditional  and  POSIX 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,  num-
              bers and the underscore character.

       Strings
              Strings  are not allowed to contain NUL characters.
              POSIX says  all  characters  must  be  included  in



                                .                              13





bc(1)                                                       bc(1)


              strings.

       last   POSIX  bc  does  not  have  a  last variable.  Some
              implementations of bc use the period (.) in a simi-
              lar way.

       comparisons
              POSIX  bc  allows comparisons only in the if state-
              ment, the while statement, and the  second  expres-
              sion  of  the  for statement.  Also, only one rela-
              tional operation is allowed in each of those state-
              ments.

       if statement, else clause
              POSIX bc does not have an else clause.

       for statement
              POSIX  bc requires all expressions to be present in
              the for statement.

       &&, ||, !
              POSIX bc does not have the logical operators.

       read function
              POSIX bc does not have a read function.

       print statement
              POSIX bc does not have a print statement .

       continue statement
              POSIX bc does not have a continue statement.

       array parameters
              POSIX bc does not (currently) support array parame-
              ters  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 bc have only call by
              value array parameters.

       =+, =-, =*, =/, =%, =^
              POSIX bc does not require these "old style" assign-
              ment  operators  to  be  defined.  This version may
              allow these "old style" assignments.  Use the  lim-
              its  statement to see if the installed version sup-
              ports 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.

       spaces in numbers
              Other  implementations  of  bc allow spaces in num-
              bers.  For example, "x=1 3" would assign the  value



                                .                              14





bc(1)                                                       bc(1)


              13  to  the  variable  x.  The same statement would
              cause a syntax error in this version of bc.

       errors and execution
              This implementation varies from  other  implementa-
              tions  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 defini-
              tion, 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 unde-
              fined.  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 state-
              ments.  For example,
              a = 1
              b = 2
       has two execution blocks and
              { 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.

       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 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 bc.

   LIMITS
       The following are the limits currently in place  for  this
       bc  processor.   Some  of them may have been changed by an
       installation.  Use the limits statement to see the  actual
       values.

       BC_BASE_MAX
              The  maximum  output  base is currently set at 999.
              The maximum input base is 16.





                                .                              15





bc(1)                                                       bc(1)


       BC_DIM_MAX
              This is currently an arbitrary limit  of  65535  as
              distributed.  Your installation may be different.

       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.

       BC_STRING_MAX
              The limit on the number of characters in  a  string
              is INT_MAX characters.

       exponent
              The  value  of  the exponent in the raise operation
              (^) is limited to LONG_MAX.

       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.

       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.

       variable names
              The current limit on the number of unique names  is
              32767  for  each  of  simple  variables, arrays and
              functions.

ENVIRONMENT VARIABLES
       The following environment variables are processed by bc:

       POSIXLY_CORRECT
              This is the same as the -s option.

       BC_ENV_ARGS
              This is another mechanism to get arguments  to  bc.
              The  format  is  the same as the command line argu-
              ments.  These arguments are processed first, so any
              files  listed in the environment arguments are pro-
              cessed before  any  command  line  argument  files.
              This  allows  the user to set up "standard" options
              and files to be processed at  every  invocation  of
              bc.   The  files in the environment variables would
              typically contain function  definitions  for  func-
              tions  the user wants defined every time bc is run.

       BC_LINE_LENGTH
              This should be an integer specifing the  number  of



                                .                              16





bc(1)                                                       bc(1)


              characters  in  an  output  line  for numbers. This
              includes the backslash and newline  characters  for
              long numbers.

FILES
       In  most  installations,  bc is completely self-contained.
       Where executable size is of importance or the  C  compiler
       does  not  deal  with  very long strings, bc will read the
       standard math library from  the  file  /usr/local/lib/lib-
       math.b.   (The  actual  location  may  vary.   It  may  be
       /lib/libmath.b.)

DIAGNOSTICS
       If any file on the command line can not be opened, bc will
       report  that the file is unavailable and terminate.  Also,
       there are compile and run time diagnostics that should  be
       self-explanatory.

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 ``bc'' somewhere  in  the  ``Sub-
       ject:'' field.

AUTHOR
       Philip A. Nelson
       phil@cs.wwu.edu

ACKNOWLEDGEMENTS
       The  author  would like to thank Steve Sommars (Steve.Som-
       mars@att.com) for his extensive help in testing the imple-
       mentation.   Many great suggestions were given.  This is a
       much better product due to his involvement.























                                .                              17


