diff options
author | uqs <uqs@FreeBSD.org> | 2010-12-04 10:11:20 +0000 |
---|---|---|
committer | uqs <uqs@FreeBSD.org> | 2010-12-04 10:11:20 +0000 |
commit | 9242c645f81d22058934688725f1fff0bc88cb64 (patch) | |
tree | a39140e4d881fbba4f04ac77974bfbb05df9d360 /usr.bin/bc | |
parent | 06cd6f2bc1f94f941b57ef92ed6445529822669b (diff) | |
download | FreeBSD-src-9242c645f81d22058934688725f1fff0bc88cb64.zip FreeBSD-src-9242c645f81d22058934688725f1fff0bc88cb64.tar.gz |
Move most of the remaining USD/PSD/SMM papers into share/doc
Diffstat (limited to 'usr.bin/bc')
-rw-r--r-- | usr.bin/bc/USD.doc/bc | 1241 |
1 files changed, 0 insertions, 1241 deletions
diff --git a/usr.bin/bc/USD.doc/bc b/usr.bin/bc/USD.doc/bc deleted file mode 100644 index c4e68c6..0000000 --- a/usr.bin/bc/USD.doc/bc +++ /dev/null @@ -1,1241 +0,0 @@ -.\" $FreeBSD$ -.\" $OpenBSD: bc,v 1.9 2004/07/09 10:23:05 jmc Exp $ -.\" -.\" Copyright (C) Caldera International Inc. 2001-2002. -.\" All rights reserved. -.\" -.\" Redistribution and use in source and binary forms, with or without -.\" modification, are permitted provided that the following conditions -.\" are met: -.\" 1. Redistributions of source code and documentation must retain the above -.\" copyright notice, this list of conditions and the following disclaimer. -.\" 2. Redistributions in binary form must reproduce the above copyright -.\" notice, this list of conditions and the following disclaimer in the -.\" documentation and/or other materials provided with the distribution. -.\" 3. All advertising materials mentioning features or use of this software -.\" must display the following acknowledgement: -.\" This product includes software developed or owned by Caldera -.\" International, Inc. -.\" 4. Neither the name of Caldera International, Inc. nor the names of other -.\" contributors may be used to endorse or promote products derived from -.\" this software without specific prior written permission. -.\" -.\" USE OF THE SOFTWARE PROVIDED FOR UNDER THIS LICENSE BY CALDERA -.\" INTERNATIONAL, INC. AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR -.\" IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES -.\" OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. -.\" IN NO EVENT SHALL CALDERA INTERNATIONAL, INC. BE LIABLE FOR ANY DIRECT, -.\" INDIRECT INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -.\" (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -.\" SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) -.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, -.\" STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING -.\" IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE -.\" POSSIBILITY OF SUCH DAMAGE. -.\" -.\" @(#)bc 6.2 (Berkeley) 4/17/91 -.\" -.if n \{\ -.po 5n -.ll 70n -.\} -.EH 'USD:6-%''BC \- An Arbitrary Precision Desk-Calculator Language' -.OH 'BC \- An Arbitrary Precision Desk-Calculator Language''USD:6-%' -.\".RP -.TL -BC \- An Arbitrary Precision Desk-Calculator Language -.AU -Lorinda Cherry -.AU -Robert Morris -.AI -.\" .MH -.AB -BC is a language and a compiler for doing arbitrary precision arithmetic -on the PDP-11 under the -.UX -time-sharing -system. The output of the compiler is interpreted and executed by -a collection of routines which can input, output, and do -arithmetic on indefinitely large integers and on scaled fixed-point -numbers. -.PP -These routines are themselves based on a dynamic storage allocator. -Overflow does not occur until all available core storage -is exhausted. -.PP -The language has a complete control structure as well as immediate-mode -operation. Functions can be defined and saved for later execution. -.PP -Two five hundred-digit numbers can be multiplied to give a -thousand digit result in about ten seconds. -.PP -A small collection of library functions is also available, -including sin, cos, arctan, log, exponential, and Bessel functions of -integer order. -.PP -Some of the uses of this compiler are -.IP \- -to do computation with large integers, -.IP \- -to do computation accurate to many decimal places, -.IP \- -conversion of numbers from one base to another base. -.AE -.PP -.SH -Introduction -.PP -BC is a language and a compiler for doing arbitrary precision -arithmetic on the -.UX -time-sharing system [1]. -The compiler was written to make conveniently available a -collection of routines (called DC [5]) which are capable of doing -arithmetic on integers of arbitrary size. The compiler -is by no means intended to provide a complete programming -language. -It is a minimal language facility. -.PP -There is a scaling provision that permits the -use of decimal point notation. -Provision is made for input and output in bases other than -decimal. Numbers can be converted from decimal to octal by -simply setting the output base to equal 8. -.PP -The actual limit on the number of digits that can -be handled depends on the amount of storage available on the machine. -Manipulation of numbers with many hundreds of digits -is possible even on the smallest versions of -.UX . -.PP -The syntax of BC has been deliberately selected to agree -substantially with the C language [2]. Those who -are familiar with C will find few surprises in this language. -.SH -Simple Computations with Integers -.PP -The simplest kind of statement is an arithmetic expression -on a line by itself. -For instance, if you type in the line: -.DS -.ft B -142857 + 285714 -.ft P -.DE -the program responds immediately with the line -.DS -.ft B -428571 -.ft P -.DE -The operators \-, *, /, %, and ^ can also be used; they -indicate subtraction, multiplication, division, remaindering, and -exponentiation, respectively. Division of integers produces an -integer result truncated toward zero. -Division by zero produces an error -comment. -.PP -Any term in an expression may be prefixed by a minus sign to -indicate that it is to be negated (the `unary' minus sign). -The expression -.DS -.ft B -7+\-3 -.ft P -.DE -is interpreted to mean that \-3 is to be added to 7. -.PP -More complex expressions with several operators and with -parentheses are interpreted just as in -Fortran, with ^ having the greatest binding -power, then * and % and /, and finally + and \-. -Contents of parentheses are evaluated before material -outside the parentheses. -Exponentiations are -performed from right to left and the other operators -from left to right. -The two expressions -.DS -.ft B -a^b^c and a^(b^c) -.ft P -.DE -are equivalent, as are the two expressions -.DS -.ft B -a*b*c and (a*b)*c -.ft P -.DE -BC shares with Fortran and C the undesirable convention that -.DS -\fBa/b*c\fP is equivalent to \fB(a/b)*c\fP -.ft P -.DE -.PP -Internal storage registers to hold numbers have single lower-case -letter names. The value of an expression can be assigned to -a register in the usual way. The statement -.DS -.ft B -x = x + 3 -.ft P -.DE -has the effect of increasing by three the value of the contents of the -register named x. -When, as in this case, the outermost operator is an =, the -assignment is performed but the result is not printed. -Only 26 of these named storage registers are available. -.PP -There is a built-in square root function whose -result is truncated to an integer (but see scaling below). -The lines -.DS -.ft B -x = sqrt(191) -x -.ft P -.DE -produce the printed result -.DS -.ft B -13 -.ft P -.DE -.SH -Bases -.PP -There are special internal quantities, called `ibase' and `obase'. -The contents of `ibase', initially set to 10, -determines the base used for interpreting numbers read in. -For example, the lines -.DS -.ft B -ibase = 8 -11 -.ft P -.DE -will produce the output line -.DS -.ft B -9 -.ft P -.DE -and you are all set up to do octal to decimal conversions. -Beware, however of trying to change the input base back -to decimal by typing -.DS -.ft B -ibase = 10 -.ft P -.DE -Because the number 10 is interpreted as octal, this statement will -have no effect. -For those who deal in hexadecimal notation, -the characters A\-F are permitted in numbers -(no matter what base is in effect) -and are -interpreted as digits having values 10\-15 respectively. -The statement -.DS -.ft B -ibase = A -.ft P -.DE -will change you back to decimal input base no matter what the -current input base is. -Negative and large positive input bases are -permitted but useless. -No mechanism has been provided for the input of arbitrary -numbers in bases less than 1 and greater than 16. -.PP -The contents of `obase', initially set to 10, are used as the base for output -numbers. The lines -.DS -.ft B -obase = 16 -1000 -.ft P -.DE -will produce the output line -.DS -.ft B -3E8 -.ft P -.DE -which is to be interpreted as a 3-digit hexadecimal number. -Very large output bases are permitted, and they are sometimes useful. -For example, large numbers can be output in groups of five digits -by setting `obase' to 100000. -Strange (i.e. 1, 0, or negative) output bases are -handled appropriately. -.PP -Very large numbers are split across lines with 70 characters per line. -Lines which are continued end with \\. -Decimal output conversion is practically instantaneous, but output -of very large numbers (i.e., more than 100 digits) with other bases -is rather slow. -Non-decimal output conversion of -a one hundred digit number takes about -three seconds. -.PP -It is best to remember that `ibase' and `obase' have no effect -whatever on the course of internal computation or -on the evaluation of expressions, but only affect input and -output conversion, respectively. -.SH -Scaling -.PP -A third special internal quantity called `scale' is -used to determine the scale of calculated -quantities. -Numbers may have -up to a specific number of decimal digits after the decimal point. -This fractional part is retained in further computations. -We refer to the number of digits after the decimal point of -a number as its scale. -The current implementation allows scales to be as large as can be -represented by a 32-bit unsigned number minus one. -This is a non-portable extension. -The original implementation allowed for a maximum scale of 99. -.PP -When two scaled numbers are combined by -means of one of the arithmetic operations, the result -has a scale determined by the following rules. For -addition and subtraction, the scale of the result is the larger -of the scales of the two operands. In this case, -there is never any truncation of the result. -For multiplications, the scale of the result is never -less than the maximum of the two scales of the operands, -never more than the sum of the scales of the operands -and, subject to those two restrictions, -the scale of the result is set equal to the contents of the internal -quantity `scale'. -The scale of a quotient is the contents of the internal -quantity `scale'. The scale of a remainder is -the sum of the scales of the quotient and the divisor. -The result of an exponentiation is scaled as if -the implied multiplications were performed. -An exponent must be an integer. -The scale of a square root is set to the maximum of the scale -of the argument and the contents of `scale'. -.PP -All of the internal operations are actually carried out in terms -of integers, with digits being discarded when necessary. -In every case where digits are discarded, truncation and -not rounding is performed. -.PP -The contents of -`scale' must be no greater than -4294967294 and no less than 0. It is initially set to 0. -.PP -The internal quantities `scale', `ibase', and `obase' can be -used in expressions just like other variables. -The line -.DS -.ft B -scale = scale + 1 -.ft P -.DE -increases the value of `scale' by one, and the line -.DS -.ft B -scale -.ft P -.DE -causes the current value of `scale' to be printed. -.PP -The value of `scale' retains its meaning as a -number of decimal digits to be retained in internal -computation even when `ibase' or `obase' are not equal to 10. -The internal computations (which are still conducted in decimal, -regardless of the bases) are performed to the specified number -of decimal digits, never hexadecimal or octal or any -other kind of digits. -.SH -Functions -.PP -The name of a function is a single lower-case letter. -Function names are permitted to collide with simple -variable names. -Twenty-six different defined functions are permitted -in addition to the twenty-six variable names. -The line -.DS -.ft B - define a(x){ -.ft P -.DE -begins the definition of a function with one argument. -This line must be followed by one or more statements, -which make up the body of the function, ending -with a right brace }. -Return of control from a function occurs when a return -statement is executed or when the end of the function is reached. -The return statement can take either -of the two forms -.DS -.ft B -return -return(x) -.ft P -.DE -In the first case, the value of the function is 0, and in -the second, the value of the expression in parentheses. -.PP -Variables used in the function can be declared as automatic -by a statement of the form -.DS -.ft B -auto x,y,z -.ft P -.DE -There can be only one `auto' statement in a function and it must -be the first statement in the definition. -These automatic variables are allocated space and initialized -to zero on entry to the function and thrown away on return. The -values of any variables with the same names outside the function -are not disturbed. -Functions may be called recursively and the automatic variables -at each level of call are protected. -The parameters named in a function definition are treated in -the same way as the automatic variables of that function -with the single exception that they are given a value -on entry to the function. -An example of a function definition is -.DS -.ft B - define a(x,y){ - auto z - z = x*y - return(z) - } -.ft P -.DE -The value of this function, when called, will be the -product of its -two arguments. -.PP -A function is called by the appearance of its name -followed by a string of arguments enclosed in -parentheses and separated by commas. -The result -is unpredictable if the wrong number of arguments is used. -.PP -Functions with no arguments are defined and called using -parentheses with nothing between them: b(). -.PP -If the function -.ft I -a -.ft -above has been defined, then the line -.DS -.ft B -a(7,3.14) -.ft P -.DE -would cause the result 21.98 to be printed and the line -.DS -.ft B -x = a(a(3,4),5) -.ft P -.DE -would cause the value of x to become 60. -.SH -Subscripted Variables -.PP -A single lower-case letter variable name -followed by an expression in brackets is called a subscripted -variable (an array element). -The variable name is called the array name and the expression -in brackets is called the subscript. -Only one-dimensional arrays are -permitted. The names of arrays are permitted to -collide with the names of simple variables and function names. -Any fractional -part of a subscript is discarded before use. -Subscripts must be greater than or equal to zero and -less than or equal to 2047. -.PP -Subscripted variables may be freely used in expressions, in -function calls, and in return statements. -.PP -An array name may be used as an argument to a function, -or may be declared as automatic in -a function definition by the use of empty brackets: -.DS -.ft B -f(a[\|]) -define f(a[\|]) -auto a[\|] -.ft P -.DE -When an array name is so used, the whole contents of the array -are copied for the use of the function, and thrown away on exit -from the function. -Array names which refer to whole arrays cannot be used -in any other contexts. -.SH -Control Statements -.PP -The `if', the `while', and the `for' statements -may be used to alter the flow within programs or to cause iteration. -The range of each of them is a statement or -a compound statement consisting of a collection of -statements enclosed in braces. -They are written in the following way -.DS -.ft B -if(relation) statement -if(relation) statement else statement -while(relation) statement -for(expression1; relation; expression2) statement -.ft P -.DE -or -.DS -.ft B -if(relation) {statements} -if(relation) {statements} else {statements} -while(relation) {statements} -for(expression1; relation; expression2) {statements} -.ft P -.DE -.PP -A relation in one of the control statements is an expression of the form -.DS -.ft B -x>y -.ft P -.DE -where two expressions are related by one of the six relational -operators `<', `>', `<=', `>=', `==', or `!='. -The relation `==' -stands for `equal to' and `!=' stands for `not equal to'. -The meaning of the remaining relational operators is -clear. -.PP -BEWARE of using `=' instead of `==' in a relational. Unfortunately, -both of them are legal, so you will not get a diagnostic -message, but `=' really will not do a comparison. -.PP -The `if' statement causes execution of its range -if and only if the relation is true. -Then control passes to the next statement in sequence. -If an `else' branch is present, the statements in this branch are -executed if the relation is false. -The `else' keyword is a non-portable extension. -.PP -The `while' statement causes execution of its range -repeatedly as long as the relation -is true. The relation is tested before each execution -of its range and if the relation -is false, control passes to the next statement beyond the range -of the while. -.PP -The `for' statement begins -by executing `expression1'. Then the relation is tested -and, if true, the statements in the range of the `for' are executed. -Then `expression2' is executed. The relation is tested, and so on. -The typical use of the `for' statement is for a controlled iteration, -as in the statement -.DS -.ft B -for(i=1; i<=10; i=i+1) i -.ft P -.DE -which will print the integers from 1 to 10. -Here are some examples of the use of the control statements. -.DS -.ft B -define f(n){ -auto i, x -x=1 -for(i=1; i<=n; i=i+1) x=x*i -return(x) -} -.ft P -.DE -The line -.DS -.ft B - f(a) -.ft P -.DE -will print -.ft I -a -.ft -factorial if -.ft I -a -.ft -is a positive integer. -Here is the definition of a function which will -compute values of the binomial coefficient -(m and n are assumed to be positive integers). -.DS -.ft B -define b(n,m){ -auto x, j -x=1 -for(j=1; j<=m; j=j+1) x=x*(n\-j+1)/j -return(x) -} -.ft P -.DE -The following function computes values of the exponential function -by summing the appropriate series -without regard for possible truncation errors: -.DS -.ft B -scale = 20 -define e(x){ - auto a, b, c, d, n - a = 1 - b = 1 - c = 1 - d = 0 - n = 1 - while(1==1){ - a = a*x - b = b*n - c = c + a/b - n = n + 1 - if(c==d) return(c) - d = c - } -} -.ft P -.DE -.SH -Some Details -.PP -There are some language features that every user should know -about even if he will not use them. -.PP -Normally statements are typed one to a line. It is also permissible -to type several statements on a line separated by semicolons. -.PP -If an assignment statement is parenthesized, it then has -a value and it can be used anywhere that an expression can. -For example, the line -.DS -.ft B -(x=y+17) -.ft P -.DE -not only makes the indicated assignment, but also prints the -resulting value. -.PP -Here is an example of a use of the value of an -assignment statement even when it is not parenthesized. -.DS -.ft B -x = a[i=i+1] -.ft P -.DE -causes a value to be assigned to x and also increments i -before it is used as a subscript. -.PP -The following constructs work in BC in exactly the same manner -as they do in the C language. Consult the appendix or the -C manuals [2] for their exact workings. -.DS -.ft B -.ta 2i -x=y=z is the same as x=(y=z) -x += y x = x+y -x \-= y x = x\-y -x *= y x = x*y -x /= y x = x/y -x %= y x = x%y -x ^= y x = x^y -x++ (x=x+1)\-1 -x\-\- (x=x\-1)+1 -++x x = x+1 -\-\-x x = x\-1 -.ft P -.DE -Even if you don't intend to use the constructs, -if you type one inadvertently, something correct but unexpected -may happen. -.SH -Three Important Things -.PP -1. To exit a BC program, type `quit'. -.PP -2. There is a comment convention identical to that of C and -of PL/I. Comments begin with `/*' and end with `*/'. -As a non-portable extension, comments may also start with a `#' and end with -a newline. -The newline is not part of the comment. -.PP -3. There is a library of math functions which may be obtained by -typing at command level -.DS -.ft B -bc \-l -.ft P -.DE -This command will load a set of library functions -which, at the time of writing, consists of sine (named `s'), -cosine (`c'), arctangent (`a'), natural logarithm (`l'), -exponential (`e') and Bessel functions of integer order (`j(n,x)'). Doubtless more functions will be added -in time. -The library sets the scale to 20. You can reset it to something -else if you like. -The design of these mathematical library routines -is discussed elsewhere [3]. -.PP -If you type -.DS -.ft B -bc file ... -.ft P -.DE -BC will read and execute the named file or files before accepting -commands from the keyboard. In this way, you may load your -favorite programs and function definitions. -.SH -Acknowledgement -.PP -The compiler is written in YACC [4]; its original -version was written by S. C. Johnson. -.SH -References -.IP [1] -K. Thompson and D. M. Ritchie, -.ft I -UNIX Programmer's Manual, -.ft -Bell Laboratories, -1978. -.IP [2] -B. W. Kernighan and -D. M. Ritchie, -.ft I -The C Programming Language, -.ft -Prentice-Hall, 1978. -.IP [3] -R. Morris, -.ft I -A Library of Reference Standard Mathematical Subroutines, -.ft -Bell Laboratories internal memorandum, 1975. -.IP [4] -S. C. Johnson, -.ft I -YACC \(em Yet Another Compiler-Compiler. -.ft -Bell Laboratories Computing Science Technical Report #32, 1978. -.IP [5] -R. Morris and L. L. Cherry, -.ft I -DC \- An Interactive Desk Calculator. -.ft -.LP -.bp -.ft B -.DS C -Appendix -.DE -.ft -.NH -Notation -.PP -In the following pages syntactic categories are in \fIitalics\fP; -literals are in \fBbold\fP; material in brackets [\|] is optional. -.NH -Tokens -.PP -Tokens consist of keywords, identifiers, constants, operators, -and separators. -Token separators may be blanks, tabs or comments. -Newline characters or semicolons separate statements. -.NH 2 -Comments -.PP -Comments are introduced by the characters /* and terminated by -*/. -As a non-portable extension, comments may also start with a # and -end with a newline. -The newline is not part of the comment. -.NH 2 -Identifiers -.PP -There are three kinds of identifiers \- ordinary identifiers, array identifiers -and function identifiers. -All three types consist of single lower-case letters. -Array identifiers are followed by square brackets, possibly -enclosing an expression describing a subscript. -Arrays are singly dimensioned and may contain up to 2048 -elements. -Indexing begins at zero so an array may be indexed from 0 to 2047. -Subscripts are truncated to integers. -Function identifiers are followed by parentheses, possibly enclosing arguments. -The three types of identifiers do not conflict; -a program can have a variable named \fBx\fP, -an array named \fBx\fP and a function named \fBx\fP, all of which are separate and -distinct. -.NH 2 -Keywords -.PP -The following are reserved keywords: -.ft B -.ta .5i 1.0i -.nf - ibase if - obase break - scale define - sqrt auto - length return - while quit - for continue - else last - print -.fi -.ft -.NH 2 -Constants -.PP -Constants consist of arbitrarily long numbers -with an optional decimal point. -The hexadecimal digits \fBA\fP\-\fBF\fP are also recognized as digits with -values 10\-15, respectively. -.NH 1 -Expressions -.PP -The value of an expression is printed unless the main -operator is an assignment. -The value printed is assigned to the special variable \fBlast\fP. -A single dot may be used as a synonym for \fBlast\fP. -This is a non-portable extension. -Precedence is the same as the order -of presentation here, with highest appearing first. -Left or right associativity, where applicable, is -discussed with each operator. -.bp -.NH 2 -Primitive expressions -.NH 3 -Named expressions -.PP -Named expressions are -places where values are stored. -Simply stated, -named expressions are legal on the left -side of an assignment. -The value of a named expression is the value stored in the place named. -.NH 4 -\fIidentifiers\fR -.PP -Simple identifiers are named expressions. -They have an initial value of zero. -.NH 4 -\fIarray-name\fP\|[\|\fIexpression\fP\|] -.PP -Array elements are named expressions. -They have an initial value of zero. -.NH 4 -\fBscale\fR, \fBibase\fR and \fBobase\fR -.PP -The internal registers -\fBscale\fP, \fBibase\fP and \fBobase\fP are all named expressions. -\fBscale\fP is the number of digits after the decimal point to be -retained in arithmetic operations. -\fBscale\fR has an initial value of zero. -\fBibase\fP and \fBobase\fP are the input and output number -radix respectively. -Both \fBibase\fR and \fBobase\fR have initial values of 10. -.NH 3 -Function calls -.NH 4 -\fIfunction-name\fB\|(\fR[\fIexpression\fR\|[\fB,\|\fIexpression\|\fR.\|.\|.\|]\|]\fB) -.PP -A function call consists of a function name followed by parentheses -containing a comma-separated list of -expressions, which are the function arguments. -A whole array passed as an argument is specified by the -array name followed by empty square brackets. -All function arguments are passed by -value. -As a result, changes made to the formal parameters have -no effect on the actual arguments. -If the function terminates by executing a return -statement, the value of the function is -the value of the expression in the parentheses of the return -statement or is zero if no expression is provided -or if there is no return statement. -.NH 4 -sqrt\|(\|\fIexpression\fP\|) -.PP -The result is the square root of the expression. -The result is truncated in the least significant decimal place. -The scale of the result is -the scale of the expression or the -value of -.ft B -scale, -.ft -whichever is larger. -.NH 4 -length\|(\|\fIexpression\fP\|) -.PP -The result is the total number of significant decimal digits in the expression. -The scale of the result is zero. -.NH 4 -scale\|(\|\fIexpression\fP\|) -.PP -The result is the scale of the expression. -The scale of the result is zero. -.NH 3 -Constants -.PP -Constants are primitive expressions. -.NH 3 -Parentheses -.PP -An expression surrounded by parentheses is -a primitive expression. -The parentheses are used to alter the -normal precedence. -.NH 2 -Unary operators -.PP -The unary operators -bind right to left. -.NH 3 -\-\|\fIexpression\fP -.PP -The result is the negative of the expression. -.NH 3 -++\|\fInamed-expression\fP -.PP -The named expression is -incremented by one. -The result is the value of the named expression after -incrementing. -.NH 3 -\-\-\|\fInamed-expression\fP -.PP -The named expression is -decremented by one. -The result is the value of the named expression after -decrementing. -.NH 3 -\fInamed-expression\fP\|++ -.PP -The named expression is -incremented by one. -The result is the value of the named expression before -incrementing. -.NH 3 -\fInamed-expression\fP\|\-\- -.PP -The named expression is -decremented by one. -The result is the value of the named expression before -decrementing. -.NH 2 -Exponentiation operator -.PP -The exponentiation operator binds right to left. -.NH 3 -\fIexpression\fP ^ \fIexpression\fP -.PP -The result is the first -expression raised to the power of the -second expression. -The second expression must be an integer. -If \fIa\fP -is the scale of the left expression -and \fIb\fP is the absolute value -of the right expression, -then the scale of the result is: -.PP -min\|(\|\fIa\(mub\fP,\|max\|(\|\fBscale\fP,\|\fIa\fP\|)\|) -.NH 2 -Multiplicative operators -.PP -The operators *, /, % bind left to right. -.NH 3 -\fIexpression\fP * \fIexpression\fP -.PP -The result is the product -of the two expressions. -If \fIa\fP and \fIb\fP are the -scales of the two expressions, -then the scale of the result is: -.PP -min\|(\|\fIa+b\fP,\|max\|(\|\fBscale\fP,\|\fIa\fP,\|\fIb\fP\|)\|) -.NH 3 -\fIexpression\fP / \fIexpression\fP -.PP -The result is the quotient of the two expressions. -The scale of the result is the value of \fBscale\fR. -.NH 3 -\fIexpression\fP % \fIexpression\fP -.PP -The % operator produces the remainder of the division -of the two expressions. -More precisely, -\fIa\fP%\fIb\fP is \fIa\fP\-\fIa\fP/\fIb\fP*\fIb\fP. -.PP -The scale of the result is the sum of the scale of -the divisor and the value of -.ft B -scale -.ft -.NH 2 -Additive operators -.PP -The additive operators bind left to right. -.NH 3 -\fIexpression\fP + \fIexpression\fP -.PP -The result is the sum of the two expressions. -The scale of the result is -the maximum of the scales of the expressions. -.NH 3 -\fIexpression\fP \- \fIexpression\fP -.PP -The result is the difference of the two expressions. -The scale of the result is the -maximum of the scales of the expressions. -.NH 2 -assignment operators -.PP -The assignment operators bind right to left. -.NH 3 -\fInamed-expression\fP = \fIexpression\fP -.PP -This expression results in assigning the value of the expression -on the right -to the named expression on the left. -.NH 3 -\fInamed-expression\fP += \fIexpression\fP -.NH 3 -\fInamed-expression\fP \-= \fIexpression\fP -.NH 3 -\fInamed-expression\fP *= \fIexpression\fP -.NH 3 -\fInamed-expression\fP /= \fIexpression\fP -.NH 3 -\fInamed-expression\fP %= \fIexpression\fP -.NH 3 -\fInamed-expression\fP ^= \fIexpression\fP -.PP -The result of the above expressions is equivalent -to ``named expression = named expression OP expression'', -where OP is the operator after the = sign. -.NH 1 -Relations -.PP -Unlike all other operators, the relational operators -are only valid as the object of an \fBif\fP, \fBwhile\fP, -or inside a \fBfor\fP statement. -.NH 2 -\fIexpression\fP < \fIexpression\fP -.NH 2 -\fIexpression\fP > \fIexpression\fP -.NH 2 -\fIexpression\fP <= \fIexpression\fP -.NH 2 -\fIexpression\fP >= \fIexpression\fP -.NH 2 -\fIexpression\fP == \fIexpression\fP -.NH 2 -\fIexpression\fP != \fIexpression\fP -.NH 1 -Storage classes -.PP -There are only two storage classes in BC, global and automatic -(local). -Only identifiers that are to be local to a function need be -declared with the \fBauto\fP command. -The arguments to a function -are local to the function. -All other identifiers are assumed to be global -and available to all functions. -All identifiers, global and local, have initial values -of zero. -Identifiers declared as \fBauto\fP are allocated on entry to the function -and released on returning from the function. -They therefore do not retain values between function calls. -\fBauto\fP arrays are specified by the array name followed by empty square brackets. -.PP -Automatic variables in BC do not work in exactly the same way -as in either C or PL/I. On entry to a function, the old values of -the names that appear as parameters and as automatic -variables are pushed onto a stack. -Until return is made from the function, reference to these -names refers only to the new values. -.NH 1 -Statements -.PP -Statements must be separated by semicolon or newline. -Except where altered by control statements, execution -is sequential. -.NH 2 -Expression statements -.PP -When a statement is an expression, unless -the main operator is an assignment, the value -of the expression is printed, followed by a newline character. -.NH 2 -Compound statements -.PP -Statements may be grouped together and used when one statement is expected -by surrounding them with { }. -.NH 2 -Quoted string statements -.PP -"any string" -.sp .5 -This statement prints the string inside the quotes. -.NH 2 -If statements -.sp .5 -\fBif\|(\|\fIrelation\fB\|)\|\fIstatement\fR -.PP -The substatement is executed if the relation is true. -.NH 2 -If-else statements -.sp .5 -\fBif\|(\|\fIrelation\fB\|)\|\fIstatement\fB\|else\|\fIstatement\fR -.PP -The first substatement is executed if the relation is true, the second -substatement if the relation is false. -The \fBif-else\fR statement is a non-portable extension. -.NH 2 -While statements -.sp .5 -\fBwhile\|(\|\fIrelation\fB\|)\|\fIstatement\fR -.PP -The statement is executed while the relation -is true. -The test occurs before each execution of the statement. -.NH 2 -For statements -.sp .5 -\fBfor\|(\|\fIexpression\fB; \fIrelation\fB; \fIexpression\fB\|)\|\fIstatement\fR -.PP -The \fBfor\fR statement is the same as -.nf -.ft I - first-expression - \fBwhile\|(\fPrelation\|\fB) {\fP - statement - last-expression - } -.ft R -.fi -.PP -All three expressions may be left out. -This is a non-portable extension. -.NH 2 -Break statements -.sp .5 -\fBbreak\fP -.PP -\fBbreak\fP causes termination of a \fBfor\fP or \fBwhile\fP statement. -.NH 2 -Continue statements -.sp .5 -\fBcontinue\fP -.PP -\fBcontinue\fP causes the next iteration of a \fBfor\fP or \fBwhile\fP -statement to start, skipping the remainder of the loop. -For a \fBwhile\fP statement, execution continues with the evaluation -of the condition. -For a \fBfor\fP statement, execution continues with evaluation of -the last-expression. -The \fBcontinue\fP statement is a non-portable extension. -.NH 2 -Auto statements -.sp .5 -\fBauto \fIidentifier\fR\|[\|\fB,\fIidentifier\fR\|] -.PP -The \fBauto\fR statement causes the values of the identifiers to be pushed down. -The identifiers can be ordinary identifiers or array identifiers. -Array identifiers are specified by following the array name by empty square -brackets. -The auto statement must be the first statement -in a function definition. -.NH 2 -Define statements -.sp .5 -.nf -\fBdefine(\|\fR[\fIparameter\|\fR[\fB\|,\|\fIparameter\|.\|.\|.\|\fR]\|]\|\fB)\|{\fI - statements\|\fB}\fR -.fi -.PP -The \fBdefine\fR statement defines a function. -The parameters may -be ordinary identifiers or array names. -Array names must be followed by empty square brackets. -As a non-portable extension, the opening brace may also appear on the -next line. -.NH 2 -Return statements -.sp .5 -\fBreturn\fP -.sp .5 -\fBreturn(\fI\|expression\|\fB)\fR -.PP -The \fBreturn\fR statement causes termination of a function, -popping of its auto variables, and -specifies the result of the function. -The first form is equivalent to \fBreturn(0)\fR. -The result of the function is the result of the expression -in parentheses. -Leaving out the expression between parentheses is equivalent to -\fBreturn(0)\fR. -As a non-portable extension, the parentheses may be left out. -.NH 2 -Print -.PP -The \fBprint\fR statement takes a list of comma-separated expressions. -Each expression in the list is evaluated and the computed -value is printed and assigned to the variable `last'. -No trailing newline is printed. -The expression may also be a string enclosed in double quotes. -Within these strings the following escape sequences may be used: -\ea -for bell (alert), -`\eb' -for backspace, -`\ef' -for formfeed, -`\en' -for newline, -`\er' -for carriage return, -`\et' -`for tab, -`\eq' -for double quote and -`\e\e' -for backslash. -Any other character following a backslash will be ignored. -Strings will not be assigned to `last'. -The \fBprint\fR statement is a non-portable extension. -.NH 2 -Quit -.PP -The \fBquit\fR statement stops execution of a BC program and returns -control to UNIX when it is first encountered. -Because it is not treated as an executable statement, -it cannot be used -in a function definition or in an -.ft B -if, for, -.ft -or -.ft B -while -.ft -statement. |