3 SPDX-License-Identifier: BSD-2-Clause
5 Copyright (c) 2018-2021 Gavin D. Howard and contributors.
7 Redistribution and use in source and binary forms, with or without
8 modification, are permitted provided that the following conditions are met:
10 * Redistributions of source code must retain the above copyright notice, this
11 list of conditions and the following disclaimer.
13 * Redistributions in binary form must reproduce the above copyright notice,
14 this list of conditions and the following disclaimer in the documentation
15 and/or other materials provided with the distribution.
17 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
18 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
21 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
22 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
25 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
26 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
27 POSSIBILITY OF SUCH DAMAGE.
33 bc - arbitrary-precision decimal arithmetic language and calculator
37 **bc** [**-ghilPqsvVw**] [**--global-stacks**] [**--help**] [**--interactive**] [**--mathlib**] [**--no-prompt**] [**--quiet**] [**--standard**] [**--warn**] [**--version**] [**-e** *expr*] [**--expression**=*expr*...] [**-f** *file*...] [**-file**=*file*...]
42 bc(1) is an interactive processor for a language first standardized in 1991 by
43 POSIX. (The current standard is [here][1].) The language provides unlimited
44 precision decimal arithmetic and is somewhat C-like, but there are differences.
45 Such differences will be noted in this document.
47 After parsing and handling options, this bc(1) reads any files given on the
48 command line and executes them before reading from **stdin**.
52 The following are the options that bc(1) accepts.
54 **-g**, **--global-stacks**
56 : Turns the globals **ibase**, **obase**, **scale**, and **seed** into stacks.
58 This has the effect that a copy of the current value of all four are pushed
59 onto a stack for every function call, as well as popped when every function
60 returns. This means that functions can assign to any and all of those
61 globals without worrying that the change will affect other functions.
62 Thus, a hypothetical function named **output(x,b)** that simply printed
63 **x** in base **b** could be written like this:
65 define void output(x, b) {
72 define void output(x, b) {
80 This makes writing functions much easier.
82 (**Note**: the function **output(x,b)** exists in the extended math library.
83 See the **LIBRARY** section.)
85 However, since using this flag means that functions cannot set **ibase**,
86 **obase**, **scale**, or **seed** globally, functions that are made to do so
87 cannot work anymore. There are two possible use cases for that, and each has
90 First, if a function is called on startup to turn bc(1) into a number
91 converter, it is possible to replace that capability with various shell
94 alias d2o="bc -e ibase=A -e obase=8"
95 alias h2b="bc -e ibase=G -e obase=2"
97 Second, if the purpose of a function is to set **ibase**, **obase**,
98 **scale**, or **seed** globally for any other purpose, it could be split
99 into one to four functions (based on how many globals it sets) and each of
100 those functions could return the desired value for a global.
102 For functions that set **seed**, the value assigned to **seed** is not
103 propagated to parent functions. This means that the sequence of
104 pseudo-random numbers that they see will not be the same sequence of
105 pseudo-random numbers that any parent sees. This is only the case once
106 **seed** has been set.
108 If a function desires to not affect the sequence of pseudo-random numbers
109 of its parents, but wants to use the same **seed**, it can use the following
114 If the behavior of this option is desired for every run of bc(1), then users
115 could make sure to define **BC_ENV_ARGS** and include this option (see the
116 **ENVIRONMENT VARIABLES** section for more details).
118 If **-s**, **-w**, or any equivalents are used, this option is ignored.
120 This is a **non-portable extension**.
124 : Prints a usage message and quits.
126 **-i**, **--interactive**
128 : Forces interactive mode. (See the **INTERACTIVE MODE** section.)
130 This is a **non-portable extension**.
132 **-l**, **--mathlib**
134 : Sets **scale** (see the **SYNTAX** section) to **20** and loads the included
135 math library and the extended math library before running any code,
136 including any expressions or files specified on the command line.
138 To learn what is in the libraries, see the **LIBRARY** section.
140 **-P**, **--no-prompt**
142 : Disables the prompt in TTY mode. (The prompt is only enabled in TTY mode.
143 See the **TTY MODE** section) This is mostly for those users that do not
144 want a prompt or are not used to having them in bc(1). Most of those users
145 would want to put this option in **BC_ENV_ARGS** (see the
146 **ENVIRONMENT VARIABLES** section).
148 This is a **non-portable extension**.
152 : This option is for compatibility with the [GNU bc(1)][2]; it is a no-op.
153 Without this option, GNU bc(1) prints a copyright header. This bc(1) only
154 prints the copyright header if one or more of the **-v**, **-V**, or
155 **--version** options are given.
157 This is a **non-portable extension**.
159 **-s**, **--standard**
161 : Process exactly the language defined by the [standard][1] and error if any
164 This is a **non-portable extension**.
166 **-v**, **-V**, **--version**
168 : Print the version information (copyright header) and exit.
170 This is a **non-portable extension**.
174 : Like **-s** and **--standard**, except that warnings (and not errors) are
175 printed for non-standard extensions and execution continues normally.
177 This is a **non-portable extension**.
179 **-e** *expr*, **--expression**=*expr*
181 : Evaluates *expr*. If multiple expressions are given, they are evaluated in
182 order. If files are given as well (see below), the expressions and files are
183 evaluated in the order given. This means that if a file is given before an
184 expression, the file is read in and evaluated first.
186 If this option is given on the command-line (i.e., not in **BC_ENV_ARGS**,
187 see the **ENVIRONMENT VARIABLES** section), then after processing all
188 expressions and files, bc(1) will exit, unless **-** (**stdin**) was given
189 as an argument at least once to **-f** or **--file**, whether on the
190 command-line or in **BC_ENV_ARGS**. However, if any other **-e**,
191 **--expression**, **-f**, or **--file** arguments are given after **-f-** or
192 equivalent is given, bc(1) will give a fatal error and exit.
194 This is a **non-portable extension**.
196 **-f** *file*, **--file**=*file*
198 : Reads in *file* and evaluates it, line by line, as though it were read
199 through **stdin**. If expressions are also given (see above), the
200 expressions are evaluated in the order given.
202 If this option is given on the command-line (i.e., not in **BC_ENV_ARGS**,
203 see the **ENVIRONMENT VARIABLES** section), then after processing all
204 expressions and files, bc(1) will exit, unless **-** (**stdin**) was given
205 as an argument at least once to **-f** or **--file**. However, if any other
206 **-e**, **--expression**, **-f**, or **--file** arguments are given after
207 **-f-** or equivalent is given, bc(1) will give a fatal error and exit.
209 This is a **non-portable extension**.
211 All long options are **non-portable extensions**.
215 Any non-error output is written to **stdout**. In addition, if history (see the
216 **HISTORY** section) and the prompt (see the **TTY MODE** section) are enabled,
217 both are output to **stdout**.
219 **Note**: Unlike other bc(1) implementations, this bc(1) will issue a fatal
220 error (see the **EXIT STATUS** section) if it cannot write to **stdout**, so if
221 **stdout** is closed, as in **bc <file> >&-**, it will quit with an error. This
222 is done so that bc(1) can report problems when **stdout** is redirected to a
225 If there are scripts that depend on the behavior of other bc(1) implementations,
226 it is recommended that those scripts be changed to redirect **stdout** to
231 Any error output is written to **stderr**.
233 **Note**: Unlike other bc(1) implementations, this bc(1) will issue a fatal
234 error (see the **EXIT STATUS** section) if it cannot write to **stderr**, so if
235 **stderr** is closed, as in **bc <file> 2>&-**, it will quit with an error. This
236 is done so that bc(1) can exit with an error code when **stderr** is redirected
239 If there are scripts that depend on the behavior of other bc(1) implementations,
240 it is recommended that those scripts be changed to redirect **stderr** to
245 The syntax for bc(1) programs is mostly C-like, with some differences. This
246 bc(1) follows the [POSIX standard][1], which is a much more thorough resource
247 for the language this bc(1) accepts. This section is meant to be a summary and a
248 listing of all the extensions to the standard.
250 In the sections below, **E** means expression, **S** means statement, and **I**
253 Identifiers (**I**) start with a lowercase letter and can be followed by any
254 number (up to **BC_NAME_MAX-1**) of lowercase letters (**a-z**), digits
255 (**0-9**), and underscores (**\_**). The regex is **\[a-z\]\[a-z0-9\_\]\***.
256 Identifiers with more than one character (letter) are a
257 **non-portable extension**.
259 **ibase** is a global variable determining how to interpret constant numbers. It
260 is the "input" base, or the number base used for interpreting input numbers.
261 **ibase** is initially **10**. If the **-s** (**--standard**) and **-w**
262 (**--warn**) flags were not given on the command line, the max allowable value
263 for **ibase** is **36**. Otherwise, it is **16**. The min allowable value for
264 **ibase** is **2**. The max allowable value for **ibase** can be queried in
265 bc(1) programs with the **maxibase()** built-in function.
267 **obase** is a global variable determining how to output results. It is the
268 "output" base, or the number base used for outputting numbers. **obase** is
269 initially **10**. The max allowable value for **obase** is **BC_BASE_MAX** and
270 can be queried in bc(1) programs with the **maxobase()** built-in function. The
271 min allowable value for **obase** is **0**. If **obase** is **0**, values are
272 output in scientific notation, and if **obase** is **1**, values are output in
273 engineering notation. Otherwise, values are output in the specified base.
275 Outputting in scientific and engineering notations are **non-portable
278 The *scale* of an expression is the number of digits in the result of the
279 expression right of the decimal point, and **scale** is a global variable that
280 sets the precision of any operations, with exceptions. **scale** is initially
281 **0**. **scale** cannot be negative. The max allowable value for **scale** is
282 **BC_SCALE_MAX** and can be queried in bc(1) programs with the **maxscale()**
285 bc(1) has both *global* variables and *local* variables. All *local*
286 variables are local to the function; they are parameters or are introduced in
287 the **auto** list of a function (see the **FUNCTIONS** section). If a variable
288 is accessed which is not a parameter or in the **auto** list, it is assumed to
289 be *global*. If a parent function has a *local* variable version of a variable
290 that a child function considers *global*, the value of that *global* variable in
291 the child function is the value of the variable in the parent function, not the
292 value of the actual *global* variable.
294 All of the above applies to arrays as well.
296 The value of a statement that is an expression (i.e., any of the named
297 expressions or operands) is printed unless the lowest precedence operator is an
298 assignment operator *and* the expression is notsurrounded by parentheses.
300 The value that is printed is also assigned to the special variable **last**. A
301 single dot (**.**) may also be used as a synonym for **last**. These are
302 **non-portable extensions**.
304 Either semicolons or newlines may separate statements.
308 There are two kinds of comments:
310 1. Block comments are enclosed in **/\*** and **\*/**.
311 2. Line comments go from **#** until, and not including, the next newline. This
312 is a **non-portable extension**.
316 The following are named expressions in bc(1):
319 2. Array Elements: **I[E]**
324 7. **last** or a single dot (**.**)
326 Numbers 6 and 7 are **non-portable extensions**.
328 The meaning of **seed** is dependent on the current pseudo-random number
329 generator but is guaranteed to not change except for new major versions.
331 The *scale* and sign of the value may be significant.
333 If a previously used **seed** value is assigned to **seed** and used again, the
334 pseudo-random number generator is guaranteed to produce the same sequence of
335 pseudo-random numbers as it did when the **seed** value was previously used.
337 The exact value assigned to **seed** is not guaranteed to be returned if
338 **seed** is queried again immediately. However, if **seed** *does* return a
339 different value, both values, when assigned to **seed**, are guaranteed to
340 produce the same sequence of pseudo-random numbers. This means that certain
341 values assigned to **seed** will *not* produce unique sequences of pseudo-random
342 numbers. The value of **seed** will change after any use of the **rand()** and
343 **irand(E)** operands (see the *Operands* subsection below), except if the
344 parameter passed to **irand(E)** is **0**, **1**, or negative.
346 There is no limit to the length (number of significant decimal digits) or
347 *scale* of the value that can be assigned to **seed**.
349 Variables and arrays do not interfere; users can have arrays named the same as
350 variables. This also applies to functions (see the **FUNCTIONS** section), so a
351 user can have a variable, array, and function that all have the same name, and
352 they will not shadow each other, whether inside of functions or not.
354 Named expressions are required as the operand of **increment**/**decrement**
355 operators and as the left side of **assignment** operators (see the *Operators*
360 The following are valid operands in bc(1):
362 1. Numbers (see the *Numbers* subsection below).
363 2. Array indices (**I[E]**).
364 3. **(E)**: The value of **E** (used to change precedence).
365 4. **sqrt(E)**: The square root of **E**. **E** must be non-negative.
366 5. **length(E)**: The number of significant decimal digits in **E**.
367 6. **length(I[])**: The number of elements in the array **I**. This is a
368 **non-portable extension**.
369 7. **scale(E)**: The *scale* of **E**.
370 8. **abs(E)**: The absolute value of **E**. This is a **non-portable
372 9. **I()**, **I(E)**, **I(E, E)**, and so on, where **I** is an identifier for
373 a non-**void** function (see the *Void Functions* subsection of the
374 **FUNCTIONS** section). The **E** argument(s) may also be arrays of the form
375 **I[]**, which will automatically be turned into array references (see the
376 *Array References* subsection of the **FUNCTIONS** section) if the
377 corresponding parameter in the function definition is an array reference.
378 10. **read()**: Reads a line from **stdin** and uses that as an expression. The
379 result of that expression is the result of the **read()** operand. This is a
380 **non-portable extension**.
381 11. **maxibase()**: The max allowable **ibase**. This is a **non-portable
383 12. **maxobase()**: The max allowable **obase**. This is a **non-portable
385 13. **maxscale()**: The max allowable **scale**. This is a **non-portable
387 14. **rand()**: A pseudo-random integer between **0** (inclusive) and
388 **BC_RAND_MAX** (inclusive). Using this operand will change the value of
389 **seed**. This is a **non-portable extension**.
390 15. **irand(E)**: A pseudo-random integer between **0** (inclusive) and the
391 value of **E** (exclusive). If **E** is negative or is a non-integer
392 (**E**'s *scale* is not **0**), an error is raised, and bc(1) resets (see
393 the **RESET** section) while **seed** remains unchanged. If **E** is larger
394 than **BC_RAND_MAX**, the higher bound is honored by generating several
395 pseudo-random integers, multiplying them by appropriate powers of
396 **BC_RAND_MAX+1**, and adding them together. Thus, the size of integer that
397 can be generated with this operand is unbounded. Using this operand will
398 change the value of **seed**, unless the value of **E** is **0** or **1**.
399 In that case, **0** is returned, and **seed** is *not* changed. This is a
400 **non-portable extension**.
401 16. **maxrand()**: The max integer returned by **rand()**. This is a
402 **non-portable extension**.
404 The integers generated by **rand()** and **irand(E)** are guaranteed to be as
405 unbiased as possible, subject to the limitations of the pseudo-random number
408 **Note**: The values returned by the pseudo-random number generator with
409 **rand()** and **irand(E)** are guaranteed to *NOT* be cryptographically secure.
410 This is a consequence of using a seeded pseudo-random number generator. However,
411 they *are* guaranteed to be reproducible with identical **seed** values. This
412 means that the pseudo-random values from bc(1) should only be used where a
413 reproducible stream of pseudo-random numbers is *ESSENTIAL*. In any other case,
414 use a non-seeded pseudo-random number generator.
418 Numbers are strings made up of digits, uppercase letters, and at most **1**
419 period for a radix. Numbers can have up to **BC_NUM_MAX** digits. Uppercase
420 letters are equal to **9** + their position in the alphabet (i.e., **A** equals
421 **10**, or **9+1**). If a digit or letter makes no sense with the current value
422 of **ibase**, they are set to the value of the highest valid digit in **ibase**.
424 Single-character numbers (i.e., **A** alone) take the value that they would have
425 if they were valid digits, regardless of the value of **ibase**. This means that
426 **A** alone always equals decimal **10** and **Z** alone always equals decimal
429 In addition, bc(1) accepts numbers in scientific notation. These have the form
430 **\<number\>e\<integer\>**. The exponent (the portion after the **e**) must be
431 an integer. An example is **1.89237e9**, which is equal to **1892370000**.
432 Negative exponents are also allowed, so **4.2890e-3** is equal to **0.0042890**.
434 Using scientific notation is an error or warning if the **-s** or **-w**,
435 respectively, command-line options (or equivalents) are given.
437 **WARNING**: Both the number and the exponent in scientific notation are
438 interpreted according to the current **ibase**, but the number is still
439 multiplied by **10\^exponent** regardless of the current **ibase**. For example,
440 if **ibase** is **16** and bc(1) is given the number string **FFeA**, the
441 resulting decimal number will be **2550000000000**, and if bc(1) is given the
442 number string **10e-4**, the resulting decimal number will be **0.0016**.
444 Accepting input as scientific notation is a **non-portable extension**.
448 The following arithmetic and logical operators can be used. They are listed in
449 order of decreasing precedence. Operators in the same group have the same
454 : Type: Prefix and Postfix
458 Description: **increment**, **decrement**
466 Description: **negation**, **boolean not**
474 Description: **truncation**
482 Description: **set precision**
490 Description: **power**
498 Description: **multiply**, **divide**, **modulus**
506 Description: **add**, **subtract**
514 Description: **shift left**, **shift right**
516 **=** **\<\<=** **\>\>=** **+=** **-=** **\*=** **/=** **%=** **\^=** **\@=**
522 Description: **assignment**
524 **==** **\<=** **\>=** **!=** **\<** **\>**
530 Description: **relational**
538 Description: **boolean and**
546 Description: **boolean or**
548 The operators will be described in more detail below.
552 : The prefix and postfix **increment** and **decrement** operators behave
553 exactly like they would in C. They require a named expression (see the
554 *Named Expressions* subsection) as an operand.
556 The prefix versions of these operators are more efficient; use them where
561 : The **negation** operator returns **0** if a user attempts to negate any
562 expression with the value **0**. Otherwise, a copy of the expression with
563 its sign flipped is returned.
567 : The **boolean not** operator returns **1** if the expression is **0**, or
570 This is a **non-portable extension**.
574 : The **truncation** operator returns a copy of the given expression with all
575 of its *scale* removed.
577 This is a **non-portable extension**.
581 : The **set precision** operator takes two expressions and returns a copy of
582 the first with its *scale* equal to the value of the second expression. That
583 could either mean that the number is returned without change (if the
584 *scale* of the first expression matches the value of the second
585 expression), extended (if it is less), or truncated (if it is more).
587 The second expression must be an integer (no *scale*) and non-negative.
589 This is a **non-portable extension**.
593 : The **power** operator (not the **exclusive or** operator, as it would be in
594 C) takes two expressions and raises the first to the power of the value of
595 the second. The *scale* of the result is equal to **scale**.
597 The second expression must be an integer (no *scale*), and if it is
598 negative, the first value must be non-zero.
602 : The **multiply** operator takes two expressions, multiplies them, and
603 returns the product. If **a** is the *scale* of the first expression and
604 **b** is the *scale* of the second expression, the *scale* of the result is
605 equal to **min(a+b,max(scale,a,b))** where **min()** and **max()** return
610 : The **divide** operator takes two expressions, divides them, and returns the
611 quotient. The *scale* of the result shall be the value of **scale**.
613 The second expression must be non-zero.
617 : The **modulus** operator takes two expressions, **a** and **b**, and
618 evaluates them by 1) Computing **a/b** to current **scale** and 2) Using the
619 result of step 1 to calculate **a-(a/b)\*b** to *scale*
620 **max(scale+scale(b),scale(a))**.
622 The second expression must be non-zero.
626 : The **add** operator takes two expressions, **a** and **b**, and returns the
627 sum, with a *scale* equal to the max of the *scale*s of **a** and **b**.
631 : The **subtract** operator takes two expressions, **a** and **b**, and
632 returns the difference, with a *scale* equal to the max of the *scale*s of
637 : The **left shift** operator takes two expressions, **a** and **b**, and
638 returns a copy of the value of **a** with its decimal point moved **b**
641 The second expression must be an integer (no *scale*) and non-negative.
643 This is a **non-portable extension**.
647 : The **right shift** operator takes two expressions, **a** and **b**, and
648 returns a copy of the value of **a** with its decimal point moved **b**
651 The second expression must be an integer (no *scale*) and non-negative.
653 This is a **non-portable extension**.
655 **=** **\<\<=** **\>\>=** **+=** **-=** **\*=** **/=** **%=** **\^=** **\@=**
657 : The **assignment** operators take two expressions, **a** and **b** where
658 **a** is a named expression (see the *Named Expressions* subsection).
660 For **=**, **b** is copied and the result is assigned to **a**. For all
661 others, **a** and **b** are applied as operands to the corresponding
662 arithmetic operator and the result is assigned to **a**.
664 The **assignment** operators that correspond to operators that are
665 extensions are themselves **non-portable extensions**.
667 **==** **\<=** **\>=** **!=** **\<** **\>**
669 : The **relational** operators compare two expressions, **a** and **b**, and
670 if the relation holds, according to C language semantics, the result is
671 **1**. Otherwise, it is **0**.
673 Note that unlike in C, these operators have a lower precedence than the
674 **assignment** operators, which means that **a=b\>c** is interpreted as
677 Also, unlike the [standard][1] requires, these operators can appear anywhere
678 any other expressions can be used. This allowance is a
679 **non-portable extension**.
683 : The **boolean and** operator takes two expressions and returns **1** if both
684 expressions are non-zero, **0** otherwise.
686 This is *not* a short-circuit operator.
688 This is a **non-portable extension**.
692 : The **boolean or** operator takes two expressions and returns **1** if one
693 of the expressions is non-zero, **0** otherwise.
695 This is *not* a short-circuit operator.
697 This is a **non-portable extension**.
701 The following items are statements:
704 2. **{** **S** **;** ... **;** **S** **}**
705 3. **if** **(** **E** **)** **S**
706 4. **if** **(** **E** **)** **S** **else** **S**
707 5. **while** **(** **E** **)** **S**
708 6. **for** **(** **E** **;** **E** **;** **E** **)** **S**
709 7. An empty statement
715 13. A string of characters, enclosed in double quotes
716 14. **print** **E** **,** ... **,** **E**
717 15. **I()**, **I(E)**, **I(E, E)**, and so on, where **I** is an identifier for
718 a **void** function (see the *Void Functions* subsection of the
719 **FUNCTIONS** section). The **E** argument(s) may also be arrays of the form
720 **I[]**, which will automatically be turned into array references (see the
721 *Array References* subsection of the **FUNCTIONS** section) if the
722 corresponding parameter in the function definition is an array reference.
724 Numbers 4, 9, 11, 12, 14, and 15 are **non-portable extensions**.
726 Also, as a **non-portable extension**, any or all of the expressions in the
727 header of a for loop may be omitted. If the condition (second expression) is
728 omitted, it is assumed to be a constant **1**.
730 The **break** statement causes a loop to stop iterating and resume execution
731 immediately following a loop. This is only allowed in loops.
733 The **continue** statement causes a loop iteration to stop early and returns to
734 the start of the loop, including testing the loop condition. This is only
737 The **if** **else** statement does the same thing as in C.
739 The **quit** statement causes bc(1) to quit, even if it is on a branch that will
740 not be executed (it is a compile-time command).
742 The **halt** statement causes bc(1) to quit, if it is executed. (Unlike **quit**
743 if it is on a branch of an **if** statement that is not executed, bc(1) does not
746 The **limits** statement prints the limits that this bc(1) is subject to. This
747 is like the **quit** statement in that it is a compile-time command.
749 An expression by itself is evaluated and printed, followed by a newline.
751 Both scientific notation and engineering notation are available for printing the
752 results of expressions. Scientific notation is activated by assigning **0** to
753 **obase**, and engineering notation is activated by assigning **1** to
754 **obase**. To deactivate them, just assign a different value to **obase**.
756 Scientific notation and engineering notation are disabled if bc(1) is run with
757 either the **-s** or **-w** command-line options (or equivalents).
759 Printing numbers in scientific notation and/or engineering notation is a
760 **non-portable extension**.
764 The "expressions" in a **print** statement may also be strings. If they are, there
765 are backslash escape sequences that are interpreted specially. What those
766 sequences are, and what they cause to be printed, are shown below:
780 Any other character following a backslash causes the backslash and character to
783 Any non-string expression in a print statement shall be assigned to **last**,
784 like any other expression that is printed.
786 ## Order of Evaluation
788 All expressions in a statment are evaluated left to right, except as necessary
789 to maintain order of operations. This means, for example, assuming that **i** is
790 equal to **0**, in the expression
794 the first (or 0th) element of **a** is set to **1**, and **i** is equal to **2**
795 at the end of the expression.
797 This includes function arguments. Thus, assuming **i** is equal to **0**, this
798 means that in the expression
802 the first argument passed to **x()** is **0**, and the second argument is **1**,
803 while **i** is equal to **2** before the function starts executing.
807 Function definitions are as follows:
817 Any **I** in the parameter list or **auto** list may be replaced with **I[]** to
818 make a parameter or **auto** var an array, and any **I** in the parameter list
819 may be replaced with **\*I[]** to make a parameter an array reference. Callers
820 of functions that take array references should not put an asterisk in the call;
821 they must be called with just **I[]** like normal array parameters and will be
822 automatically converted into references.
824 As a **non-portable extension**, the opening brace of a **define** statement may
825 appear on the next line.
827 As a **non-portable extension**, the return statement may also be in one of the
831 2. **return** **(** **)**
834 The first two, or not specifying a **return** statement, is equivalent to
835 **return (0)**, unless the function is a **void** function (see the *Void
836 Functions* subsection below).
840 Functions can also be **void** functions, defined as follows:
843 define void I(I,...,I){
850 They can only be used as standalone expressions, where such an expression would
851 be printed alone, except in a print statement.
853 Void functions can only use the first two **return** statements listed above.
854 They can also omit the return statement entirely.
856 The word "void" is not treated as a keyword; it is still possible to have
857 variables, arrays, and functions named **void**. The word "void" is only
858 treated specially right after the **define** keyword.
860 This is a **non-portable extension**.
864 For any array in the parameter list, if the array is declared in the form
870 it is a **reference**. Any changes to the array in the function are reflected,
871 when the function returns, to the array that was passed in.
873 Other than this, all function arguments are passed by value.
875 This is a **non-portable extension**.
879 All of the functions below, including the functions in the extended math
880 library (see the *Extended Library* subsection below), are available when the
881 **-l** or **--mathlib** command-line flags are given, except that the extended
882 math library is not available when the **-s** option, the **-w** option, or
883 equivalents are given.
887 The [standard][1] defines the following functions for the math library:
891 : Returns the sine of **x**, which is assumed to be in radians.
893 This is a transcendental function (see the *Transcendental Functions*
898 : Returns the cosine of **x**, which is assumed to be in radians.
900 This is a transcendental function (see the *Transcendental Functions*
905 : Returns the arctangent of **x**, in radians.
907 This is a transcendental function (see the *Transcendental Functions*
912 : Returns the natural logarithm of **x**.
914 This is a transcendental function (see the *Transcendental Functions*
919 : Returns the mathematical constant **e** raised to the power of **x**.
921 This is a transcendental function (see the *Transcendental Functions*
926 : Returns the bessel integer order **n** (truncated) of **x**.
928 This is a transcendental function (see the *Transcendental Functions*
933 The extended library is *not* loaded when the **-s**/**--standard** or
934 **-w**/**--warn** options are given since they are not part of the library
935 defined by the [standard][1].
937 The extended library is a **non-portable extension**.
941 : Calculates **x** to the power of **y**, even if **y** is not an integer, and
942 returns the result to the current **scale**.
944 It is an error if **y** is negative and **x** is **0**.
946 This is a transcendental function (see the *Transcendental Functions*
951 : Returns **x** rounded to **p** decimal places according to the rounding mode
952 [round half away from **0**][3].
956 : Returns **x** rounded to **p** decimal places according to the rounding mode
957 [round away from **0**][6].
961 : Returns the factorial of the truncated absolute value of **x**.
965 : Returns the permutation of the truncated absolute value of **n** of the
966 truncated absolute value of **k**, if **k \<= n**. If not, it returns **0**.
970 : Returns the combination of the truncated absolute value of **n** of the
971 truncated absolute value of **k**, if **k \<= n**. If not, it returns **0**.
975 : Returns the logarithm base **2** of **x**.
977 This is a transcendental function (see the *Transcendental Functions*
982 : Returns the logarithm base **10** of **x**.
984 This is a transcendental function (see the *Transcendental Functions*
989 : Returns the logarithm base **b** of **x**.
991 This is a transcendental function (see the *Transcendental Functions*
996 : Returns the cube root of **x**.
1000 : Calculates the truncated value of **n**, **r**, and returns the **r**th root
1001 of **x** to the current **scale**.
1003 If **r** is **0** or negative, this raises an error and causes bc(1) to
1004 reset (see the **RESET** section). It also raises an error and causes bc(1)
1005 to reset if **r** is even and **x** is negative.
1009 : Returns **pi** to **p** decimal places.
1011 This is a transcendental function (see the *Transcendental Functions*
1016 : Returns the tangent of **x**, which is assumed to be in radians.
1018 This is a transcendental function (see the *Transcendental Functions*
1023 : Returns the arctangent of **y/x**, in radians. If both **y** and **x** are
1024 equal to **0**, it raises an error and causes bc(1) to reset (see the
1025 **RESET** section). Otherwise, if **x** is greater than **0**, it returns
1026 **a(y/x)**. If **x** is less than **0**, and **y** is greater than or equal
1027 to **0**, it returns **a(y/x)+pi**. If **x** is less than **0**, and **y**
1028 is less than **0**, it returns **a(y/x)-pi**. If **x** is equal to **0**,
1029 and **y** is greater than **0**, it returns **pi/2**. If **x** is equal to
1030 **0**, and **y** is less than **0**, it returns **-pi/2**.
1032 This function is the same as the **atan2()** function in many programming
1035 This is a transcendental function (see the *Transcendental Functions*
1040 : Returns the sine of **x**, which is assumed to be in radians.
1042 This is an alias of **s(x)**.
1044 This is a transcendental function (see the *Transcendental Functions*
1049 : Returns the cosine of **x**, which is assumed to be in radians.
1051 This is an alias of **c(x)**.
1053 This is a transcendental function (see the *Transcendental Functions*
1058 : Returns the tangent of **x**, which is assumed to be in radians.
1060 If **x** is equal to **1** or **-1**, this raises an error and causes bc(1)
1061 to reset (see the **RESET** section).
1063 This is an alias of **t(x)**.
1065 This is a transcendental function (see the *Transcendental Functions*
1070 : Returns the arctangent of **x**, in radians.
1072 This is an alias of **a(x)**.
1074 This is a transcendental function (see the *Transcendental Functions*
1079 : Returns the arctangent of **y/x**, in radians. If both **y** and **x** are
1080 equal to **0**, it raises an error and causes bc(1) to reset (see the
1081 **RESET** section). Otherwise, if **x** is greater than **0**, it returns
1082 **a(y/x)**. If **x** is less than **0**, and **y** is greater than or equal
1083 to **0**, it returns **a(y/x)+pi**. If **x** is less than **0**, and **y**
1084 is less than **0**, it returns **a(y/x)-pi**. If **x** is equal to **0**,
1085 and **y** is greater than **0**, it returns **pi/2**. If **x** is equal to
1086 **0**, and **y** is less than **0**, it returns **-pi/2**.
1088 This function is the same as the **atan2()** function in many programming
1091 This is an alias of **a2(y, x)**.
1093 This is a transcendental function (see the *Transcendental Functions*
1098 : Converts **x** from radians to degrees and returns the result.
1100 This is a transcendental function (see the *Transcendental Functions*
1105 : Converts **x** from degrees to radians and returns the result.
1107 This is a transcendental function (see the *Transcendental Functions*
1112 : Generates a pseudo-random number between **0** (inclusive) and **1**
1113 (exclusive) with the number of decimal digits after the decimal point equal
1114 to the truncated absolute value of **p**. If **p** is not **0**, then
1115 calling this function will change the value of **seed**. If **p** is **0**,
1116 then **0** is returned, and **seed** is *not* changed.
1120 : Generates a pseudo-random number that is between **0** (inclusive) and the
1121 truncated absolute value of **i** (exclusive) with the number of decimal
1122 digits after the decimal point equal to the truncated absolute value of
1123 **p**. If the absolute value of **i** is greater than or equal to **2**, and
1124 **p** is not **0**, then calling this function will change the value of
1125 **seed**; otherwise, **0** is returned and **seed** is not changed.
1129 : Returns **x** with its sign flipped with probability **0.5**. In other
1130 words, it randomizes the sign of **x**.
1134 : Returns a random boolean value (either **0** or **1**).
1138 : Returns the numbers of unsigned integer bytes required to hold the truncated
1139 absolute value of **x**.
1143 : Returns the numbers of signed, two's-complement integer bytes required to
1144 hold the truncated value of **x**.
1148 : Outputs the hexadecimal (base **16**) representation of **x**.
1150 This is a **void** function (see the *Void Functions* subsection of the
1151 **FUNCTIONS** section).
1155 : Outputs the binary (base **2**) representation of **x**.
1157 This is a **void** function (see the *Void Functions* subsection of the
1158 **FUNCTIONS** section).
1162 : Outputs the base **b** representation of **x**.
1164 This is a **void** function (see the *Void Functions* subsection of the
1165 **FUNCTIONS** section).
1169 : Outputs the representation, in binary and hexadecimal, of **x** as an
1170 unsigned integer in as few power of two bytes as possible. Both outputs are
1171 split into bytes separated by spaces.
1173 If **x** is not an integer or is negative, an error message is printed
1174 instead, but bc(1) is not reset (see the **RESET** section).
1176 This is a **void** function (see the *Void Functions* subsection of the
1177 **FUNCTIONS** section).
1181 : Outputs the representation, in binary and hexadecimal, of **x** as a signed,
1182 two's-complement integer in as few power of two bytes as possible. Both
1183 outputs are split into bytes separated by spaces.
1185 If **x** is not an integer, an error message is printed instead, but bc(1)
1186 is not reset (see the **RESET** section).
1188 This is a **void** function (see the *Void Functions* subsection of the
1189 **FUNCTIONS** section).
1193 : Outputs the representation, in binary and hexadecimal, of **x** as an
1194 unsigned integer in **n** bytes. Both outputs are split into bytes separated
1197 If **x** is not an integer, is negative, or cannot fit into **n** bytes, an
1198 error message is printed instead, but bc(1) is not reset (see the **RESET**
1201 This is a **void** function (see the *Void Functions* subsection of the
1202 **FUNCTIONS** section).
1206 : Outputs the representation, in binary and hexadecimal, of **x** as a signed,
1207 two's-complement integer in **n** bytes. Both outputs are split into bytes
1208 separated by spaces.
1210 If **x** is not an integer or cannot fit into **n** bytes, an error message
1211 is printed instead, but bc(1) is not reset (see the **RESET** section).
1213 This is a **void** function (see the *Void Functions* subsection of the
1214 **FUNCTIONS** section).
1218 : Outputs the representation, in binary and hexadecimal, of **x** as an
1219 unsigned integer in **1** byte. Both outputs are split into bytes separated
1222 If **x** is not an integer, is negative, or cannot fit into **1** byte, an
1223 error message is printed instead, but bc(1) is not reset (see the **RESET**
1226 This is a **void** function (see the *Void Functions* subsection of the
1227 **FUNCTIONS** section).
1231 : Outputs the representation, in binary and hexadecimal, of **x** as a signed,
1232 two's-complement integer in **1** byte. Both outputs are split into bytes
1233 separated by spaces.
1235 If **x** is not an integer or cannot fit into **1** byte, an error message
1236 is printed instead, but bc(1) is not reset (see the **RESET** section).
1238 This is a **void** function (see the *Void Functions* subsection of the
1239 **FUNCTIONS** section).
1243 : Outputs the representation, in binary and hexadecimal, of **x** as an
1244 unsigned integer in **2** bytes. Both outputs are split into bytes separated
1247 If **x** is not an integer, is negative, or cannot fit into **2** bytes, an
1248 error message is printed instead, but bc(1) is not reset (see the **RESET**
1251 This is a **void** function (see the *Void Functions* subsection of the
1252 **FUNCTIONS** section).
1256 : Outputs the representation, in binary and hexadecimal, of **x** as a signed,
1257 two's-complement integer in **2** bytes. Both outputs are split into bytes
1258 separated by spaces.
1260 If **x** is not an integer or cannot fit into **2** bytes, an error message
1261 is printed instead, but bc(1) is not reset (see the **RESET** section).
1263 This is a **void** function (see the *Void Functions* subsection of the
1264 **FUNCTIONS** section).
1268 : Outputs the representation, in binary and hexadecimal, of **x** as an
1269 unsigned integer in **4** bytes. Both outputs are split into bytes separated
1272 If **x** is not an integer, is negative, or cannot fit into **4** bytes, an
1273 error message is printed instead, but bc(1) is not reset (see the **RESET**
1276 This is a **void** function (see the *Void Functions* subsection of the
1277 **FUNCTIONS** section).
1281 : Outputs the representation, in binary and hexadecimal, of **x** as a signed,
1282 two's-complement integer in **4** bytes. Both outputs are split into bytes
1283 separated by spaces.
1285 If **x** is not an integer or cannot fit into **4** bytes, an error message
1286 is printed instead, but bc(1) is not reset (see the **RESET** section).
1288 This is a **void** function (see the *Void Functions* subsection of the
1289 **FUNCTIONS** section).
1293 : Outputs the representation, in binary and hexadecimal, of **x** as an
1294 unsigned integer in **8** bytes. Both outputs are split into bytes separated
1297 If **x** is not an integer, is negative, or cannot fit into **8** bytes, an
1298 error message is printed instead, but bc(1) is not reset (see the **RESET**
1301 This is a **void** function (see the *Void Functions* subsection of the
1302 **FUNCTIONS** section).
1306 : Outputs the representation, in binary and hexadecimal, of **x** as a signed,
1307 two's-complement integer in **8** bytes. Both outputs are split into bytes
1308 separated by spaces.
1310 If **x** is not an integer or cannot fit into **8** bytes, an error message
1311 is printed instead, but bc(1) is not reset (see the **RESET** section).
1313 This is a **void** function (see the *Void Functions* subsection of the
1314 **FUNCTIONS** section).
1318 : Outputs the representation of the truncated absolute value of **x** as an
1319 unsigned integer in hexadecimal using **n** bytes. Not all of the value will
1320 be output if **n** is too small.
1322 This is a **void** function (see the *Void Functions* subsection of the
1323 **FUNCTIONS** section).
1325 **binary_uint(x, n)**
1327 : Outputs the representation of the truncated absolute value of **x** as an
1328 unsigned integer in binary using **n** bytes. Not all of the value will be
1329 output if **n** is too small.
1331 This is a **void** function (see the *Void Functions* subsection of the
1332 **FUNCTIONS** section).
1334 **output_uint(x, n)**
1336 : Outputs the representation of the truncated absolute value of **x** as an
1337 unsigned integer in the current **obase** (see the **SYNTAX** section) using
1338 **n** bytes. Not all of the value will be output if **n** is too small.
1340 This is a **void** function (see the *Void Functions* subsection of the
1341 **FUNCTIONS** section).
1343 **output_byte(x, i)**
1345 : Outputs byte **i** of the truncated absolute value of **x**, where **0** is
1346 the least significant byte and **number_of_bytes - 1** is the most
1349 This is a **void** function (see the *Void Functions* subsection of the
1350 **FUNCTIONS** section).
1352 ## Transcendental Functions
1354 All transcendental functions can return slightly inaccurate results (up to 1
1355 [ULP][4]). This is unavoidable, and [this article][5] explains why it is
1356 impossible and unnecessary to calculate exact results for the transcendental
1359 Because of the possible inaccuracy, I recommend that users call those functions
1360 with the precision (**scale**) set to at least 1 higher than is necessary. If
1361 exact results are *absolutely* required, users can double the precision
1362 (**scale**) and then truncate.
1364 The transcendental functions in the standard math library are:
1373 The transcendental functions in the extended math library are:
1391 When bc(1) encounters an error or a signal that it has a non-default handler
1392 for, it resets. This means that several things happen.
1394 First, any functions that are executing are stopped and popped off the stack.
1395 The behavior is not unlike that of exceptions in programming languages. Then
1396 the execution point is set so that any code waiting to execute (after all
1397 functions returned) is skipped.
1399 Thus, when bc(1) resets, it skips any remaining code waiting to be executed.
1400 Then, if it is interactive mode, and the error was not a fatal error (see the
1401 **EXIT STATUS** section), it asks for more input; otherwise, it exits with the
1402 appropriate return code.
1404 Note that this reset behavior is different from the GNU bc(1), which attempts to
1405 start executing the statement right after the one that caused an error.
1409 Most bc(1) implementations use **char** types to calculate the value of **1**
1410 decimal digit at a time, but that can be slow. This bc(1) does something
1413 It uses large integers to calculate more than **1** decimal digit at a time. If
1414 built in a environment where **BC_LONG_BIT** (see the **LIMITS** section) is
1415 **64**, then each integer has **9** decimal digits. If built in an environment
1416 where **BC_LONG_BIT** is **32** then each integer has **4** decimal digits. This
1417 value (the number of decimal digits per large integer) is called
1420 The actual values of **BC_LONG_BIT** and **BC_BASE_DIGS** can be queried with
1421 the **limits** statement.
1423 In addition, this bc(1) uses an even larger integer for overflow checking. This
1424 integer type depends on the value of **BC_LONG_BIT**, but is always at least
1425 twice as large as the integer type used to store digits.
1429 The following are the limits on bc(1):
1433 : The number of bits in the **long** type in the environment where bc(1) was
1434 built. This determines how many decimal digits can be stored in a single
1435 large integer (see the **PERFORMANCE** section).
1439 : The number of decimal digits per large integer (see the **PERFORMANCE**
1440 section). Depends on **BC_LONG_BIT**.
1444 : The max decimal number that each large integer can store (see
1445 **BC_BASE_DIGS**) plus **1**. Depends on **BC_BASE_DIGS**.
1449 : The max number that the overflow type (see the **PERFORMANCE** section) can
1450 hold. Depends on **BC_LONG_BIT**.
1454 : The maximum output base. Set at **BC_BASE_POW**.
1458 : The maximum size of arrays. Set at **SIZE_MAX-1**.
1462 : The maximum **scale**. Set at **BC_OVERFLOW_MAX-1**.
1466 : The maximum length of strings. Set at **BC_OVERFLOW_MAX-1**.
1470 : The maximum length of identifiers. Set at **BC_OVERFLOW_MAX-1**.
1474 : The maximum length of a number (in decimal digits), which includes digits
1475 after the decimal point. Set at **BC_OVERFLOW_MAX-1**.
1479 : The maximum integer (inclusive) returned by the **rand()** operand. Set at
1480 **2\^BC_LONG_BIT-1**.
1484 : The maximum allowable exponent (positive or negative). Set at
1485 **BC_OVERFLOW_MAX**.
1489 : The maximum number of vars/arrays. Set at **SIZE_MAX-1**.
1491 The actual values can be queried with the **limits** statement.
1493 These limits are meant to be effectively non-existent; the limits are so large
1494 (at least on 64-bit machines) that there should not be any point at which they
1495 become a problem. In fact, memory should be exhausted before these limits should
1498 # ENVIRONMENT VARIABLES
1500 bc(1) recognizes the following environment variables:
1504 : If this variable exists (no matter the contents), bc(1) behaves as if
1505 the **-s** option was given.
1509 : This is another way to give command-line arguments to bc(1). They should be
1510 in the same format as all other command-line arguments. These are always
1511 processed first, so any files given in **BC_ENV_ARGS** will be processed
1512 before arguments and files given on the command-line. This gives the user
1513 the ability to set up "standard" options and files to be used at every
1514 invocation. The most useful thing for such files to contain would be useful
1515 functions that the user might want every time bc(1) runs.
1517 The code that parses **BC_ENV_ARGS** will correctly handle quoted arguments,
1518 but it does not understand escape sequences. For example, the string
1519 **"/home/gavin/some bc file.bc"** will be correctly parsed, but the string
1520 **"/home/gavin/some \"bc\" file.bc"** will include the backslashes.
1522 The quote parsing will handle either kind of quotes, **'** or **"**. Thus,
1523 if you have a file with any number of single quotes in the name, you can use
1524 double quotes as the outside quotes, as in **"some 'bc' file.bc"**, and vice
1525 versa if you have a file with double quotes. However, handling a file with
1526 both kinds of quotes in **BC_ENV_ARGS** is not supported due to the
1527 complexity of the parsing, though such files are still supported on the
1528 command-line where the parsing is done by the shell.
1532 : If this environment variable exists and contains an integer that is greater
1533 than **1** and is less than **UINT16_MAX** (**2\^16-1**), bc(1) will output
1534 lines to that length, including the backslash (**\\**). The default line
1539 bc(1) returns the following exit statuses:
1547 : A math error occurred. This follows standard practice of using **1** for
1548 expected errors, since math errors will happen in the process of normal
1551 Math errors include divide by **0**, taking the square root of a negative
1552 number, using a negative number as a bound for the pseudo-random number
1553 generator, attempting to convert a negative number to a hardware integer,
1554 overflow when converting a number to a hardware integer, and attempting to
1555 use a non-integer where an integer is required.
1557 Converting to a hardware integer happens for the second operand of the power
1558 (**\^**), places (**\@**), left shift (**\<\<**), and right shift (**\>\>**)
1559 operators and their corresponding assignment operators.
1563 : A parse error occurred.
1565 Parse errors include unexpected **EOF**, using an invalid character, failing
1566 to find the end of a string or comment, using a token where it is invalid,
1567 giving an invalid expression, giving an invalid print statement, giving an
1568 invalid function definition, attempting to assign to an expression that is
1569 not a named expression (see the *Named Expressions* subsection of the
1570 **SYNTAX** section), giving an invalid **auto** list, having a duplicate
1571 **auto**/function parameter, failing to find the end of a code block,
1572 attempting to return a value from a **void** function, attempting to use a
1573 variable as a reference, and using any extensions when the option **-s** or
1574 any equivalents were given.
1578 : A runtime error occurred.
1580 Runtime errors include assigning an invalid number to **ibase**, **obase**,
1581 or **scale**; give a bad expression to a **read()** call, calling **read()**
1582 inside of a **read()** call, type errors, passing the wrong number of
1583 arguments to functions, attempting to call an undefined function, and
1584 attempting to use a **void** function call as a value in an expression.
1588 : A fatal error occurred.
1590 Fatal errors include memory allocation errors, I/O errors, failing to open
1591 files, attempting to use files that do not have only ASCII characters (bc(1)
1592 only accepts ASCII characters), attempting to open a directory as a file,
1593 and giving invalid command-line options.
1595 The exit status **4** is special; when a fatal error occurs, bc(1) always exits
1596 and returns **4**, no matter what mode bc(1) is in.
1598 The other statuses will only be returned when bc(1) is not in interactive mode
1599 (see the **INTERACTIVE MODE** section), since bc(1) resets its state (see the
1600 **RESET** section) and accepts more input when one of those errors occurs in
1601 interactive mode. This is also the case when interactive mode is forced by the
1602 **-i** flag or **--interactive** option.
1604 These exit statuses allow bc(1) to be used in shell scripting with error
1605 checking, and its normal behavior can be forced by using the **-i** flag or
1606 **--interactive** option.
1610 Per the [standard][1], bc(1) has an interactive mode and a non-interactive mode.
1611 Interactive mode is turned on automatically when both **stdin** and **stdout**
1612 are hooked to a terminal, but the **-i** flag and **--interactive** option can
1613 turn it on in other cases.
1615 In interactive mode, bc(1) attempts to recover from errors (see the **RESET**
1616 section), and in normal execution, flushes **stdout** as soon as execution is
1617 done for the current input.
1621 If **stdin**, **stdout**, and **stderr** are all connected to a TTY, bc(1) turns
1624 The prompt is enabled in TTY mode.
1626 TTY mode is different from interactive mode because interactive mode is required
1627 in the [bc(1) specification][1], and interactive mode requires only **stdin**
1628 and **stdout** to be connected to a terminal.
1632 Sending a **SIGINT** will cause bc(1) to stop execution of the current input. If
1633 bc(1) is in TTY mode (see the **TTY MODE** section), it will reset (see the
1634 **RESET** section). Otherwise, it will clean up and exit.
1636 Note that "current input" can mean one of two things. If bc(1) is processing
1637 input from **stdin** in TTY mode, it will ask for more input. If bc(1) is
1638 processing input from a file in TTY mode, it will stop processing the file and
1639 start processing the next file, if one exists, or ask for input from **stdin**
1640 if no other file exists.
1642 This means that if a **SIGINT** is sent to bc(1) as it is executing a file, it
1643 can seem as though bc(1) did not respond to the signal since it will immediately
1644 start executing the next file. This is by design; most files that users execute
1645 when interacting with bc(1) have function definitions, which are quick to parse.
1646 If a file takes a long time to execute, there may be a bug in that file. The
1647 rest of the files could still be executed without problem, allowing the user to
1650 **SIGTERM** and **SIGQUIT** cause bc(1) to clean up and exit, and it uses the
1651 default handler for all other signals.
1655 This bc(1) ships with support for adding error messages for different locales
1656 and thus, supports **LC_MESSAGES**.
1664 bc(1) is compliant with the [IEEE Std 1003.1-2017 (“POSIX.1-2017”)][1]
1665 specification. The flags **-efghiqsvVw**, all long options, and the extensions
1666 noted above are extensions to that specification.
1668 Note that the specification explicitly says that bc(1) only accepts numbers that
1669 use a period (**.**) as a radix point, regardless of the value of
1672 This bc(1) supports error messages for different locales, and thus, it supports
1677 None are known. Report bugs at https://git.yzena.com/gavin/bc.
1681 Gavin D. Howard <gavin@yzena.com> and contributors.
1683 [1]: https://pubs.opengroup.org/onlinepubs/9699919799/utilities/bc.html
1684 [2]: https://www.gnu.org/software/bc/
1685 [3]: https://en.wikipedia.org/wiki/Rounding#Round_half_away_from_zero
1686 [4]: https://en.wikipedia.org/wiki/Unit_in_the_last_place
1687 [5]: https://people.eecs.berkeley.edu/~wkahan/LOG10HAF.TXT
1688 [6]: https://en.wikipedia.org/wiki/Rounding#Rounding_away_from_zero