bc.1

操作系统设计与实现源码

bc(1)                     Minix Programmer's Manual                      bc(1)


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







                                     .\                                      1



bc(1)                     Minix Programmer's Manual                      bc(1)


  VARIABLES
     Numbers are stored in  two  types  of  variables,  simple  variables  and
     arrays.   Both  simple  variables  and  array variables are named.  Names
     begin with a letter  followed  by  any  number  of  letters,  digits  and
     underscores.   All letters must be lower case.  (Full alpha-numeric names
     are an extension. In POSIX 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, statements and expressions are
     executed as soon as possible.  There is no "main" program.  Instead, code
     is executed as it is encountered.  (Functions, discussed in detail later,
     are defined when encountered.)

     A simple expression is  just  a  constant.  bc  converts  constants  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 (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.


                                     .\                                      2



bc(1)                     Minix Programmer's Manual                      bc(1)


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

     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


                                     .\                                      3



bc(1)                     Minix Programmer's Manual                      bc(1)


          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.




                                     .\                                      4



bc(1)                     Minix Programmer's Manual                      bc(1)


     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 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 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 programs  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 significant digits
          in the expression.




                                     .\                                      5