NAME

     bc - An arbitrary precision calculator language


SYNTAX

     bc [ -lws ] [  file ... ]


VERSION

     This man page documents GNU bc version 1.02.


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 processor, bc will never read from the
     standard input.)

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

  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
     variables 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 letters 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.

  EXPRESSIONS
     The numbers are manipulated by expressions  and  statements.
     Since  the  language  was designed to be interactive, state-
     ments and expressions are  executed  as  soon  as  possible.
     There is no "main" program.  Instead, code is executed as it
     is encountered.  (Functions, discussed in detail later,  are
     defined when encountered.)

     A simple expression is just a  constant.  bc  converts  con-
     stants into internal decimal numbers using the current input
     base, specified by the variable ibase. (There is  an  excep-
     tion in functions.)  The legal values of ibase are 2 through
     16 (F).  Assigning a value outside this range to ibase  will
     result in a value of 2 or 16.  Input numbers may contain the
     characters 0-9 and  A-F.  (Note:   They  must  be  capitals.
     Lower  case  letters  are  variable  names.)   Single  digit
     numbers always have the value of the digit regardless of the
     value  of ibase. (i.e. A = 10.)  For 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
     languages.   Since  there  is only one kind of number, there
     are no rules for mixing types.  Instead, there are rules  on
     the  scale  of  expressions.   Every expression has a scale.
     This is derived from the  scale  of  original  numbers,  the
     operation  performed  and  in  many  cases, the value of the
     variable scale. Legal values of the variable scale are 0  to
     the maximum number representable by a C integer.

     In the following descriptions of legal  expressions,  "expr"
     refers to a complete expression and "var" refers to a simple
     or an array variable.  A simple variable is just a
          name
     and an array variable is specified as
          name[expr]
     Unless specifically mentioned the scale of the result is the
     maximum scale of the expressions involved.

     - 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 vari-
          able and then the variable is incremented by one.

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

     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 integers this expression
          is the integer remainder function.

     expr ^ expr
          The result of the expression is the value of the  first
          raised  to the second. The second expression must be an
          integer.  (If the second expression is not an  integer,
          a  warning is generated and the expression is truncated
          to get an integer value.)  The scale of the  result  is
          scale  if the exponent is negative.  If the exponent is
          positive the scale of the result is the minimum of  the
          scale  of  the  first expression times the value of the
          exponent and the maximum of scale and the scale of  the
          first  expression.   (e.g. scale(a^b) = min(scale(a)*b,
          max( scale,  scale(a))).)   It  should  be  noted  that
          expr^0 will always return the value of 1.

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

     var = expr
          The variable is assigned the value of the expression.

     var <op>= expr
          This is equivalent to "var = var <op>  expr"  with  the
          exception  that  the "var" part is evaluated only once.
          This can make a difference if "var" is an array.

      Relational expressions are a  special  kind  of  expression
     that  always  evaluate to 0 or 1, 0 if the relation is false
     and 1 if the relation is true.   These  may  appear  in  any
     legal   expression.   (POSIX  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 operations
     are 0 and 1 (for false and true) as  in  relational  expres-
     sions.  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 highest)
          || operator, left associative
          && operator, left associative
          ! operator, nonassociative
          Relational operators, left associative
          Assignment operator, right associative
          + and - operators, left associative
          *, / and % operators, left associative
          ^ operator, right associative
          unary - operator, nonassociative
          ++ and -- operators, nonassociative

     This precedence was chosen so that POSIX compliant  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(parameters)".
     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  sig-
          nificant digits in the expression.

     read ( )
          The read function (an extension)  will  read  a  number
          from  the standard input, regardless of where the func-
          tion occurs.   Beware, this can cause problems with the
          mixing  of data and program in the standard input.  The
          best use for this function is in a  previously  written
          program  that  needs  input  from  the  user, but never
          allows program code to be input  from  the  user.   The
          value  of the read function is the number read from the
          standard input using the current value of the  variable
          ibase for the conversion 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
     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 newlines are
     statement separators, it is possible to hide  a  newline  by
     using  the backslash character.  The sequence "\<nl>", where
     <nl> is the newline appears to 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  expres-
          sion  starts  with "<variable> <assignment> ...", it is
          considered to  be  an  assignment  statement.   If  the
          expression  is not an assignment statement, the expres-
          sion is evaluated and printed to the output.  After the
          number  is printed, a newline is printed.  For example,
          "a=1" is an assignment  statement  and  "(a=1)"  is  an
          expression   that  has  an  embedded  assignment.   All
          numbers that are printed are printed in the base speci-
          fied  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 number  of  characters
          required  to represent the base ten value of "obase-1".
          Since numbers are of arbitrary precision, some  numbers
          may  not  be  printable on a single output line.  These
          long numbers will be split across lines using  the  "\"
          as the last character on a line.  The maximum number of
          characters printed per line is 70.  Due to the interac-
          tive  nature  of  bc  printing  a number cause the side
          effect of assigning the printed value the  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.

     string
          The string is printed to  the  output.   Strings  start
          with  a  double quote character and contain all charac-
          ters until the next double quote character.  All  char-
          acters  are  take literally, including any newline.  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
          the variable last. Strings in the print  statement  are
          printed  to  the output and may contain special charac-
          ters.  Special  characters  start  with  the  backslash
          character (\).  The special characters recognized by bc
          are "b" (bell), "f" (form  feed),  "n"  (newline),  "r"
          (carriage return), "t" (tab), and "\" (backslash).  Any
          other  character  following  the  backslash   will   be
          ignored.   This  still  does not allow the double quote
          character to be part of any string.

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

     if ( expression ) then statement1 [else statement2]
          The if statement evaluates the expression and  executes
          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 expres-
          sion before each execution of the statement.   Termina-
          tion  of  the loop is caused by a zero expression 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 execution of the
          statement.   If  it  is  non-zero,  the  statement   is
          evaluated.   If  it  is  zero,  the loop is terminated.
          After each execution of the statement,  expression3  is
          evaluated  before  the reevaluation of expression2.  If
          expression1 or  expression3  are  missing,  nothing  is
          evaluated  at  the  point  they would be evaluated.  If
          expression2 is missing, it is the same as  substituting
          the value 1 for expression2.  (The optional expressions
          are an extension. POSIX bc requires all  three  expres-
          sions.)   The  following 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 itera-
          tion.

     halt The halt statement (an extension) is an executed state-
          ment  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  section
          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 version of
          bc.  This is an extension.

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

     warranty
          Print a longer warranty notice.  This is an extension.

  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 until a
     definition is encountered in the input.  That definition  is
     then  used  until  another  definition function for the same
     name is encountered.  The new definition then  replaces  the
     older definition.  A function is defined as follows:
          define name ( parameters ) { newline
              auto_list   statement_list }
     A  function  call  is  just  an  expression  of   the   form
     "name(parameters)".

     Parameters are numbers or arrays  (an  extension).   In  the
     function  definition, zero or more parameters are defined by
     listing their names separated by commas.  Numbers  are  only
     call by value parameters.  Arrays are only call by variable.
     Arrays are specified in  the  parameter  definition  by  the
     notation "name[]".   In the function call, actual parameters
     are full expressions for number parameters.  The same  nota-
     tion is used for passing arrays as for defining array param-
     eters.  The named array is passed by variable to  the  func-
     tion.   Since  function  definitions  are dynamic, parameter
     numbers and types are checked when  a  function  is  called.
     Any  mismatch  in number or types of parameters will cause a
     runtime error.  A runtime error will also occur for the call
     to an undefined function.

     The auto_list is an optional list of variables that are  for
     "local"  use.   The  syntax of the auto list (if present) is
     "auto name, ... ;".  (The semicolon is optional.)  Each name
     is the name of an auto variable.  Arrays may be specified by
     using the same notation as used in parameters.  These  vari-
     ables  have their values pushed onto a stack at the start of
     the function.  The variables are then  initialized  to  zero
     and used throughout the execution of the function.  At func-
     tion exit, these variables are popped so that  the  original
     value  (at the time of the function call) of these variables
     are restored.  The parameters are really auto variables that
     are  initialized  to  a value provided in the function call.
     Auto variables are different than  traditional  local  vari-
     ables in the fact that if function A calls function B, B may
     access function A's auto variables by just  using  the  same
     name, unless function B has called them auto variables.  Due
     to the fact that auto variables and  parameters  are  pushed
     onto a stack, bc supports recursive functions.

     The function body is a list of bc statements.  Again, state-
     ments  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 ( expres-
     sion )", computes the value of the  expression  and  returns
     that  value  to the calling expression.  There is an implied
     "return (0)" at the end of every function.   This  allows  a
     function  to  terminate  and  return  0  without an explicit
     return statement.

     Functions also change the usage of the variable 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 follow-
     ing functions:

     s (x)
          The sine of x in radians.

     c (x)
          The cosine of x in radians.

     a (x)
          The arctangent of x.

     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  function
     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. */
            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 bal-
     ances.  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


     The following is the definition of the  recursive  factorial
     function.

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


  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
     implementations.   It  is not implemented in the traditional
     way using dc(1). This version  is  a  single  process  which
     parses  and  runs  a  byte  code translation of the program.
     There is an "undocumented" option (-c) that causes the  pro-
     gram  to output the byte code to the standard output instead
     of running it.  It was mainly used for debugging the  parser
     and preparing the math library.

     A major source of differences is extensions, where a feature
     is  extended  to add more functionality and additions, where
     new features are added. The following is the list of differ-
     ences and extensions.

     LANG       This version does not conform to the POSIX  stan-
                dard  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,
                numbers and the underscore character.

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

     last       POSIX bc does not have  a  last  variable.   Some
                implementations  of  bc  use  the period (.) in a
                similar 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
                statements.

     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 have array  parameters.   Other
                implementations  of  bc  may  have  call by value
                array parameters.

     =+, =-, =*, =/, =%, =^
                POSIX bc  does  not  require  these  "old  style"
                assignment operators to be defined.  This version
                may allow these "old style" assignments.  Use the
                limits  statement to see if the installed version
                supports them.   If  it  does  support  the  "old
                style"  assignment operators, the statement "a =-
                1" will decrement a by 1 instead of setting a  to
                the value -1.

     spaces in numbers
                Other  implementations  of  bc  allow  spaces  in
                numbers.   For  example, "x=1 3" would assign the
                value 13 to the variable x.  The  same  statement
                would cause a syntax error in this version of 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 func-
                tion.  Once a syntax error is found in the  func-
                tion,  the  function  will  not  be  callable and
                becomes undefined.  Syntax errors in the interac-
                tive  execution  code will invalidate the current
                execution block.  The  execution  block  is  ter-
                minated  by  an  end of line that appears after a
                complete sequence of statements.  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 interrup-
                tion.  All auto variables and function parameters
                are removed during the clean up process.   During
                a non-interactive session, 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 instal-
     lation.  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.

     BC_DIM_MAX
          This is currently an arbitrary limit of 65535  as  dis-
          tributed.  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
          10240  bytes  of  compiled  byte code each.  This limit
          (BC_MAX_SEGS) can be easily changed to have  more  than
          10 segments of 1024 bytes.

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


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 stan-
     dard  math  library  from the file /usr/local/lib/libmath.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.


AUTHOR

     Philip A. Nelson
     phil@cs.wwu.edu


ACKNOWLEDGEMENTS

     The   author   would   like   to   thank    Steve    Sommars
     (sesv@iwtsf.att.com)  for  his extensive help in testing the
     implementation.  Many great suggestions were given.  This is
     a much better product due to his involvement.