Man Pages

bc(1p) - phpMan bc(1p) - phpMan

Command: man perldoc info search(apropos)  


BC(1P)                     POSIX Programmer's Manual                    BC(1P)



PROLOG
       This manual page is part of the POSIX Programmer's Manual.  The Linux implementation of this interface may dif-
       fer (consult the corresponding Linux manual page for details of Linux behavior), or the interface  may  not  be
       implemented on Linux.

NAME
       bc - arbitrary-precision arithmetic language

SYNOPSIS
       bc [-l] [file ...]

DESCRIPTION
       The  bc  utility  shall implement an arbitrary precision calculator.  It shall take input from any files given,
       then read from the standard input. If the standard input and standard output to bc are attached to a  terminal,
       the  invocation  of  bc  shall be considered to be interactive, causing behavioral constraints described in the
       following sections.

OPTIONS
       The bc utility shall conform to the Base Definitions volume of IEEE Std 1003.1-2001, Section 12.2, Utility Syn-
       tax Guidelines.

       The following option shall be supported:

       -l     (The letter ell.) Define the math functions and initialize scale to 20, instead of the default zero; see
              the EXTENDED DESCRIPTION section.


OPERANDS
       The following operand shall be supported:

       file   A pathname of a text file containing bc program statements.  After all files have been  read,  bc  shall
              read the standard input.


STDIN
       See the INPUT FILES section.

INPUT FILES
       Input  files  shall  be text files containing a sequence of comments, statements, and function definitions that
       shall be executed as they are read.

ENVIRONMENT VARIABLES
       The following environment variables shall affect the execution of bc:

       LANG   Provide a default value for the internationalization variables that are unset or  null.  (See  the  Base
              Definitions  volume  of IEEE Std 1003.1-2001, Section 8.2, Internationalization Variables for the prece-
              dence of internationalization variables used to determine the values of locale categories.)

       LC_ALL If set to a non-empty string value, override the values of all the other internationalization variables.

       LC_CTYPE
              Determine  the locale for the interpretation of sequences of bytes of text data as characters (for exam-
              ple, single-byte as opposed to multi-byte characters in arguments and input files).

       LC_MESSAGES
              Determine the locale that should be used to affect the format and contents of diagnostic messages  writ-
              ten to standard error.

       NLSPATH
              Determine the location of message catalogs for the processing of LC_MESSAGES .


ASYNCHRONOUS EVENTS
       Default.

STDOUT
       The  output  of  the bc utility shall be controlled by the program read, and consist of zero or more lines con-
       taining the value of all executed expressions without assignments. The radix and precision of the output  shall
       be controlled by the values of the obase and scale variables; see the EXTENDED DESCRIPTION section.

STDERR
       The standard error shall be used only for diagnostic messages.

OUTPUT FILES
       None.

EXTENDED DESCRIPTION
   Grammar
       The  grammar  in  this section and the lexical conventions in the following section shall together describe the
       syntax for bc programs. The general conventions for this style of grammar are described in Grammar  Conventions
       .  A  valid  program  can  be represented as the non-terminal symbol program in the grammar. This formal syntax
       shall take precedence over the text syntax description.


              %token    EOF NEWLINE STRING LETTER NUMBER


              %token    MUL_OP
              /*        '*', '/', '%'                           */


              %token    ASSIGN_OP
              /*        '=', '+=', '-=', '*=', '/=', '%=', '^=' */


              %token    REL_OP
              /*        '==', '<=', '>=', '!=', '<', '>'        */


              %token    INCR_DECR
              /*        '++', '--'                              */


              %token    Define    Break    Quit    Length
              /*        'define', 'break', 'quit', 'length'     */


              %token    Return    For    If    While    Sqrt
              /*        'return', 'for', 'if', 'while', 'sqrt'  */


              %token    Scale    Ibase    Obase    Auto
              /*        'scale', 'ibase', 'obase', 'auto'       */


              %start    program


              %%


              program              : EOF
                                   | input_item program
                                   ;


              input_item           : semicolon_list NEWLINE
                                   | function
                                   ;


              semicolon_list       : /* empty */
                                   | statement
                                   | semicolon_list ';' statement
                                   | semicolon_list ';'
                                   ;


              statement_list       : /* empty */
                                   | statement
                                   | statement_list NEWLINE
                                   | statement_list NEWLINE statement
                                   | statement_list ';'
                                   | statement_list ';' statement
                                   ;


              statement            : expression
                                   | STRING
                                   | Break
                                   | Quit
                                   | Return
                                   | Return '(' return_expression ')'
                                   | For '(' expression ';'
                                         relational_expression ';'
                                         expression ')' statement
                                   | If '(' relational_expression ')' statement
                                   | While '(' relational_expression ')' statement
                                   | '{' statement_list '}'
                                   ;


              function             : Define LETTER '(' opt_parameter_list ')'
                                         '{' NEWLINE opt_auto_define_list
                                         statement_list '}'
                                   ;


              opt_parameter_list   : /* empty */
                                   | parameter_list
                                   ;


              parameter_list       : LETTER
                                   | define_list ',' LETTER
                                   ;


              opt_auto_define_list : /* empty */
                                   | Auto define_list NEWLINE
                                   | Auto define_list ';'
                                   ;


              define_list          : LETTER
                                   | LETTER '[' ']'
                                   | define_list ',' LETTER
                                   | define_list ',' LETTER '[' ']'
                                   ;


              opt_argument_list    : /* empty */
                                   | argument_list
                                   ;


              argument_list        : expression
                                   | LETTER '[' ']' ',' argument_list
                                   ;


              relational_expression : expression
                                   | expression REL_OP expression
                                   ;


              return_expression    : /* empty */
                                   | expression
                                   ;


              expression           : named_expression
                                   | NUMBER
                                   | '(' expression ')'
                                   | LETTER '(' opt_argument_list ')'
                                   | '-' expression
                                   | expression '+' expression
                                   | expression '-' expression
                                   | expression MUL_OP expression
                                   | expression '^' expression
                                   | INCR_DECR named_expression
                                   | named_expression INCR_DECR
                                   | named_expression ASSIGN_OP expression
                                   | Length '(' expression ')'
                                   | Sqrt '(' expression ')'
                                   | Scale '(' expression ')'
                                   ;


              named_expression     : LETTER
                                   | LETTER '[' expression ']'
                                   | Scale
                                   | Ibase
                                   | Obase
                                   ;

   Lexical Conventions in bc
       The lexical conventions for bc programs, with respect to the preceding grammar, shall be as follows:

        1. Except as noted, bc shall recognize the longest possible token or delimiter beginning at a given point.


        2. A comment shall consist of any characters beginning with the two adjacent characters "/*" and terminated by
           the  next  occurrence of the two adjacent characters "*/" . Comments shall have no effect except to delimit
           lexical tokens.


        3. The <newline> shall be recognized as the token NEWLINE.


        4. The token STRING shall represent a string constant; it shall consist of any characters beginning  with  the
           double-quote character ( ' )' and terminated by another occurrence of the double-quote character. The value
           of the string is the sequence of all characters between, but not including, the  two  double-quote  charac-
           ters.  All characters shall be taken literally from the input, and there is no way to specify a string con-
           taining  a  double-quote  character.  The  length  of  the  value  of  each  string  shall  be  limited  to
           {BC_STRING_MAX} bytes.


        5. A  <blank>  shall have no effect except as an ordinary character if it appears within a STRING token, or to
           delimit a lexical token other than STRING.


        6. The combination of a backslash character immediately followed by a <newline> shall  have  no  effect  other
           than to delimit lexical tokens with the following exceptions:

            * It shall be interpreted as the character sequence "\<newline>" in STRING tokens.


            * It shall be ignored as part of a multi-line NUMBER token.



        7. The token NUMBER shall represent a numeric constant. It shall be recognized by the following grammar:


           NUMBER  : integer
                   | '.' integer
                   | integer '.'
                   | integer '.' integer
                   ;


           integer : digit
                   | integer digit
                   ;


           digit   : 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7
                   | 8 | 9 | A | B | C | D | E | F
                   ;


        8. The  value  of  a  NUMBER token shall be interpreted as a numeral in the base specified by the value of the
           internal register ibase (described below). Each of the digit characters shall have the value from 0  to  15
           in  the  order listed here, and the period character shall represent the radix point. The behavior is unde-
           fined if digits greater than or equal to the value of ibase appear in the token. However, note  the  excep-
           tion for single-digit values being assigned to ibase and obase themselves, in Operations in bc .


        9. The following keywords shall be recognized as tokens:


                                            auto     ibase   length   return   while
                                            break    if      obase    scale
                                            define   for     quit     sqrt



       10. Any of the following characters occurring anywhere except within a keyword shall be recognized as the token
           LETTER:


           a b c d e f g h i j k l m n o p q r s t u v w x y z


       11. The following single-character and two-character sequences shall be recognized as the token ASSIGN_OP:


           =   +=   -=   *=   /=   %=   ^=


       12. If an '=' character, as the beginning of a token, is followed by a '-' character with no intervening delim-
           iter, the behavior is undefined.


       13. The following single-characters shall be recognized as the token MUL_OP:


           *   /   %


       14. The following single-character and two-character sequences shall be recognized as the token REL_OP:


           ==   <=   >=   !=   <   >


       15. The following two-character sequences shall be recognized as the token INCR_DECR:


           ++   --


       16. The following single characters shall be recognized as tokens whose names are the character:


           <newline>  (  )  ,  +  -  ;  [  ]  ^  {  }


       17. The token EOF is returned when the end of input is reached.


   Operations in bc
       There  are  three  kinds of identifiers: ordinary identifiers, array identifiers, and function identifiers. All
       three types consist of single lowercase letters. Array identifiers shall be followed by square brackets (  "[]"
       ).  An  array  subscript  is required except in an argument or auto list. Arrays are singly dimensioned and can
       contain up to {BC_DIM_MAX} elements.  Indexing  shall  begin  at  zero  so  an  array  is  indexed  from  0  to
       {BC_DIM_MAX}-1.   Subscripts shall be truncated to integers. The application shall ensure that function identi-
       fiers are followed by parentheses, possibly enclosing arguments. The three types of  identifiers  do  not  con-
       flict.

       The  following  table  summarizes the rules for precedence and associativity of all operators. Operators on the
       same line shall have the same precedence; rows are in order of decreasing precedence.

                                                   Table: Operators in bc

                                          Operator                    Associativity
                                          ++, --                      N/A
                                          unary -                     N/A
                                          ^                           Right to left
                                          *, /, %                     Left to right
                                          +, binary -                 Left to right
                                          =, +=, -=, *=, /=, %=, ^=   Right to left
                                          ==, <=, >=, !=, <, >        None

       Each expression or named expression has a scale, which is the number of decimal digits that shall be maintained
       as the fractional portion of the expression.

       Named  expressions  are places where values are stored. Named expressions shall be valid on the left side of an
       assignment.  The value of a named expression shall be the value stored in the place named.  Simple  identifiers
       and array elements are named expressions; they have an initial value of zero and an initial scale of zero.

       The internal registers scale, ibase, and obase are all named expressions. The scale of an expression consisting
       of the name of one of these registers shall be zero; values assigned to any of these registers are truncated to
       integers.  The  scale  register  shall  contain  a  global value used in computing the scale of expressions (as
       described below).  The value of the register scale is limited to 0 <= scale <= {BC_SCALE_MAX} and shall have  a
       default  value  of zero. The ibase and obase registers are the input and output number radix, respectively. The
       value of ibase shall be limited to:


              2 <= ibase <= 16

       The value of obase shall be limited to:


              2 <= obase <= {BC_BASE_MAX}

       When either ibase or obase is assigned a single digit value from the list in Lexical  Conventions  in  bc,  the
       value  shall be assumed in hexadecimal. (For example, ibase=A sets to base ten, regardless of the current ibase
       value.) Otherwise, the behavior is undefined when digits greater than or equal to the value of ibase appear  in
       the input. Both ibase and obase shall have initial values of 10.

       Internal  computations  shall  be  conducted as if in decimal, regardless of the input and output bases, to the
       specified number of decimal digits. When an exact result is not achieved  (for  example,  scale=0; 3.2/1),  the
       result shall be truncated.

       For  all  values  of  obase specified by this volume of IEEE Std 1003.1-2001, bc shall output numeric values by
       performing each of the following steps in order:

        1. If the value is less than zero, a hyphen ( '-' ) character shall be output.


        2. One of the following is output, depending on the numerical value:

            * If the absolute value of the numerical value is greater than or equal to one, the integer portion of the
              value  shall be output as a series of digits appropriate to obase (as described below), most significant
              digit first. The most significant non-zero digit shall be output next,  followed  by  each  successively
              less significant digit.


            * If the absolute value of the numerical value is less than one but greater than zero and the scale of the
              numerical value is greater than zero, it is unspecified whether the character 0 is output.


            * If the numerical value is zero, the character 0 shall be output.



        3. If the scale of the value is greater than zero and the numeric value is not zero, a period character  shall
           be  output,  followed by a series of digits appropriate to obase (as described below) representing the most
           significant portion of the fractional part of the value. If s represents the scale of the value being  out-
           put,  the  number  of  digits output shall be s if obase is 10, less than or equal to s if obase is greater
           than 10, or greater than or equal to s if obase is less than 10. For  obase  values  other  than  10,  this
           should be the number of digits needed to represent a precision of 10**s.


       For obase values from 2 to 16, valid digits are the first obase of the single characters:


              0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F

       which represent the values zero to 15, inclusive, respectively.

       For  bases  greater  than  16, each digit shall be written as a separate multi-digit decimal number. Each digit
       except the most significant fractional digit shall be preceded by a single <space>.  For bases from 17 to  100,
       bc  shall  write two-digit decimal numbers; for bases from 101 to 1000, three-digit decimal strings, and so on.
       For example, the decimal number 1024 in base 25 would be written as:


               01 15 24

       and in base 125, as:


               008 024

       Very large numbers shall be split across lines with 70 characters per line in the POSIX locale;  other  locales
       may split at different character boundaries. Lines that are continued shall end with a backslash ( '\' ).

       A  function  call shall consist 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 shall be  specified  by  the
       array  name  followed  by  empty square brackets. All function arguments shall be passed by value. As a result,
       changes made to the formal parameters shall have no effect on the actual arguments. If the function  terminates
       by  executing  a return statement, the value of the function shall be the value of the expression in the paren-
       theses of the return statement or shall be zero if no expression is provided or if there is  no  return  state-
       ment.

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

       The  result  of  length( expression) shall be the total number of significant decimal digits in the expression.
       The scale of the result shall be zero.

       The result of scale( expression) shall be the scale of the expression. The scale of the result shall be zero.

       A numeric constant shall be an expression. The scale shall be the number of digits that follow the radix  point
       in the input representing the constant, or zero if no radix point appears.

       The sequence ( expression ) shall be an expression with the same value and scale as expression. The parentheses
       can be used to alter the normal precedence.

       The semantics of the unary and binary operators are as follows:

       -expression

              The result shall be the negative of the expression. The scale of  the  result  shall  be  the  scale  of
              expression.


       The  unary increment and decrement operators shall not modify the scale of the named expression upon which they
       operate. The scale of the result shall be the scale of that named expression.

       ++named-expression

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

       --named-expression

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

       named-expression++

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

       named-expression--

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


       The exponentiation operator, circumflex ( '^' ), shall bind right to left.

       expression^expression

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


              if b >= 0 min(a * b, max(scale, a)) if b < 0 scale

       The multiplicative operators ( '*', '/', '%' ) shall bind left to right.

       expression*expression

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


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

       expression/expression

              The  result  shall be the quotient of the two expressions. The scale of the result shall be the value of
              scale.

       expression%expression

              For expressions a and b, a% b shall be evaluated equivalent to the steps:

               1. Compute a/ b to current scale.


               2. Use the result to compute:


                  a - (a / b) * b

              to scale:


                     max(scale + scale(b), scale(a))

       The scale of the result shall be:


              max(scale + scale(b), scale(a))

       When scale is zero, the '%' operator is the mathematical remainder operator.


       The additive operators ( '+', '-' ) shall bind left to right.

       expression+expression

              The result shall be the sum of the two expressions. The scale of the result shall be the maximum of  the
              scales of the expressions.

       expression-expression

              The  result shall be the difference of the two expressions. The scale of the result shall be the maximum
              of the scales of the expressions.


       The assignment operators ( '=', "+=", "-=", "*=", "/=", "%=", "^=" ) shall bind right to left.

       named-expression=expression

              This expression shall result in assigning the value of the expression on the right to the named  expres-
              sion  on  the  left. The scale of both the named expression and the result shall be the scale of expres-
              sion.


       The compound assignment forms:


              named-expression <operator>= expression

       shall be equivalent to:


              named-expression=named-expression <operator> expression

       except that the named-expression shall be evaluated only once.

       Unlike all other operators, the relational operators ( '<', '>', "<=", ">=", "==", "!=" ) shall be  only  valid
       as the object of an if, while, or inside a for statement.

       expression1<expression2

              The relation shall be true if the value of expression1 is strictly less than the value of expression2.

       expression1>expression2

              The  relation  shall  be  true if the value of expression1 is strictly greater than the value of expres-
              sion2.

       expression1<=expression2

              The relation shall be true if the value of expression1 is less than or equal to  the  value  of  expres-
              sion2.

       expression1>=expression2

              The  relation shall be true if the value of expression1 is greater than or equal to the value of expres-
              sion2.

       expression1==expression2

              The relation shall be true if the values of expression1 and expression2 are equal.

       expression1!=expression2

              The relation shall be true if the values of expression1 and expression2 are unequal.


       There are only two storage classes in bc: global and automatic (local). Only identifiers that are  local  to  a
       function  need  be  declared with the auto command. The arguments to a function shall be 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 shall be allocated on entry to the function
       and released on returning from the function. They therefore do not retain values between function  calls.  Auto
       arrays  shall be specified by the array name followed by empty square brackets. On entry to a function, the old
       values of the names that appear as parameters and as automatic variables shall be pushed onto  a  stack.  Until
       the function returns, reference to these names shall refer only to the new values.

       References  to any of these names from other functions that are called from this function also refer to the new
       value until one of those functions uses the same name for a local variable.

       When a statement is an expression, unless the main operator is an assignment, execution of the statement  shall
       write the value of the expression followed by a <newline>.

       When a statement is a string, execution of the statement shall write the value of the string.

       Statements  separated  by semicolons or <newline>s shall be executed sequentially. In an interactive invocation
       of bc, each time a <newline> is read that satisfies the grammatical production:


              input_item : semicolon_list NEWLINE

       the sequential list of statements making up the semicolon_list shall be executed  immediately  and  any  output
       produced by that execution shall be written without any delay due to buffering.

       In an if statement ( if( relation) statement), the statement shall be executed if the relation is true.

       The  while statement ( while( relation) statement) implements a loop in which the relation is tested; each time
       the relation is true, the statement shall be executed and the relation retested. When the  relation  is  false,
       execution shall resume after statement.

       A for statement( for( expression; relation; expression) statement) shall be the same as:


              first-expressionwhile (relation) {
                  statement    last-expression}
       The application shall ensure that all three expressions are present.

       The break statement shall cause termination of a for or while statement.

       The  auto  statement  (  auto  identifier  [, identifier ] ...) shall cause the values of the identifiers to be
       pushed down. The identifiers can be ordinary identifiers or array identifiers. Array identifiers shall be spec-
       ified  by  following the array name by empty square brackets. The application shall ensure that the auto state-
       ment is the first statement in a function definition.

       A define statement:


              define LETTER ( opt_parameter_list ) {
                  opt_auto_define_list    statement_list}

       defines a function named LETTER. If a function named LETTER was previously defined, the define statement  shall
       replace the previous definition. The expression:


              LETTER ( opt_argument_list )

       shall  invoke the function named LETTER. The behavior is undefined if the number of arguments in the invocation
       does not match the number of parameters in the definition. Functions shall be defined before they are  invoked.
       A  function  shall be considered to be defined within its own body, so recursive calls are valid. The values of
       numeric constants within a function shall be interpreted in the base specified by the value of the ibase regis-
       ter when the function is invoked.

       The  return  statements ( return and return( expression)) shall cause termination of a function, popping of its
       auto variables, and specification of the result of  the  function.  The  first  form  shall  be  equivalent  to
       return(0).  The  value  and  scale  of  the result returned by the function shall be the value and scale of the
       expression returned.

       The quit statement ( quit) shall stop execution of a bc program at the point where the statement occurs in  the
       input, even if it occurs in a function definition, or in an if, for, or while statement.

       The following functions shall be defined when the -l option is specified:

       s( expression )

              Sine of argument in radians.

       c( expression )

              Cosine of argument in radians.

       a( expression )

              Arctangent of argument.

       l( expression )

              Natural logarithm of argument.

       e( expression )

              Exponential function of argument.

       j( expression, expression )

              Bessel function of integer order.


       The  scale  of  the result returned by these functions shall be the value of the scale register at the time the
       function is invoked. The value of the scale register after these functions have completed their execution shall
       be  the  same value it had upon invocation. The behavior is undefined if any of these functions is invoked with
       an argument outside the domain of the mathematical function.

EXIT STATUS
       The following exit values shall be returned:

       0      All input files were processed successfully.

       unspecified
              An error occurred.


CONSEQUENCES OF ERRORS
       If any file operand is specified and the named file cannot be accessed, bc shall write a diagnostic message  to
       standard error and terminate without any further action.

       In  an  interactive invocation of bc, the utility should print an error message and recover following any error
       in the input. In a non-interactive invocation of bc, invalid input causes undefined behavior.

       The following sections are informative.

APPLICATION USAGE
       Automatic variables in bc do not work in exactly the same way as in either C or PL/1.

       For historical reasons, the exit status from bc cannot be relied upon to indicate that an error  has  occurred.
       Returning zero after an error is possible. Therefore, bc should be used primarily by interactive users (who can
       react to error messages) or by application programs that can somehow  validate  the  answers  returned  as  not
       including error messages.

       The  bc utility always uses the period ( '.' ) character to represent a radix point, regardless of any decimal-
       point character specified as part of the current locale. In languages like C or awk, the  period  character  is
       used  in  program source, so it can be portable and unambiguous, while the locale-specific character is used in
       input and output. Because there is no distinction between source and input in bc, this arrangement would not be
       possible. Using the locale-specific character in bc's input would introduce ambiguities into the language; con-
       sider the following example in a locale with a comma as the decimal-point character:


              define f(a,b) {
                  ...
              }
              ...


              f(1,2,3)

       Because of such ambiguities, the period character is used in input.  Having input follow different  conventions
       from  output  would  be  confusing in either pipeline usage or interactive usage, so the period is also used in
       output.

EXAMPLES
       In the shell, the following assigns an approximation of the first ten digits of 'pi' to the variable x:


              x=$(printf "%s\n" 'scale = 10; 104348/33215' | bc)

       The following bc program prints the same approximation of 'pi', with a label, to standard output:


              scale = 10
              "pi equals "
              104348 / 33215

       The following defines a function to compute an approximate value of the exponential function (note that such  a
       function is predefined if the -l option is specified):


              scale = 20
              define e(x){
                  auto a, b, c, i, s
                  a = 1
                  b = 1
                  s = 1
                  for (i = 1; 1 == 1; i++){
                      a = a*x
                      b = b*i
                      c = a/b
                      if (c == 0) {
                           return(s)
                      }
                      s = s+c
                  }
              }

       The following prints approximate values of the exponential function of the first ten integers:


              for (i = 1; i <= 10; ++i) {
                  e(i)
              }

RATIONALE
       The  bc  utility is implemented historically as a front-end processor for dc; dc was not selected to be part of
       this volume of IEEE Std 1003.1-2001 because bc was thought to have a  more  intuitive  programmatic  interface.
       Current implementations that implement bc using dc are expected to be compliant.

       The exit status for error conditions has been left unspecified for several reasons:

        * The  bc  utility  is  used  in  both interactive and non-interactive situations. Different exit codes may be
          appropriate for the two uses.


        * It is unclear when a non-zero exit should be given; divide-by-zero, undefined functions, and  syntax  errors
          are all possibilities.


        * It is not clear what utility the exit status has.


        * In the 4.3 BSD, System V, and Ninth Edition implementations, bc works in conjunction with dc. The dc utility
          is the parent, bc is the child. This was done to cleanly terminate bc if dc aborted.


       The decision to have bc exit upon encountering an inaccessible input file is based on the belief that bc  file1
       file2  is  used  most  often when at least file1 contains data/function declarations/initializations. Having bc
       continue with prerequisite files missing is probably not useful. There is no implication in the CONSEQUENCES OF
       ERRORS section that bc must check all its files for accessibility before opening any of them.

       There  was  considerable  debate  on the appropriateness of the language accepted by bc. Several reviewers pre-
       ferred to see either a pure subset of the C language or some changes to make the language more compatible  with
       C.  While  the  bc  language has some obvious similarities to C, it has never claimed to be compatible with any
       version of C. An interpreter for a subset of C might be a very worthwhile utility,  and  it  could  potentially
       make  bc obsolete. However, no such utility is known in historical practice, and it was not within the scope of
       this volume of IEEE Std 1003.1-2001 to define such a language and utility. If and when they are defined, it may
       be appropriate to include them in a future version of IEEE Std 1003.1. This left the following alternatives:

        1. Exclude any calculator language from this volume of IEEE Std 1003.1-2001.

       The  consensus of the standard developers was that a simple programmatic calculator language is very useful for
       both applications and interactive users. The only arguments for excluding any calculator  were  that  it  would
       become  obsolete if and when a C-compatible one emerged, or that the absence would encourage the development of
       such a C-compatible one. These arguments did not sufficiently address the needs of current application writers.


        2. Standardize the historical dc, possibly with minor modifications.

       The  consensus  of  the  standard  developers was that dc is a fundamentally less usable language and that that
       would be far too severe a penalty for avoiding the issue of being similar to but incompatible with C.


        3. Standardize the historical bc, possibly with minor modifications.

       This was the approach taken. Most of the proponents of changing the language  would  not  have  been  satisfied
       until  most  or  all  of  the incompatibilities with C were resolved. Since most of the changes considered most
       desirable  would  break  historical  applications  and   require   significant   modification   to   historical
       implementations,  almost  no  modifications  were  made. The one significant modification that was made was the
       replacement of the historical bc assignment operators "=+", and so on, with the more modern "+=",  and  so  on.
       The  older  versions  are  considered  to be fundamentally flawed because of the lexical ambiguity in uses like
       a=-1.

       In order to permit implementations to deal with backwards-compatibility as they see fit, the behavior  of  this
       one  ambiguous  construct  was  made undefined. (At least three implementations have been known to support this
       change already, so the degree of change involved should not be great.)


       The '%' operator is the mathematical remainder operator when scale is zero. The behavior of this  operator  for
       other values of scale is from historical implementations of bc, and has been maintained for the sake of histor-
       ical applications despite its non-intuitive nature.

       Historical implementations permit setting ibase and obase to a broader range of values.  This  includes  values
       less than 2, which were not seen as sufficiently useful to standardize.  These implementations do not interpret
       input properly for values of ibase that are greater than 16. This is because numeric constants  are  recognized
       syntactically,  rather than lexically, as described in this volume of IEEE Std 1003.1-2001. They are built from
       lexical tokens of single hexadecimal digits and periods. Since <blank>s between tokens are not visible  at  the
       syntactic  level,  it  is not possible to recognize the multi-digit "digits" used in the higher bases properly.
       The ability to recognize input in these bases was not considered  useful  enough  to  require  modifying  these
       implementations.  Note  that  the recognition of numeric constants at the syntactic level is not a problem with
       conformance to this volume of IEEE Std 1003.1-2001, as it does not impact the behavior of  conforming  applica-
       tions  (and correct bc programs). Historical implementations also accept input with all of the digits '0' - '9'
       and 'A' - 'F' regardless of the value of ibase; since digits with value greater than or equal to ibase are  not
       really appropriate, the behavior when they appear is undefined, except for the common case of:


              ibase=8;
                  /* Process in octal base. */
              ...
              ibase=A
                  /* Restore decimal base. */

       In  some historical implementations, if the expression to be written is an uninitialized array element, a lead-
       ing <space> and/or up to four leading 0 characters may be output before the character zero.  This  behavior  is
       considered a bug; it is unlikely that any currently conforming application relies on:


              echo 'b[3]' | bc

       returning 00000 rather than 0.

       Exact calculation of the number of fractional digits to output for a given value in a base other than 10 can be
       computationally expensive. Historical implementations use a faster approximation, and this is  permitted.  Note
       that the requirements apply only to values of obase that this volume of IEEE Std 1003.1-2001 requires implemen-
       tations to support (in particular, not to 1, 0, or negative bases, if an implementation  supports  them  as  an
       extension).

       Historical  implementations  of bc did not allow array parameters to be passed as the last parameter to a func-
       tion. New implementations are encouraged to remove this restriction even though it is not required by the gram-
       mar.

FUTURE DIRECTIONS
       None.

SEE ALSO
       Grammar Conventions, awk

COPYRIGHT
       Portions of this text are reprinted and reproduced in electronic form from IEEE Std 1003.1, 2003 Edition, Stan-
       dard for Information Technology -- Portable Operating System Interface (POSIX), The Open Group Base  Specifica-
       tions  Issue  6,  Copyright (C) 2001-2003 by the Institute of Electrical and Electronics Engineers, Inc and The
       Open Group. In the event of any discrepancy between this version and the original IEEE and The Open Group Stan-
       dard,  the  original  IEEE  and  The  Open Group Standard is the referee document. The original Standard can be
       obtained online at http://www.opengroup.org/unix/online.html .



IEEE/The Open Group                  2003                               BC(1P)