bc

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



PROLOG
       This manual page is part of the POSIX Programmer's Manual.  The Linux
       implementation of this interface may differ (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
       POSIX.1‐2008, Section 12.2, Utility Syntax 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
                 POSIX.1‐2008, Section 8.2, Internationalization Variables for
                 the precedence 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 example, 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 written 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 containing 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 Section 1.3,
       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 characters. All characters shall
           be taken literally from the input, and there is no way to specify a
           string containing 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 undefined if digits
           greater than or equal to the value of ibase appear in the token.
           However, note the exception 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 delimiter, 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 identifiers are followed by
       parentheses, possibly enclosing arguments. The three types of identifiers
       do not conflict.

       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 POSIX.1‐2008, 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 output, 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 10s.

       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 parentheses of the
       return statement or shall be zero if no expression is provided or if
       there is no return statement.

       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.

       expressionexpression
             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 expression on the left. The
             scale of both the named expression and the result shall be the
             scale of expression.

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

       expression1<=expression2
             The relation shall be true if the value of expression1 is less than
             or equal to the value of expression2.

       expression1>=expression2
             The relation shall be true if the value of expression1 is greater
             than or equal to the value of expression2.

       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 <semicolon> or <newline> characters 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-expression
           while (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
       specified by following the array name by empty square brackets. The
       application shall ensure that the auto statement 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 register 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; consider 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 'π' to the variable x:

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

       The following bc program prints the same approximation of 'π', 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 POSIX.1‐2008 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 preferred 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
       POSIX.1‐2008 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
       this standard. This left the following alternatives:

        1. Exclude any calculator language from this volume of POSIX.1‐2008.

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

        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
       historical 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 POSIX.1‐2008. They are
       built from lexical tokens of single hexadecimal digits and <period>
       characters. Since <blank> characters 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 POSIX.1‐2008, as it does not impact the behavior of
       conforming applications (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 leading <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 POSIX.1‐2008 requires implementations 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 function. New implementations are
       encouraged to remove this restriction even though it is not required by
       the grammar.

FUTURE DIRECTIONS
       None.

SEE ALSO
       Section 1.3, Grammar Conventions, awk

       The Base Definitions volume of POSIX.1‐2008, Chapter 8, Environment
       Variables, Section 12.2, Utility Syntax Guidelines

COPYRIGHT
       Portions of this text are reprinted and reproduced in electronic form
       from IEEE Std 1003.1, 2013 Edition, Standard for Information Technology
       -- Portable Operating System Interface (POSIX), The Open Group Base
       Specifications Issue 7, Copyright (C) 2013 by the Institute of Electrical
       and Electronics Engineers, Inc and The Open Group.  (This is POSIX.1-2008
       with the 2013 Technical Corrigendum 1 applied.) In the event of any
       discrepancy between this version and the original IEEE and The Open Group
       Standard, the original IEEE and The Open Group Standard is the referee
       document. The original Standard can be obtained online at
       http://www.unix.org/online.html .

       Any typographical or formatting errors that appear in this page are most
       likely to have been introduced during the conversion of the source files
       to man page format. To report such errors, see
       https://www.kernel.org/doc/man-pages/reporting_bugs.html .



IEEE/The Open Group                   2013                            BC(1POSIX)