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*...] [*file*...]
41 bc(1) is an interactive processor for a language first standardized in 1991 by
42 POSIX. (The current standard is [here][1].) The language provides unlimited
43 precision decimal arithmetic and is somewhat C-like, but there are differences.
44 Such differences will be noted in this document.
46 After parsing and handling options, this bc(1) reads any files given on the
47 command line and executes them before reading from **stdin**.
49 This bc(1) is a drop-in replacement for *any* bc(1), including (and
50 especially) the GNU bc(1). It also has many extensions and extra features beyond
51 other implementations.
55 The following are the options that bc(1) accepts.
57 **-g**, **-\-global-stacks**
59 : Turns the globals **ibase**, **obase**, **scale**, and **seed** into stacks.
61 This has the effect that a copy of the current value of all four are pushed
62 onto a stack for every function call, as well as popped when every function
63 returns. This means that functions can assign to any and all of those
64 globals without worrying that the change will affect other functions.
65 Thus, a hypothetical function named **output(x,b)** that simply printed
66 **x** in base **b** could be written like this:
68 define void output(x, b) {
75 define void output(x, b) {
83 This makes writing functions much easier.
85 (**Note**: the function **output(x,b)** exists in the extended math library.
86 See the **LIBRARY** section.)
88 However, since using this flag means that functions cannot set **ibase**,
89 **obase**, **scale**, or **seed** globally, functions that are made to do so
90 cannot work anymore. There are two possible use cases for that, and each has
93 First, if a function is called on startup to turn bc(1) into a number
94 converter, it is possible to replace that capability with various shell
97 alias d2o="bc -e ibase=A -e obase=8"
98 alias h2b="bc -e ibase=G -e obase=2"
100 Second, if the purpose of a function is to set **ibase**, **obase**,
101 **scale**, or **seed** globally for any other purpose, it could be split
102 into one to four functions (based on how many globals it sets) and each of
103 those functions could return the desired value for a global.
105 For functions that set **seed**, the value assigned to **seed** is not
106 propagated to parent functions. This means that the sequence of
107 pseudo-random numbers that they see will not be the same sequence of
108 pseudo-random numbers that any parent sees. This is only the case once
109 **seed** has been set.
111 If a function desires to not affect the sequence of pseudo-random numbers
112 of its parents, but wants to use the same **seed**, it can use the following
117 If the behavior of this option is desired for every run of bc(1), then users
118 could make sure to define **BC_ENV_ARGS** and include this option (see the
119 **ENVIRONMENT VARIABLES** section for more details).
121 If **-s**, **-w**, or any equivalents are used, this option is ignored.
123 This is a **non-portable extension**.
127 : Prints a usage message and quits.
129 **-i**, **-\-interactive**
131 : Forces interactive mode. (See the **INTERACTIVE MODE** section.)
133 This is a **non-portable extension**.
135 **-l**, **-\-mathlib**
137 : Sets **scale** (see the **SYNTAX** section) to **20** and loads the included
138 math library and the extended math library before running any code,
139 including any expressions or files specified on the command line.
141 To learn what is in the libraries, see the **LIBRARY** section.
143 **-P**, **-\-no-prompt**
145 : Disables the prompt in TTY mode. (The prompt is only enabled in TTY mode.
146 See the **TTY MODE** section) This is mostly for those users that do not
147 want a prompt or are not used to having them in bc(1). Most of those users
148 would want to put this option in **BC_ENV_ARGS** (see the
149 **ENVIRONMENT VARIABLES** section).
151 This is a **non-portable extension**.
155 : This option is for compatibility with the [GNU bc(1)][2]; it is a no-op.
156 Without this option, GNU bc(1) prints a copyright header. This bc(1) only
157 prints the copyright header if one or more of the **-v**, **-V**, or
158 **-\-version** options are given.
160 This is a **non-portable extension**.
162 **-s**, **-\-standard**
164 : Process exactly the language defined by the [standard][1] and error if any
167 This is a **non-portable extension**.
169 **-v**, **-V**, **-\-version**
171 : Print the version information (copyright header) and exit.
173 This is a **non-portable extension**.
177 : Like **-s** and **-\-standard**, except that warnings (and not errors) are
178 printed for non-standard extensions and execution continues normally.
180 This is a **non-portable extension**.
182 **-e** *expr*, **-\-expression**=*expr*
184 : Evaluates *expr*. If multiple expressions are given, they are evaluated in
185 order. If files are given as well (see below), the expressions and files are
186 evaluated in the order given. This means that if a file is given before an
187 expression, the file is read in and evaluated first.
189 If this option is given on the command-line (i.e., not in **BC_ENV_ARGS**,
190 see the **ENVIRONMENT VARIABLES** section), then after processing all
191 expressions and files, bc(1) will exit, unless **-** (**stdin**) was given
192 as an argument at least once to **-f** or **-\-file**, whether on the
193 command-line or in **BC_ENV_ARGS**. However, if any other **-e**,
194 **-\-expression**, **-f**, or **-\-file** arguments are given after **-f-**
195 or equivalent is given, bc(1) will give a fatal error and exit.
197 This is a **non-portable extension**.
199 **-f** *file*, **-\-file**=*file*
201 : Reads in *file* and evaluates it, line by line, as though it were read
202 through **stdin**. If expressions are also given (see above), the
203 expressions are evaluated in the order given.
205 If this option is given on the command-line (i.e., not in **BC_ENV_ARGS**,
206 see the **ENVIRONMENT VARIABLES** section), then after processing all
207 expressions and files, bc(1) will exit, unless **-** (**stdin**) was given
208 as an argument at least once to **-f** or **-\-file**. However, if any other
209 **-e**, **-\-expression**, **-f**, or **-\-file** arguments are given after
210 **-f-** or equivalent is given, bc(1) will give a fatal error and exit.
212 This is a **non-portable extension**.
214 All long options are **non-portable extensions**.
218 Any non-error output is written to **stdout**. In addition, if history (see the
219 **HISTORY** section) and the prompt (see the **TTY MODE** section) are enabled,
220 both are output to **stdout**.
222 **Note**: Unlike other bc(1) implementations, this bc(1) will issue a fatal
223 error (see the **EXIT STATUS** section) if it cannot write to **stdout**, so if
224 **stdout** is closed, as in **bc <file> >&-**, it will quit with an error. This
225 is done so that bc(1) can report problems when **stdout** is redirected to a
228 If there are scripts that depend on the behavior of other bc(1) implementations,
229 it is recommended that those scripts be changed to redirect **stdout** to
234 Any error output is written to **stderr**.
236 **Note**: Unlike other bc(1) implementations, this bc(1) will issue a fatal
237 error (see the **EXIT STATUS** section) if it cannot write to **stderr**, so if
238 **stderr** is closed, as in **bc <file> 2>&-**, it will quit with an error. This
239 is done so that bc(1) can exit with an error code when **stderr** is redirected
242 If there are scripts that depend on the behavior of other bc(1) implementations,
243 it is recommended that those scripts be changed to redirect **stderr** to
248 The syntax for bc(1) programs is mostly C-like, with some differences. This
249 bc(1) follows the [POSIX standard][1], which is a much more thorough resource
250 for the language this bc(1) accepts. This section is meant to be a summary and a
251 listing of all the extensions to the standard.
253 In the sections below, **E** means expression, **S** means statement, and **I**
256 Identifiers (**I**) start with a lowercase letter and can be followed by any
257 number (up to **BC_NAME_MAX-1**) of lowercase letters (**a-z**), digits
258 (**0-9**), and underscores (**\_**). The regex is **\[a-z\]\[a-z0-9\_\]\***.
259 Identifiers with more than one character (letter) are a
260 **non-portable extension**.
262 **ibase** is a global variable determining how to interpret constant numbers. It
263 is the "input" base, or the number base used for interpreting input numbers.
264 **ibase** is initially **10**. If the **-s** (**-\-standard**) and **-w**
265 (**-\-warn**) flags were not given on the command line, the max allowable value
266 for **ibase** is **36**. Otherwise, it is **16**. The min allowable value for
267 **ibase** is **2**. The max allowable value for **ibase** can be queried in
268 bc(1) programs with the **maxibase()** built-in function.
270 **obase** is a global variable determining how to output results. It is the
271 "output" base, or the number base used for outputting numbers. **obase** is
272 initially **10**. The max allowable value for **obase** is **BC_BASE_MAX** and
273 can be queried in bc(1) programs with the **maxobase()** built-in function. The
274 min allowable value for **obase** is **0**. If **obase** is **0**, values are
275 output in scientific notation, and if **obase** is **1**, values are output in
276 engineering notation. Otherwise, values are output in the specified base.
278 Outputting in scientific and engineering notations are **non-portable
281 The *scale* of an expression is the number of digits in the result of the
282 expression right of the decimal point, and **scale** is a global variable that
283 sets the precision of any operations, with exceptions. **scale** is initially
284 **0**. **scale** cannot be negative. The max allowable value for **scale** is
285 **BC_SCALE_MAX** and can be queried in bc(1) programs with the **maxscale()**
288 bc(1) has both *global* variables and *local* variables. All *local*
289 variables are local to the function; they are parameters or are introduced in
290 the **auto** list of a function (see the **FUNCTIONS** section). If a variable
291 is accessed which is not a parameter or in the **auto** list, it is assumed to
292 be *global*. If a parent function has a *local* variable version of a variable
293 that a child function considers *global*, the value of that *global* variable in
294 the child function is the value of the variable in the parent function, not the
295 value of the actual *global* variable.
297 All of the above applies to arrays as well.
299 The value of a statement that is an expression (i.e., any of the named
300 expressions or operands) is printed unless the lowest precedence operator is an
301 assignment operator *and* the expression is notsurrounded by parentheses.
303 The value that is printed is also assigned to the special variable **last**. A
304 single dot (**.**) may also be used as a synonym for **last**. These are
305 **non-portable extensions**.
307 Either semicolons or newlines may separate statements.
311 There are two kinds of comments:
313 1. Block comments are enclosed in **/\*** and **\*/**.
314 2. Line comments go from **#** until, and not including, the next newline. This
315 is a **non-portable extension**.
319 The following are named expressions in bc(1):
322 2. Array Elements: **I[E]**
327 7. **last** or a single dot (**.**)
329 Numbers 6 and 7 are **non-portable extensions**.
331 The meaning of **seed** is dependent on the current pseudo-random number
332 generator but is guaranteed to not change except for new major versions.
334 The *scale* and sign of the value may be significant.
336 If a previously used **seed** value is assigned to **seed** and used again, the
337 pseudo-random number generator is guaranteed to produce the same sequence of
338 pseudo-random numbers as it did when the **seed** value was previously used.
340 The exact value assigned to **seed** is not guaranteed to be returned if
341 **seed** is queried again immediately. However, if **seed** *does* return a
342 different value, both values, when assigned to **seed**, are guaranteed to
343 produce the same sequence of pseudo-random numbers. This means that certain
344 values assigned to **seed** will *not* produce unique sequences of pseudo-random
345 numbers. The value of **seed** will change after any use of the **rand()** and
346 **irand(E)** operands (see the *Operands* subsection below), except if the
347 parameter passed to **irand(E)** is **0**, **1**, or negative.
349 There is no limit to the length (number of significant decimal digits) or
350 *scale* of the value that can be assigned to **seed**.
352 Variables and arrays do not interfere; users can have arrays named the same as
353 variables. This also applies to functions (see the **FUNCTIONS** section), so a
354 user can have a variable, array, and function that all have the same name, and
355 they will not shadow each other, whether inside of functions or not.
357 Named expressions are required as the operand of **increment**/**decrement**
358 operators and as the left side of **assignment** operators (see the *Operators*
363 The following are valid operands in bc(1):
365 1. Numbers (see the *Numbers* subsection below).
366 2. Array indices (**I[E]**).
367 3. **(E)**: The value of **E** (used to change precedence).
368 4. **sqrt(E)**: The square root of **E**. **E** must be non-negative.
369 5. **length(E)**: The number of significant decimal digits in **E**.
370 6. **length(I[])**: The number of elements in the array **I**. This is a
371 **non-portable extension**.
372 7. **scale(E)**: The *scale* of **E**.
373 8. **abs(E)**: The absolute value of **E**. This is a **non-portable
375 9. **I()**, **I(E)**, **I(E, E)**, and so on, where **I** is an identifier for
376 a non-**void** function (see the *Void Functions* subsection of the
377 **FUNCTIONS** section). The **E** argument(s) may also be arrays of the form
378 **I[]**, which will automatically be turned into array references (see the
379 *Array References* subsection of the **FUNCTIONS** section) if the
380 corresponding parameter in the function definition is an array reference.
381 10. **read()**: Reads a line from **stdin** and uses that as an expression. The
382 result of that expression is the result of the **read()** operand. This is a
383 **non-portable extension**.
384 11. **maxibase()**: The max allowable **ibase**. This is a **non-portable
386 12. **maxobase()**: The max allowable **obase**. This is a **non-portable
388 13. **maxscale()**: The max allowable **scale**. This is a **non-portable
390 14. **rand()**: A pseudo-random integer between **0** (inclusive) and
391 **BC_RAND_MAX** (inclusive). Using this operand will change the value of
392 **seed**. This is a **non-portable extension**.
393 15. **irand(E)**: A pseudo-random integer between **0** (inclusive) and the
394 value of **E** (exclusive). If **E** is negative or is a non-integer
395 (**E**'s *scale* is not **0**), an error is raised, and bc(1) resets (see
396 the **RESET** section) while **seed** remains unchanged. If **E** is larger
397 than **BC_RAND_MAX**, the higher bound is honored by generating several
398 pseudo-random integers, multiplying them by appropriate powers of
399 **BC_RAND_MAX+1**, and adding them together. Thus, the size of integer that
400 can be generated with this operand is unbounded. Using this operand will
401 change the value of **seed**, unless the value of **E** is **0** or **1**.
402 In that case, **0** is returned, and **seed** is *not* changed. This is a
403 **non-portable extension**.
404 16. **maxrand()**: The max integer returned by **rand()**. This is a
405 **non-portable extension**.
407 The integers generated by **rand()** and **irand(E)** are guaranteed to be as
408 unbiased as possible, subject to the limitations of the pseudo-random number
411 **Note**: The values returned by the pseudo-random number generator with
412 **rand()** and **irand(E)** are guaranteed to *NOT* be cryptographically secure.
413 This is a consequence of using a seeded pseudo-random number generator. However,
414 they *are* guaranteed to be reproducible with identical **seed** values. This
415 means that the pseudo-random values from bc(1) should only be used where a
416 reproducible stream of pseudo-random numbers is *ESSENTIAL*. In any other case,
417 use a non-seeded pseudo-random number generator.
421 Numbers are strings made up of digits, uppercase letters, and at most **1**
422 period for a radix. Numbers can have up to **BC_NUM_MAX** digits. Uppercase
423 letters are equal to **9** + their position in the alphabet (i.e., **A** equals
424 **10**, or **9+1**). If a digit or letter makes no sense with the current value
425 of **ibase**, they are set to the value of the highest valid digit in **ibase**.
427 Single-character numbers (i.e., **A** alone) take the value that they would have
428 if they were valid digits, regardless of the value of **ibase**. This means that
429 **A** alone always equals decimal **10** and **Z** alone always equals decimal
432 In addition, bc(1) accepts numbers in scientific notation. These have the form
433 **\<number\>e\<integer\>**. The exponent (the portion after the **e**) must be
434 an integer. An example is **1.89237e9**, which is equal to **1892370000**.
435 Negative exponents are also allowed, so **4.2890e-3** is equal to **0.0042890**.
437 Using scientific notation is an error or warning if the **-s** or **-w**,
438 respectively, command-line options (or equivalents) are given.
440 **WARNING**: Both the number and the exponent in scientific notation are
441 interpreted according to the current **ibase**, but the number is still
442 multiplied by **10\^exponent** regardless of the current **ibase**. For example,
443 if **ibase** is **16** and bc(1) is given the number string **FFeA**, the
444 resulting decimal number will be **2550000000000**, and if bc(1) is given the
445 number string **10e-4**, the resulting decimal number will be **0.0016**.
447 Accepting input as scientific notation is a **non-portable extension**.
451 The following arithmetic and logical operators can be used. They are listed in
452 order of decreasing precedence. Operators in the same group have the same
457 : Type: Prefix and Postfix
461 Description: **increment**, **decrement**
469 Description: **negation**, **boolean not**
477 Description: **truncation**
485 Description: **set precision**
493 Description: **power**
501 Description: **multiply**, **divide**, **modulus**
509 Description: **add**, **subtract**
517 Description: **shift left**, **shift right**
519 **=** **\<\<=** **\>\>=** **+=** **-=** **\*=** **/=** **%=** **\^=** **\@=**
525 Description: **assignment**
527 **==** **\<=** **\>=** **!=** **\<** **\>**
533 Description: **relational**
541 Description: **boolean and**
549 Description: **boolean or**
551 The operators will be described in more detail below.
555 : The prefix and postfix **increment** and **decrement** operators behave
556 exactly like they would in C. They require a named expression (see the
557 *Named Expressions* subsection) as an operand.
559 The prefix versions of these operators are more efficient; use them where
564 : The **negation** operator returns **0** if a user attempts to negate any
565 expression with the value **0**. Otherwise, a copy of the expression with
566 its sign flipped is returned.
570 : The **boolean not** operator returns **1** if the expression is **0**, or
573 This is a **non-portable extension**.
577 : The **truncation** operator returns a copy of the given expression with all
578 of its *scale* removed.
580 This is a **non-portable extension**.
584 : The **set precision** operator takes two expressions and returns a copy of
585 the first with its *scale* equal to the value of the second expression. That
586 could either mean that the number is returned without change (if the
587 *scale* of the first expression matches the value of the second
588 expression), extended (if it is less), or truncated (if it is more).
590 The second expression must be an integer (no *scale*) and non-negative.
592 This is a **non-portable extension**.
596 : The **power** operator (not the **exclusive or** operator, as it would be in
597 C) takes two expressions and raises the first to the power of the value of
598 the second. The *scale* of the result is equal to **scale**.
600 The second expression must be an integer (no *scale*), and if it is
601 negative, the first value must be non-zero.
605 : The **multiply** operator takes two expressions, multiplies them, and
606 returns the product. If **a** is the *scale* of the first expression and
607 **b** is the *scale* of the second expression, the *scale* of the result is
608 equal to **min(a+b,max(scale,a,b))** where **min()** and **max()** return
613 : The **divide** operator takes two expressions, divides them, and returns the
614 quotient. The *scale* of the result shall be the value of **scale**.
616 The second expression must be non-zero.
620 : The **modulus** operator takes two expressions, **a** and **b**, and
621 evaluates them by 1) Computing **a/b** to current **scale** and 2) Using the
622 result of step 1 to calculate **a-(a/b)\*b** to *scale*
623 **max(scale+scale(b),scale(a))**.
625 The second expression must be non-zero.
629 : The **add** operator takes two expressions, **a** and **b**, and returns the
630 sum, with a *scale* equal to the max of the *scale*s of **a** and **b**.
634 : The **subtract** operator takes two expressions, **a** and **b**, and
635 returns the difference, with a *scale* equal to the max of the *scale*s of
640 : The **left shift** operator takes two expressions, **a** and **b**, and
641 returns a copy of the value of **a** with its decimal point moved **b**
644 The second expression must be an integer (no *scale*) and non-negative.
646 This is a **non-portable extension**.
650 : The **right shift** operator takes two expressions, **a** and **b**, and
651 returns a copy of the value of **a** with its decimal point moved **b**
654 The second expression must be an integer (no *scale*) and non-negative.
656 This is a **non-portable extension**.
658 **=** **\<\<=** **\>\>=** **+=** **-=** **\*=** **/=** **%=** **\^=** **\@=**
660 : The **assignment** operators take two expressions, **a** and **b** where
661 **a** is a named expression (see the *Named Expressions* subsection).
663 For **=**, **b** is copied and the result is assigned to **a**. For all
664 others, **a** and **b** are applied as operands to the corresponding
665 arithmetic operator and the result is assigned to **a**.
667 The **assignment** operators that correspond to operators that are
668 extensions are themselves **non-portable extensions**.
670 **==** **\<=** **\>=** **!=** **\<** **\>**
672 : The **relational** operators compare two expressions, **a** and **b**, and
673 if the relation holds, according to C language semantics, the result is
674 **1**. Otherwise, it is **0**.
676 Note that unlike in C, these operators have a lower precedence than the
677 **assignment** operators, which means that **a=b\>c** is interpreted as
680 Also, unlike the [standard][1] requires, these operators can appear anywhere
681 any other expressions can be used. This allowance is a
682 **non-portable extension**.
686 : The **boolean and** operator takes two expressions and returns **1** if both
687 expressions are non-zero, **0** otherwise.
689 This is *not* a short-circuit operator.
691 This is a **non-portable extension**.
695 : The **boolean or** operator takes two expressions and returns **1** if one
696 of the expressions is non-zero, **0** otherwise.
698 This is *not* a short-circuit operator.
700 This is a **non-portable extension**.
704 The following items are statements:
707 2. **{** **S** **;** ... **;** **S** **}**
708 3. **if** **(** **E** **)** **S**
709 4. **if** **(** **E** **)** **S** **else** **S**
710 5. **while** **(** **E** **)** **S**
711 6. **for** **(** **E** **;** **E** **;** **E** **)** **S**
712 7. An empty statement
718 13. A string of characters, enclosed in double quotes
719 14. **print** **E** **,** ... **,** **E**
720 15. **I()**, **I(E)**, **I(E, E)**, and so on, where **I** is an identifier for
721 a **void** function (see the *Void Functions* subsection of the
722 **FUNCTIONS** section). The **E** argument(s) may also be arrays of the form
723 **I[]**, which will automatically be turned into array references (see the
724 *Array References* subsection of the **FUNCTIONS** section) if the
725 corresponding parameter in the function definition is an array reference.
727 Numbers 4, 9, 11, 12, 14, and 15 are **non-portable extensions**.
729 Also, as a **non-portable extension**, any or all of the expressions in the
730 header of a for loop may be omitted. If the condition (second expression) is
731 omitted, it is assumed to be a constant **1**.
733 The **break** statement causes a loop to stop iterating and resume execution
734 immediately following a loop. This is only allowed in loops.
736 The **continue** statement causes a loop iteration to stop early and returns to
737 the start of the loop, including testing the loop condition. This is only
740 The **if** **else** statement does the same thing as in C.
742 The **quit** statement causes bc(1) to quit, even if it is on a branch that will
743 not be executed (it is a compile-time command).
745 The **halt** statement causes bc(1) to quit, if it is executed. (Unlike **quit**
746 if it is on a branch of an **if** statement that is not executed, bc(1) does not
749 The **limits** statement prints the limits that this bc(1) is subject to. This
750 is like the **quit** statement in that it is a compile-time command.
752 An expression by itself is evaluated and printed, followed by a newline.
754 Both scientific notation and engineering notation are available for printing the
755 results of expressions. Scientific notation is activated by assigning **0** to
756 **obase**, and engineering notation is activated by assigning **1** to
757 **obase**. To deactivate them, just assign a different value to **obase**.
759 Scientific notation and engineering notation are disabled if bc(1) is run with
760 either the **-s** or **-w** command-line options (or equivalents).
762 Printing numbers in scientific notation and/or engineering notation is a
763 **non-portable extension**.
767 The "expressions" in a **print** statement may also be strings. If they are, there
768 are backslash escape sequences that are interpreted specially. What those
769 sequences are, and what they cause to be printed, are shown below:
783 Any other character following a backslash causes the backslash and character to
786 Any non-string expression in a print statement shall be assigned to **last**,
787 like any other expression that is printed.
789 ## Order of Evaluation
791 All expressions in a statment are evaluated left to right, except as necessary
792 to maintain order of operations. This means, for example, assuming that **i** is
793 equal to **0**, in the expression
797 the first (or 0th) element of **a** is set to **1**, and **i** is equal to **2**
798 at the end of the expression.
800 This includes function arguments. Thus, assuming **i** is equal to **0**, this
801 means that in the expression
805 the first argument passed to **x()** is **0**, and the second argument is **1**,
806 while **i** is equal to **2** before the function starts executing.
810 Function definitions are as follows:
820 Any **I** in the parameter list or **auto** list may be replaced with **I[]** to
821 make a parameter or **auto** var an array, and any **I** in the parameter list
822 may be replaced with **\*I[]** to make a parameter an array reference. Callers
823 of functions that take array references should not put an asterisk in the call;
824 they must be called with just **I[]** like normal array parameters and will be
825 automatically converted into references.
827 As a **non-portable extension**, the opening brace of a **define** statement may
828 appear on the next line.
830 As a **non-portable extension**, the return statement may also be in one of the
834 2. **return** **(** **)**
837 The first two, or not specifying a **return** statement, is equivalent to
838 **return (0)**, unless the function is a **void** function (see the *Void
839 Functions* subsection below).
843 Functions can also be **void** functions, defined as follows:
846 define void I(I,...,I){
853 They can only be used as standalone expressions, where such an expression would
854 be printed alone, except in a print statement.
856 Void functions can only use the first two **return** statements listed above.
857 They can also omit the return statement entirely.
859 The word "void" is not treated as a keyword; it is still possible to have
860 variables, arrays, and functions named **void**. The word "void" is only
861 treated specially right after the **define** keyword.
863 This is a **non-portable extension**.
867 For any array in the parameter list, if the array is declared in the form
873 it is a **reference**. Any changes to the array in the function are reflected,
874 when the function returns, to the array that was passed in.
876 Other than this, all function arguments are passed by value.
878 This is a **non-portable extension**.
882 All of the functions below, including the functions in the extended math
883 library (see the *Extended Library* subsection below), are available when the
884 **-l** or **-\-mathlib** command-line flags are given, except that the extended
885 math library is not available when the **-s** option, the **-w** option, or
886 equivalents are given.
890 The [standard][1] defines the following functions for the math library:
894 : Returns the sine of **x**, which is assumed to be in radians.
896 This is a transcendental function (see the *Transcendental Functions*
901 : Returns the cosine of **x**, which is assumed to be in radians.
903 This is a transcendental function (see the *Transcendental Functions*
908 : Returns the arctangent of **x**, in radians.
910 This is a transcendental function (see the *Transcendental Functions*
915 : Returns the natural logarithm of **x**.
917 This is a transcendental function (see the *Transcendental Functions*
922 : Returns the mathematical constant **e** raised to the power of **x**.
924 This is a transcendental function (see the *Transcendental Functions*
929 : Returns the bessel integer order **n** (truncated) of **x**.
931 This is a transcendental function (see the *Transcendental Functions*
936 The extended library is *not* loaded when the **-s**/**-\-standard** or
937 **-w**/**-\-warn** options are given since they are not part of the library
938 defined by the [standard][1].
940 The extended library is a **non-portable extension**.
944 : Calculates **x** to the power of **y**, even if **y** is not an integer, and
945 returns the result to the current **scale**.
947 It is an error if **y** is negative and **x** is **0**.
949 This is a transcendental function (see the *Transcendental Functions*
954 : Returns **x** rounded to **p** decimal places according to the rounding mode
955 [round half away from **0**][3].
959 : Returns **x** rounded to **p** decimal places according to the rounding mode
960 [round away from **0**][6].
964 : Returns the factorial of the truncated absolute value of **x**.
968 : Returns the permutation of the truncated absolute value of **n** of the
969 truncated absolute value of **k**, if **k \<= n**. If not, it returns **0**.
973 : Returns the combination of the truncated absolute value of **n** of the
974 truncated absolute value of **k**, if **k \<= n**. If not, it returns **0**.
978 : Returns the logarithm base **2** of **x**.
980 This is a transcendental function (see the *Transcendental Functions*
985 : Returns the logarithm base **10** of **x**.
987 This is a transcendental function (see the *Transcendental Functions*
992 : Returns the logarithm base **b** of **x**.
994 This is a transcendental function (see the *Transcendental Functions*
999 : Returns the cube root of **x**.
1003 : Calculates the truncated value of **n**, **r**, and returns the **r**th root
1004 of **x** to the current **scale**.
1006 If **r** is **0** or negative, this raises an error and causes bc(1) to
1007 reset (see the **RESET** section). It also raises an error and causes bc(1)
1008 to reset if **r** is even and **x** is negative.
1012 : Returns **pi** to **p** decimal places.
1014 This is a transcendental function (see the *Transcendental Functions*
1019 : Returns the tangent of **x**, which is assumed to be in radians.
1021 This is a transcendental function (see the *Transcendental Functions*
1026 : Returns the arctangent of **y/x**, in radians. If both **y** and **x** are
1027 equal to **0**, it raises an error and causes bc(1) to reset (see the
1028 **RESET** section). Otherwise, if **x** is greater than **0**, it returns
1029 **a(y/x)**. If **x** is less than **0**, and **y** is greater than or equal
1030 to **0**, it returns **a(y/x)+pi**. If **x** is less than **0**, and **y**
1031 is less than **0**, it returns **a(y/x)-pi**. If **x** is equal to **0**,
1032 and **y** is greater than **0**, it returns **pi/2**. If **x** is equal to
1033 **0**, and **y** is less than **0**, it returns **-pi/2**.
1035 This function is the same as the **atan2()** function in many programming
1038 This is a transcendental function (see the *Transcendental Functions*
1043 : Returns the sine of **x**, which is assumed to be in radians.
1045 This is an alias of **s(x)**.
1047 This is a transcendental function (see the *Transcendental Functions*
1052 : Returns the cosine of **x**, which is assumed to be in radians.
1054 This is an alias of **c(x)**.
1056 This is a transcendental function (see the *Transcendental Functions*
1061 : Returns the tangent of **x**, which is assumed to be in radians.
1063 If **x** is equal to **1** or **-1**, this raises an error and causes bc(1)
1064 to reset (see the **RESET** section).
1066 This is an alias of **t(x)**.
1068 This is a transcendental function (see the *Transcendental Functions*
1073 : Returns the arctangent of **x**, in radians.
1075 This is an alias of **a(x)**.
1077 This is a transcendental function (see the *Transcendental Functions*
1082 : Returns the arctangent of **y/x**, in radians. If both **y** and **x** are
1083 equal to **0**, it raises an error and causes bc(1) to reset (see the
1084 **RESET** section). Otherwise, if **x** is greater than **0**, it returns
1085 **a(y/x)**. If **x** is less than **0**, and **y** is greater than or equal
1086 to **0**, it returns **a(y/x)+pi**. If **x** is less than **0**, and **y**
1087 is less than **0**, it returns **a(y/x)-pi**. If **x** is equal to **0**,
1088 and **y** is greater than **0**, it returns **pi/2**. If **x** is equal to
1089 **0**, and **y** is less than **0**, it returns **-pi/2**.
1091 This function is the same as the **atan2()** function in many programming
1094 This is an alias of **a2(y, x)**.
1096 This is a transcendental function (see the *Transcendental Functions*
1101 : Converts **x** from radians to degrees and returns the result.
1103 This is a transcendental function (see the *Transcendental Functions*
1108 : Converts **x** from degrees to radians and returns the result.
1110 This is a transcendental function (see the *Transcendental Functions*
1115 : Generates a pseudo-random number between **0** (inclusive) and **1**
1116 (exclusive) with the number of decimal digits after the decimal point equal
1117 to the truncated absolute value of **p**. If **p** is not **0**, then
1118 calling this function will change the value of **seed**. If **p** is **0**,
1119 then **0** is returned, and **seed** is *not* changed.
1123 : Generates a pseudo-random number that is between **0** (inclusive) and the
1124 truncated absolute value of **i** (exclusive) with the number of decimal
1125 digits after the decimal point equal to the truncated absolute value of
1126 **p**. If the absolute value of **i** is greater than or equal to **2**, and
1127 **p** is not **0**, then calling this function will change the value of
1128 **seed**; otherwise, **0** is returned and **seed** is not changed.
1132 : Returns **x** with its sign flipped with probability **0.5**. In other
1133 words, it randomizes the sign of **x**.
1137 : Returns a random boolean value (either **0** or **1**).
1141 : Returns the numbers of unsigned integer bytes required to hold the truncated
1142 absolute value of **x**.
1146 : Returns the numbers of signed, two's-complement integer bytes required to
1147 hold the truncated value of **x**.
1151 : Outputs the hexadecimal (base **16**) representation of **x**.
1153 This is a **void** function (see the *Void Functions* subsection of the
1154 **FUNCTIONS** section).
1158 : Outputs the binary (base **2**) representation of **x**.
1160 This is a **void** function (see the *Void Functions* subsection of the
1161 **FUNCTIONS** section).
1165 : Outputs the base **b** representation of **x**.
1167 This is a **void** function (see the *Void Functions* subsection of the
1168 **FUNCTIONS** section).
1172 : Outputs the representation, in binary and hexadecimal, of **x** as an
1173 unsigned integer in as few power of two bytes as possible. Both outputs are
1174 split into bytes separated by spaces.
1176 If **x** is not an integer or is negative, an error message is printed
1177 instead, but bc(1) is not reset (see the **RESET** section).
1179 This is a **void** function (see the *Void Functions* subsection of the
1180 **FUNCTIONS** section).
1184 : Outputs the representation, in binary and hexadecimal, of **x** as a signed,
1185 two's-complement integer in as few power of two bytes as possible. Both
1186 outputs are split into bytes separated by spaces.
1188 If **x** is not an integer, an error message is printed instead, but bc(1)
1189 is not reset (see the **RESET** section).
1191 This is a **void** function (see the *Void Functions* subsection of the
1192 **FUNCTIONS** section).
1196 : Outputs the representation, in binary and hexadecimal, of **x** as an
1197 unsigned integer in **n** bytes. Both outputs are split into bytes separated
1200 If **x** is not an integer, is negative, or cannot fit into **n** bytes, an
1201 error message is printed instead, but bc(1) is not reset (see the **RESET**
1204 This is a **void** function (see the *Void Functions* subsection of the
1205 **FUNCTIONS** section).
1209 : Outputs the representation, in binary and hexadecimal, of **x** as a signed,
1210 two's-complement integer in **n** bytes. Both outputs are split into bytes
1211 separated by spaces.
1213 If **x** is not an integer or cannot fit into **n** bytes, an error message
1214 is printed instead, but bc(1) is not reset (see the **RESET** section).
1216 This is a **void** function (see the *Void Functions* subsection of the
1217 **FUNCTIONS** section).
1221 : Outputs the representation, in binary and hexadecimal, of **x** as an
1222 unsigned integer in **1** byte. Both outputs are split into bytes separated
1225 If **x** is not an integer, is negative, or cannot fit into **1** byte, an
1226 error message is printed instead, but bc(1) is not reset (see the **RESET**
1229 This is a **void** function (see the *Void Functions* subsection of the
1230 **FUNCTIONS** section).
1234 : Outputs the representation, in binary and hexadecimal, of **x** as a signed,
1235 two's-complement integer in **1** byte. Both outputs are split into bytes
1236 separated by spaces.
1238 If **x** is not an integer or cannot fit into **1** byte, an error message
1239 is printed instead, but bc(1) is not reset (see the **RESET** section).
1241 This is a **void** function (see the *Void Functions* subsection of the
1242 **FUNCTIONS** section).
1246 : Outputs the representation, in binary and hexadecimal, of **x** as an
1247 unsigned integer in **2** bytes. Both outputs are split into bytes separated
1250 If **x** is not an integer, is negative, or cannot fit into **2** bytes, an
1251 error message is printed instead, but bc(1) is not reset (see the **RESET**
1254 This is a **void** function (see the *Void Functions* subsection of the
1255 **FUNCTIONS** section).
1259 : Outputs the representation, in binary and hexadecimal, of **x** as a signed,
1260 two's-complement integer in **2** bytes. Both outputs are split into bytes
1261 separated by spaces.
1263 If **x** is not an integer or cannot fit into **2** bytes, an error message
1264 is printed instead, but bc(1) is not reset (see the **RESET** section).
1266 This is a **void** function (see the *Void Functions* subsection of the
1267 **FUNCTIONS** section).
1271 : Outputs the representation, in binary and hexadecimal, of **x** as an
1272 unsigned integer in **4** bytes. Both outputs are split into bytes separated
1275 If **x** is not an integer, is negative, or cannot fit into **4** bytes, an
1276 error message is printed instead, but bc(1) is not reset (see the **RESET**
1279 This is a **void** function (see the *Void Functions* subsection of the
1280 **FUNCTIONS** section).
1284 : Outputs the representation, in binary and hexadecimal, of **x** as a signed,
1285 two's-complement integer in **4** bytes. Both outputs are split into bytes
1286 separated by spaces.
1288 If **x** is not an integer or cannot fit into **4** bytes, an error message
1289 is printed instead, but bc(1) is not reset (see the **RESET** section).
1291 This is a **void** function (see the *Void Functions* subsection of the
1292 **FUNCTIONS** section).
1296 : Outputs the representation, in binary and hexadecimal, of **x** as an
1297 unsigned integer in **8** bytes. Both outputs are split into bytes separated
1300 If **x** is not an integer, is negative, or cannot fit into **8** bytes, an
1301 error message is printed instead, but bc(1) is not reset (see the **RESET**
1304 This is a **void** function (see the *Void Functions* subsection of the
1305 **FUNCTIONS** section).
1309 : Outputs the representation, in binary and hexadecimal, of **x** as a signed,
1310 two's-complement integer in **8** bytes. Both outputs are split into bytes
1311 separated by spaces.
1313 If **x** is not an integer or cannot fit into **8** bytes, an error message
1314 is printed instead, but bc(1) is not reset (see the **RESET** section).
1316 This is a **void** function (see the *Void Functions* subsection of the
1317 **FUNCTIONS** section).
1321 : Outputs the representation of the truncated absolute value of **x** as an
1322 unsigned integer in hexadecimal using **n** bytes. Not all of the value will
1323 be output if **n** is too small.
1325 This is a **void** function (see the *Void Functions* subsection of the
1326 **FUNCTIONS** section).
1328 **binary_uint(x, n)**
1330 : Outputs the representation of the truncated absolute value of **x** as an
1331 unsigned integer in binary using **n** bytes. Not all of the value will be
1332 output if **n** is too small.
1334 This is a **void** function (see the *Void Functions* subsection of the
1335 **FUNCTIONS** section).
1337 **output_uint(x, n)**
1339 : Outputs the representation of the truncated absolute value of **x** as an
1340 unsigned integer in the current **obase** (see the **SYNTAX** section) using
1341 **n** bytes. Not all of the value will be output if **n** is too small.
1343 This is a **void** function (see the *Void Functions* subsection of the
1344 **FUNCTIONS** section).
1346 **output_byte(x, i)**
1348 : Outputs byte **i** of the truncated absolute value of **x**, where **0** is
1349 the least significant byte and **number_of_bytes - 1** is the most
1352 This is a **void** function (see the *Void Functions* subsection of the
1353 **FUNCTIONS** section).
1355 ## Transcendental Functions
1357 All transcendental functions can return slightly inaccurate results (up to 1
1358 [ULP][4]). This is unavoidable, and [this article][5] explains why it is
1359 impossible and unnecessary to calculate exact results for the transcendental
1362 Because of the possible inaccuracy, I recommend that users call those functions
1363 with the precision (**scale**) set to at least 1 higher than is necessary. If
1364 exact results are *absolutely* required, users can double the precision
1365 (**scale**) and then truncate.
1367 The transcendental functions in the standard math library are:
1376 The transcendental functions in the extended math library are:
1394 When bc(1) encounters an error or a signal that it has a non-default handler
1395 for, it resets. This means that several things happen.
1397 First, any functions that are executing are stopped and popped off the stack.
1398 The behavior is not unlike that of exceptions in programming languages. Then
1399 the execution point is set so that any code waiting to execute (after all
1400 functions returned) is skipped.
1402 Thus, when bc(1) resets, it skips any remaining code waiting to be executed.
1403 Then, if it is interactive mode, and the error was not a fatal error (see the
1404 **EXIT STATUS** section), it asks for more input; otherwise, it exits with the
1405 appropriate return code.
1407 Note that this reset behavior is different from the GNU bc(1), which attempts to
1408 start executing the statement right after the one that caused an error.
1412 Most bc(1) implementations use **char** types to calculate the value of **1**
1413 decimal digit at a time, but that can be slow. This bc(1) does something
1416 It uses large integers to calculate more than **1** decimal digit at a time. If
1417 built in a environment where **BC_LONG_BIT** (see the **LIMITS** section) is
1418 **64**, then each integer has **9** decimal digits. If built in an environment
1419 where **BC_LONG_BIT** is **32** then each integer has **4** decimal digits. This
1420 value (the number of decimal digits per large integer) is called
1423 The actual values of **BC_LONG_BIT** and **BC_BASE_DIGS** can be queried with
1424 the **limits** statement.
1426 In addition, this bc(1) uses an even larger integer for overflow checking. This
1427 integer type depends on the value of **BC_LONG_BIT**, but is always at least
1428 twice as large as the integer type used to store digits.
1432 The following are the limits on bc(1):
1436 : The number of bits in the **long** type in the environment where bc(1) was
1437 built. This determines how many decimal digits can be stored in a single
1438 large integer (see the **PERFORMANCE** section).
1442 : The number of decimal digits per large integer (see the **PERFORMANCE**
1443 section). Depends on **BC_LONG_BIT**.
1447 : The max decimal number that each large integer can store (see
1448 **BC_BASE_DIGS**) plus **1**. Depends on **BC_BASE_DIGS**.
1452 : The max number that the overflow type (see the **PERFORMANCE** section) can
1453 hold. Depends on **BC_LONG_BIT**.
1457 : The maximum output base. Set at **BC_BASE_POW**.
1461 : The maximum size of arrays. Set at **SIZE_MAX-1**.
1465 : The maximum **scale**. Set at **BC_OVERFLOW_MAX-1**.
1469 : The maximum length of strings. Set at **BC_OVERFLOW_MAX-1**.
1473 : The maximum length of identifiers. Set at **BC_OVERFLOW_MAX-1**.
1477 : The maximum length of a number (in decimal digits), which includes digits
1478 after the decimal point. Set at **BC_OVERFLOW_MAX-1**.
1482 : The maximum integer (inclusive) returned by the **rand()** operand. Set at
1483 **2\^BC_LONG_BIT-1**.
1487 : The maximum allowable exponent (positive or negative). Set at
1488 **BC_OVERFLOW_MAX**.
1492 : The maximum number of vars/arrays. Set at **SIZE_MAX-1**.
1494 The actual values can be queried with the **limits** statement.
1496 These limits are meant to be effectively non-existent; the limits are so large
1497 (at least on 64-bit machines) that there should not be any point at which they
1498 become a problem. In fact, memory should be exhausted before these limits should
1501 # ENVIRONMENT VARIABLES
1503 bc(1) recognizes the following environment variables:
1507 : If this variable exists (no matter the contents), bc(1) behaves as if
1508 the **-s** option was given.
1512 : This is another way to give command-line arguments to bc(1). They should be
1513 in the same format as all other command-line arguments. These are always
1514 processed first, so any files given in **BC_ENV_ARGS** will be processed
1515 before arguments and files given on the command-line. This gives the user
1516 the ability to set up "standard" options and files to be used at every
1517 invocation. The most useful thing for such files to contain would be useful
1518 functions that the user might want every time bc(1) runs.
1520 The code that parses **BC_ENV_ARGS** will correctly handle quoted arguments,
1521 but it does not understand escape sequences. For example, the string
1522 **"/home/gavin/some bc file.bc"** will be correctly parsed, but the string
1523 **"/home/gavin/some \"bc\" file.bc"** will include the backslashes.
1525 The quote parsing will handle either kind of quotes, **'** or **"**. Thus,
1526 if you have a file with any number of single quotes in the name, you can use
1527 double quotes as the outside quotes, as in **"some 'bc' file.bc"**, and vice
1528 versa if you have a file with double quotes. However, handling a file with
1529 both kinds of quotes in **BC_ENV_ARGS** is not supported due to the
1530 complexity of the parsing, though such files are still supported on the
1531 command-line where the parsing is done by the shell.
1535 : If this environment variable exists and contains an integer that is greater
1536 than **1** and is less than **UINT16_MAX** (**2\^16-1**), bc(1) will output
1537 lines to that length, including the backslash (**\\**). The default line
1542 bc(1) returns the following exit statuses:
1550 : A math error occurred. This follows standard practice of using **1** for
1551 expected errors, since math errors will happen in the process of normal
1554 Math errors include divide by **0**, taking the square root of a negative
1555 number, using a negative number as a bound for the pseudo-random number
1556 generator, attempting to convert a negative number to a hardware integer,
1557 overflow when converting a number to a hardware integer, and attempting to
1558 use a non-integer where an integer is required.
1560 Converting to a hardware integer happens for the second operand of the power
1561 (**\^**), places (**\@**), left shift (**\<\<**), and right shift (**\>\>**)
1562 operators and their corresponding assignment operators.
1566 : A parse error occurred.
1568 Parse errors include unexpected **EOF**, using an invalid character, failing
1569 to find the end of a string or comment, using a token where it is invalid,
1570 giving an invalid expression, giving an invalid print statement, giving an
1571 invalid function definition, attempting to assign to an expression that is
1572 not a named expression (see the *Named Expressions* subsection of the
1573 **SYNTAX** section), giving an invalid **auto** list, having a duplicate
1574 **auto**/function parameter, failing to find the end of a code block,
1575 attempting to return a value from a **void** function, attempting to use a
1576 variable as a reference, and using any extensions when the option **-s** or
1577 any equivalents were given.
1581 : A runtime error occurred.
1583 Runtime errors include assigning an invalid number to **ibase**, **obase**,
1584 or **scale**; give a bad expression to a **read()** call, calling **read()**
1585 inside of a **read()** call, type errors, passing the wrong number of
1586 arguments to functions, attempting to call an undefined function, and
1587 attempting to use a **void** function call as a value in an expression.
1591 : A fatal error occurred.
1593 Fatal errors include memory allocation errors, I/O errors, failing to open
1594 files, attempting to use files that do not have only ASCII characters (bc(1)
1595 only accepts ASCII characters), attempting to open a directory as a file,
1596 and giving invalid command-line options.
1598 The exit status **4** is special; when a fatal error occurs, bc(1) always exits
1599 and returns **4**, no matter what mode bc(1) is in.
1601 The other statuses will only be returned when bc(1) is not in interactive mode
1602 (see the **INTERACTIVE MODE** section), since bc(1) resets its state (see the
1603 **RESET** section) and accepts more input when one of those errors occurs in
1604 interactive mode. This is also the case when interactive mode is forced by the
1605 **-i** flag or **-\-interactive** option.
1607 These exit statuses allow bc(1) to be used in shell scripting with error
1608 checking, and its normal behavior can be forced by using the **-i** flag or
1609 **-\-interactive** option.
1613 Per the [standard][1], bc(1) has an interactive mode and a non-interactive mode.
1614 Interactive mode is turned on automatically when both **stdin** and **stdout**
1615 are hooked to a terminal, but the **-i** flag and **-\-interactive** option can
1616 turn it on in other cases.
1618 In interactive mode, bc(1) attempts to recover from errors (see the **RESET**
1619 section), and in normal execution, flushes **stdout** as soon as execution is
1620 done for the current input.
1624 If **stdin**, **stdout**, and **stderr** are all connected to a TTY, bc(1) turns
1627 TTY mode is required for history to be enabled (see the **COMMAND LINE HISTORY**
1628 section). It is also required to enable special handling for **SIGINT** signals.
1630 The prompt is enabled in TTY mode.
1632 TTY mode is different from interactive mode because interactive mode is required
1633 in the [bc(1) specification][1], and interactive mode requires only **stdin**
1634 and **stdout** to be connected to a terminal.
1638 Sending a **SIGINT** will cause bc(1) to stop execution of the current input. If
1639 bc(1) is in TTY mode (see the **TTY MODE** section), it will reset (see the
1640 **RESET** section). Otherwise, it will clean up and exit.
1642 Note that "current input" can mean one of two things. If bc(1) is processing
1643 input from **stdin** in TTY mode, it will ask for more input. If bc(1) is
1644 processing input from a file in TTY mode, it will stop processing the file and
1645 start processing the next file, if one exists, or ask for input from **stdin**
1646 if no other file exists.
1648 This means that if a **SIGINT** is sent to bc(1) as it is executing a file, it
1649 can seem as though bc(1) did not respond to the signal since it will immediately
1650 start executing the next file. This is by design; most files that users execute
1651 when interacting with bc(1) have function definitions, which are quick to parse.
1652 If a file takes a long time to execute, there may be a bug in that file. The
1653 rest of the files could still be executed without problem, allowing the user to
1656 **SIGTERM** and **SIGQUIT** cause bc(1) to clean up and exit, and it uses the
1657 default handler for all other signals. The one exception is **SIGHUP**; in that
1658 case, when bc(1) is in TTY mode, a **SIGHUP** will cause bc(1) to clean up and
1661 # COMMAND LINE HISTORY
1663 bc(1) supports interactive command-line editing. If bc(1) is in TTY mode (see
1664 the **TTY MODE** section), history is enabled. Previous lines can be recalled
1665 and edited with the arrow keys.
1667 **Note**: tabs are converted to 8 spaces.
1671 This bc(1) ships with support for adding error messages for different locales
1672 and thus, supports **LC_MESSAGES**.
1680 bc(1) is compliant with the [IEEE Std 1003.1-2017 (“POSIX.1-2017”)][1]
1681 specification. The flags **-efghiqsvVw**, all long options, and the extensions
1682 noted above are extensions to that specification.
1684 Note that the specification explicitly says that bc(1) only accepts numbers that
1685 use a period (**.**) as a radix point, regardless of the value of
1688 This bc(1) supports error messages for different locales, and thus, it supports
1693 None are known. Report bugs at https://git.yzena.com/gavin/bc.
1697 Gavin D. Howard <gavin@yzena.com> and contributors.
1699 [1]: https://pubs.opengroup.org/onlinepubs/9699919799/utilities/bc.html
1700 [2]: https://www.gnu.org/software/bc/
1701 [3]: https://en.wikipedia.org/wiki/Rounding#Round_half_away_from_zero
1702 [4]: https://en.wikipedia.org/wiki/Unit_in_the_last_place
1703 [5]: https://people.eecs.berkeley.edu/~wkahan/LOG10HAF.TXT
1704 [6]: https://en.wikipedia.org/wiki/Rounding#Rounding_away_from_zero