OPZIONI¶

-h, --help

Stampa l'uso ed esce.

-i, --interactive

Forza la modalità interattiva.

-l, --mathlib

Definisce la libreria matematica standard.

-w, --warn

Emette un avvertimento per le estensioni a POSIX bc.

-s, --standard

Elabora esattamente il linguaggio bc POSIX.

-q, --quiet

Non stampa il consueto messaggio di benvenuto di GNU bc .

-v, --version

Stampa il numero di versione e il copyright ed esce.

NUMERI¶

L'elemento più essenziale in bc è il numero. I numeri sono numeri a precisione arbitraria. La precisione è sia negli interi sia nella parte frazionaria. Tutti i numeri sono rappresentati internamente in decimali e tutti i calcoli sono fatti in decimali. (Questa versione tronca i risultati delle operazioni di divisione e di moltiplicazione.). I numeri hanno due attributi, la lunghezza e la scala. La lunghezza è il numero totale di cifre decimali usate da bc per rappresentare un numero e la scala è il numero totale di cifre decimali dopo il punto decimale. Per esempio:

 .000001 ha lunghezza 6 e scala 6.


 1935.000 ha lunghezza 7 e scala 3.

VARIABILI¶

I numeri vengono memorizzati in due tipi di variabile, variabili semplici e array. Sia le variabili semplici sia le variabili array hanno un nome. I nomi iniziano con una lettera seguita da un numero qualsiasi di lettere, cifre e trattini bassi. Tutte le lettere devono essere in minuscolo. (I nomi alfanumerici completi sono estensioni. In POSIX bc tutti i nomi sono composti da una sola lettera minuscola.) Il tipo di variabile è definito dal contesto perché tutti i nomi di variabile array sono seguiti da parentesi quadre ([]).

Ci sono quattro variabili speciali, scale, ibase, obase, e last. scale definisce come certe operazioni usano le cifre dopo il punto decimale. Il valore predefinito di scale è 0. ibase e obasedifiniscono la base di conversione per i numeri in entrata e in uscita. Il valore predefinito per entrambi è base 10. last (un'estensione) è una variabile che ha il valore dell'ultimo numero stampato. Tutte queste varibili verranno trattate nel dettaglio quando ricorre il caso. Tutte queste variabili possono avere un valore assegnato, ma possono anche essere usate nelle espressioni.

COMMENTI¶

I commenti in bc iniziano coi caratteri /* e terminano coi caratteri */ I commenti possono partire da qualsiasi posizione e appaiono nell'input come uno spazio singolo. (Ciò fa sì che i commenti delimitino altri elementi di input. Per esempio, un commento non si può trovare in mezzo a un nome di variabile.) I commenti includono qualsiasi newline (fine riga) tra l'inizio e la fine del commento.

Per permettere l'uso di script per bc, come estensione sono stati aggiunti i commenti di una sola riga. Un commento di una sola riga inizia col carattere # e continua fino alla fine della riga. Il carattere di fine riga non fa parte del commento ed è elaborato nermalmente.

ESPRESSIONI¶

I numeri vengono manipolati da espressioni e da istruzioni. Poiché il linguaggio è stato progettato per essere interattivo, istruzioni ed espressioni vengono eseguiti il prima possibile. Non c'è nessun programma "principale". Invece, il codice viene eseguito così come è stato rilevato. (Le funzioni, trattate nel dettaglio più avanti, vengono definite quando vengono rilevate.)

Un'espressione semplice è semplicemente una costante. bc converte le costanti in numeri decimali interni usando la base corrente di input, specificata dalla variabile ibase (c'è un'eccezione nelle funzioni). I valori ammessi di ibase sono da 2 a 36 (le basi maggiori di 16 sono un'estensione). Assegnando a ibase un valore al di fuori di questo intervallo si otterrà un valore di 2 o di 36. I numeri in uscita possono contenere i caratteri 0–9 e A–Z (nota: devono essere in maiuscolo; lettere in minuscolo sono nomi di variabile.) I numeri a una sola cifra hanno il valore della cifra a prescindere dal valore di ibase (cioè A = 10.) Per numeri a più cifre, bc cambia tutte le cifre maggiori o uguali a ibase al valore di ibase-1. Questo fa sì che il numero ZZZ sia sempre il numero di 3 cifre della base in entrata più alto.

Le espressioni complete sono simili a molti altri linguaggi di alto livello. Poiché c'è un solo tipo di numero, non ci sono regole per mischiare i tipi. Invece, ci sono regole sulla scala delle espressioni. Ogni espressone ha una scala. Qusto è derivato dalla scala dei numeri originali, dall'operazione effettuata e, in molti casi, dal valore della variabile scale. Valori validi per la variabile scale sono da 0 al numero massimo rappresentabile da un intero in C.

Nelle seguenti descrizioni di espressioni valide, "expr" s riferisce a una espressione completa e "var" si riferisce a una variabile semplice o a una variabile array. Una variabile semplice è semplicemente un

- expr

Il risultato è la negazione dell'espressione.

++ var

La variabile è incrementata di uno e il nuovo valore è il risultato dell'espressione.

-- var

La variabile è decrementata di uno e il nuovo valore è il risultato dell'espressione.

var ++

Il risultato dell'espressione è il valore della variabile, e poi la variabile è incrementata di uno.

var --

Il risultato dell'espressione è il valore della variabile, e poi la variabile è decrementata di uno.

expr + expr

Il risultato dell'espressione è la somma di due espressioni.

expr - expr

Il risultato dell'espressione è la differenza tra due espressioni.

expr * expr

Il risultato dell'espressione è il prodotto delle due espressioni.

expr / expr

Il risultato dell'espressione è il quoziente di due espressioni. La scala del risultato è il valore della variabile scale.

expr % expr

Il risultato dell'espressione è il "resto" ed è calcolato nel seguente modo. Per calcolare a%b, prima viene calcolato a/b alle cifre di scale. Il risultato è usato per calcolare a-(a/b)*b alla scala del massimo di scale+scale(b) e scale(a). Se scale è impostato a zero ed entambe le espressioni sono numeri interi questa espressione è la funzione degli interi residui.

expr ^ expr

Il risultato dell'espressione è il valore della prima elevato alla seconda. La seconda espressione dev'essere un intero (se la seconda espressione non è un intero, viene generato un avviso e l'espressione viene troncata per ottenere un valore intero). La scala del risultato è scale se l'esponente è negativo. Se l'esponente è positivo la scala del risultato è il minimo tra: la scala della prima espressione per l'esponente e il valore massimo tra scale) e la scala della prima espressione. (p.es scale(a^b) = min(scale(a)*b, max( scale, scale(a))).) Si deve tener conto che expr^0 restituisce sempre il valore 1.

( expr )

Altera la precedenza standard per forzare la valutazione dell'espressione.

var = expr

Alla variabile è assegnato il valore dell'espressione.

var <op>= expr

È equivalente a "var = var <op> expr" con l'eccezione che la parte "var" è valutata solo una volta. Ciò può fare la differenza se "var" è un array.

Le espressioni relazionali sono un tipo speciale di espressione che vengono sempre valutate a 0 o a 1, 0 se la relazione è falsa e 1 se la relazione è vera. Possono apparire in ogni espressione valida. (POSIX bc richiede che le espressioni relazionali siano usate solo nelle istruzioni if, while e for, e che un solo test relazionale possa essere fatto in ognuna di esse.) Gli operatori relazionali sono

expr1 < expr2

Il risultato è 1 se expr1 è rigorosamente minore di expr2.

expr1 <= expr2

Il risultato è 1 se expr1 è minore o uguale a expr2.

expr1 > expr2

Il risultato è 1 se expr1 è rigorosamente maggiore di expr2.

expr1 >= expr2

Il risultato è 1 se expr1 è maggiore o uguale a expr2.

expr1 == expr2

Il risultato è 1 se expr1 è uguale a expr2.

expr1 != expr2

Il risultato è 1 se expr1 non è uguale a expr2.

Sono valide anche le operazioni booleane (POSIX bc non ha operazioni booleane). Il risultato di tutte le operazioni booleane è 0 e 1 (per falso e vero) come nelle espressioni relazionali. Gli operatori booleani sono:

!expr

Il risultato è 1 se expr è 0.

expr && expr

Il risultato è 1 se entrambe le espressioni sono diverse da zero.

expr || expr

Il risultato è 1 se una delle espressioni è diversa da zero.

La precedenza nelle espressioni è la seguente: (dalla più bassa alla più alta)

Operatore ||, associativo a sinistra
Operatore &&, associativo a sinistra
Operatore !, non associativo
Operatori relazionale, associativi a sinistra
Operatore di assegnamento, associativo a destra
Operatori + e -, associativi a sinistra
Operatori *, / e %, associativi a sinistra
Operatore ^, associativo a destra
Operatore unario -, non associativo
Operatori ++ e -- , non associativi

Questa precedenza è stata scelta per fare in modo che i programmi bc conformi a POSIX vengano eseguiti correttamente. Questo fa in modo che gli operatori relazionali e logici abbiano un comportamento inusuale quando sono usati con espressioni di assegnamento. Si consideri l'espressione:

Molti programmatori C presumono che questo assegni il risultato di "3 < 5" (il valore 1) alla variabile "a". Quel che fa bc è assegnare il valore 3 alla variabile "a" e poi confrontare 3 con 5. È meglio usare le parentesi quando si usano operatori relazionali e logici con gli operatori di assegnamento.

Ci sono alcune altre espressioni speciali che sono fornite da bc. Queste hanno a che fare con funzioni definite dall'utente e funzioni standard; sono nella forma "nome(parametri)". Per le funzione definite dall'utente si veda la sezione dedicata alle funzioni. Le funzioni standard sono:

length ( espressione )

Il valore della funzione scale è il numero di cifre dopo il punto decimale nell'espressione.

read ( )

La funzione read (un'estensione) legge un numero dallo standard input, indipendentemente dal punto dove appare la funzione. Bisogna fare attenzione, questo può causare problemi quando si mischiano dati e programma nello standard input. Il miglior uso di questa funzione è in un programma precedentemente scritto che necessita di input dall'utente. Il valore della funzione read è il numero letto dallo standard input usando io valore corrente della variabile base per la base di conversione.

scale ( espressione )

Il valore della funzione scale è il numero di cifre dopo il punto decimale nell'espressione.

sqrt ( espressione )

Il valore della funzione sqrt è la radice quadrata dell'espressione. Se l'espressione è negativa, viene generato un errore di esecuzione (runtime).

ISTRUZIONI¶

Le istruzioni (come nella maggior parte dei linguaggi algebrici) forniscono la valutazione di espressioni in sequenza. In bc le istruzioni vengono eseguite "il più presto possibile". L'esecuzione avviene quando viene trovato una separatore di riga (newline) e ci sono una o più istruzioni complete. Proprio per la sua immediata esecuzione, i newline sono molto importanti in bc. Infatti, sia il punto e virgola sia il newline vengono usati come separatori di istruzioni . Un newline messo in un punto impropriamente causerà un errore di sintassi. Poiché i newline sono separatori di istruzioni, è possibile nascondere un newline usando il carattere di barra inversa. La sequenza "\<nl>", dove <nl> è il newline, appare a bc come uno spazio bianco invece che un newline. Una lista di istruzioni è una serie di istruzioni separate da punti e virgola e newline. Quel che segue è una lista di istruzioni bc con la descrizione di quello che fanno: (Quel che è racchiuso tra parentesi quadre ([]) sono parti opzionali dell'istruzione.)

espressione

Questa istruzione fa una o due cose. Se l'espressione inizia con "<variabile> <assegnamento> ...", è considerata un'istruzione di assegnamento. Se l'espressione non è un'istruzione di assegnamento, l'espressione viene valutata e stampata nell'ouput. Dopo che il numero è stato stampato, viene stampato un codice di fine riga (newline). Per esempio, "a=1" è un assegnamento di variabile e "(a=1)" è un'espressione che ha un assegnamento al suo interno. Tutti i numeri che vengono stampati sono stampati nella base specificata dalla variabile obase. I valori ammessi per obase sono da 2 a BC_BASE_MAX (si veda la sezione LIMITI). Per basi da 2 a 16, è usato il metodo abituale di scrivere i numeri. Per basi maggiori di 16, bc usa un metodo che utilizza cifre multicarattere per stampare i numeri dove ogni cifra di una base superiore è stampata come un numero a base 10. Le cifre multicarattere sono separate da spazi. Ogni cifra continene il numero di caratteri richiesti per rappresentare il valore in base dieci di "obase-1". Poiché i numeri sono a precisione arbitraria, alcuni numeri possono non essere stampabili su un sola riga. Questi numeri lunghi verranno suddivisi su più righe usando "\" come ultimo carattere della riga. Il numero massimo di caratteri stampati per riga è 70. Per la natura interattiva di bc, stampare un numero comporta l'effetto collaterale di assegnare il valore stampato alla variabile speciale last. Ciò consente all'utente di recuperare l'ultimo valore stampato senza dover riscrivere l'espressione che ha generato il numero stampato. L'assegnamentoao last è ammesso e sovrascrive l'ultimo valore stampato con il valore assegnato. Il nuovo valore assegnato rimane fino a quando viene stampato il prossimo numero o viene assegnato un altro valore a last . (Alcune installazioni possonoconsentire l'uso di un punto (.) non facente parte di un numero come forma abbreviata di last.)

stringa

La stringa è stampata nell'output. Le stringhe iniziano con un carattere di doppi apici e contengono tutti i caratteri fino al successivo carattere di doppi apici. Tutti i caratteri sono presi letteralmente, inclusi i newline. Dopo la stringa non viene stampato nessun newline.

print lista

The print statement (an extension) provides another method of output. The "list" is a list of strings and expressions separated by commas. Each string or expression is printed in the order of the list. No terminating newline is printed. Expressions are evaluated and their value is printed and assigned to the variable last. Strings in the print statement are printed to the output and may contain special characters. Special characters start with the backslash character (\). The special characters recognized by bc are "a" (alert or bell), "b" (backspace), "f" (form feed), "n" (newline), "r" (carriage return), "q" (double quote), "t" (tab), and "\" (backslash). Any other character following the backslash will be ignored.

{ lista_istruzioni }

Questa è un'istruzione composta. Consente di raggruppare più istruzioni per essere eseguite.

if ( espressione ) istruzione1 [else istruzione2]

L'istruzione if valuta l'espressione ed esegue istruzione1 o istruzione2 a seconda del valore dell'espressione. Se l'espressione è diversa da zero, viene eseguita istruzione1. Se istruzione2 è presente e il valore dell'espressione è 0, viene eseguita istruzione2. (La clausola else è un'estensione.)

while ( espressione ) istruzione

The while statement will execute the statement while the expression is non-zero. It evaluates the expression before each execution of the statement. Termination of the loop is caused by a zero expression value or the execution of a break statement.

for ( [espressione1] ; [espressione2] ; [espressione3] ) istruzione

The for statement controls repeated execution of the statement. Expression1 is evaluated before the loop. Expression2 is evaluated before each execution of the statement. If it is non-zero, the statement is evaluated. If it is zero, the loop is terminated. After each execution of the statement, expression3 is evaluated before the reevaluation of expression2. If expression1 or expression3 are missing, nothing is evaluated at the point they would be evaluated. If expression2 is missing, it is the same as substituting the value 1 for expression2. (The optional expressions are an extension. POSIX bc requires all three expressions.) The following is equivalent code for the for statement:

expression1;
while (expression2) {


   statement;


   expression3;
}

break

This statement causes a forced exit of the most recent enclosing while statement or for statement.

continue

L'istruzione continue (un'estensione) fa sì che l'istruzione for inglobata più recente inizi la successiva iterazione.

halt

The halt statement (an extension) is an executed statement that causes the bc processor to quit only when it is executed. For example, "if (0 == 1) halt" will not cause bc to terminate because the halt is not executed.

return

Restituisce il valore 0 da una funzione. (Si veda la sezione sulle funzioni.)

return ( espressione )

Restituisce il valore dell'espressione da una funzione. (Si veda la sezione sulle funzioni.) Come estensione, le parentesi non sono richieste.

PSEUDO ISTRUZIONI¶

Queste istruzioni non sono istruzioni nel senso tradizionale. Non sono istruzioni eseguite. La loro funzione viene eseguita al momento della "compilazione".

limits

Stampa i limiti locali imposti per la versione locale di bc. È un'estensione.

quit

Quando l'istruzione quit viene letta, il processore bc viene arrestato, indipendentemente da dove viene trovata l'istruzione quit. Per esempio, "if (0 == 1) quit" farà terminare bc.

warranty

Stampa una nota di avvertimento più lunga. È un'estensione.

FUNZIONI¶

Functions provide a method of defining a computation that can be executed later. Functions in bc always compute a value and return it to the caller. Function definitions are "dynamic" in the sense that a function is undefined until a definition is encountered in the input. That definition is then used until another definition function for the same name is encountered. The new definition then replaces the older definition. A function is defined as follows:

define nome ( parametri ) { newline     lista_auto  lista_istruzioni }

Una chiamata di funzione è semplicemente un'espressione nella forma "nome(parametri)".

Parameters are numbers or arrays (an extension). In the function definition, zero or more parameters are defined by listing their names separated by commas. All parameters are call by value parameters. Arrays are specified in the parameter definition by the notation "name[]". In the function call, actual parameters are full expressions for number parameters. The same notation is used for passing arrays as for defining array parameters. The named array is passed by value to the function. Since function definitions are dynamic, parameter numbers and types are checked when a function is called. Any mismatch in number or types of parameters will cause a runtime error. A runtime error will also occur for the call to an undefined function.

The auto_list is an optional list of variables that are for "local" use. The syntax of the auto list (if present) is "auto name, ... ;". (The semicolon is optional.) Each name is the name of an auto variable. Arrays may be specified by using the same notation as used in parameters. These variables have their values pushed onto a stack at the start of the function. The variables are then initialized to zero and used throughout the execution of the function. At function exit, these variables are popped so that the original value (at the time of the function call) of these variables are restored. The parameters are really auto variables that are initialized to a value provided in the function call. Auto variables are different than traditional local variables because if function A calls function B, B may access function A's auto variables by just using the same name, unless function B has called them auto variables. Due to the fact that auto variables and parameters are pushed onto a stack, bc supports recursive functions.

The function body is a list of bc statements. Again, statements are separated by semicolons or newlines. Return statements cause the termination of a function and the return of a value. There are two versions of the return statement. The first form, "return", returns the value 0 to the calling expression. The second form, "return ( expression )", computes the value of the expression and returns that value to the calling expression. There is an implied "return (0)" at the end of every function. This allows a function to terminate and return 0 without an explicit return statement.

Functions also change the usage of the variable ibase. All constants in the function body will be converted using the value of ibase at the time of the function call. Changes of ibase will be ignored during the execution of the function except for the standard function read, which will always use the current value of ibase for conversion of numbers.

Several extensions have been added to functions. First, the format of the definition has been slightly relaxed. The standard requires the opening brace be on the same line as the define keyword and all other parts must be on following lines. This version of bc will allow any number of newlines before and after the opening brace of the function. For example, the following definitions are legal.

 define d (n) { return (2*n); } define d (n)   { return (2*n); }

Functions may be defined as void. A void function returns no value and thus may not be used in any place that needs a value. A void function does not produce any output when called by itself on an input line. The key word void is placed between the key word define and the function name. For example, consider the following session.

 define py (y) { print "--->", y, "<---", "\n"; } define void px (x) { print "--->", x, "<---", "\n"; } py(1) --->1<--- 0 px(1) --->1<---

Also, call by variable for arrays was added. To declare a call by variable array, the declaration of the array parameter in the function definition looks like "*name[]". The call to the function remains the same as call by value arrays.

LIBRERIA MATEMATICA¶

Se bc viene invocato con l'opzione -l, viene precaricata la libreria matematica e la scala predefinita è impostata a 20. Le funzioni matematiche calcolano i risultati alla scala impostata al momento della chiamata. La libreria matematica definisce le seguenti funzioni:

s (x)

Il seno di x, x in radianti.

c (x)

Il coseno di x, x in radianti.

a (x)

L'arcotangente di x, x in radianti.

l (x)

Il logaritmo naturale di x.

e (x)

La funzione esponenziale di elevare e al valore x.

j (n,x)

La funzione di Bessel di un intero di ordine n di x.

ESEMPI¶

In /bin/sh, il seguente codice assegna il valore "pi" alla variabile di shell pi.

La seguente è la definizione della funzione esponenziale usata nella libreria matematica. Questa funzione è scritta in POSIX bc.

 scale = 20
/* Uses the fact that e^x = (e^(x/2))^2    When x is small enough, we use the series:      e^x = 1 + x + x^2/2! + x^3/3! + ... */
define e(x) {   auto  a, d, e, f, i, m, v, z
  /* Verifica del segno x. */   if (x<0) {     m = 1     x = -x   }
  /* Precondizione x. */   z = scale;   scale = 4 + z + .44*x;   while (x > 1) {     f += 1;     x /= 2;   }
  /* Inizializza le variabili. */   v = 1+x   a = x   d = 1
  for (i=2; 1; i++) {     e = (a *= x) / (d *= i)     if (e == 0) {       if (f>0) while (f--)  v = v*v;       scale = z       if (m) return (1/v);       return (v/1);     }     v += e   } }

The following is code that uses the extended features of bc to implement a simple program for calculating checkbook balances. This program is best kept in a file so that it can be used many times without having to retype it at every use.

 scale=2 print "\nCheck book program!\n" print "  Remember, deposits are negative transactions.\n" print "  Exit by a 0 transaction.\n\n"
print "Initial balance? "; bal = read() bal /= 1 print "\n" while (1) {   "current balance = "; bal   "transaction? "; trans = read()   if (trans == 0) break;   bal -= trans   bal /= 1 } quit

La seguente è la definizione della funzione fattoriale ricorsiva.

 define f (x) {   if (x <= 1) return (1);   return (f(x-1) * x); }

OPZIONI READLINE E LIBEDIT¶

GNU bc can be compiled (via a configure option) to use the GNU readline input editor library or the BSD libedit library. This allows the user to do editing of lines before sending them to bc. It also allows for a history of previous lines typed. When this option is selected, bc has one more special variable. This special variable, history is the number of lines of history retained. For readline, a value of -1 means that an unlimited number of history lines are retained. Setting the value of history to a positive number restricts the number of history lines to the number given. The value of 0 disables the history feature. The default value is 100. For more information, read the user manuals for the GNU readline, history and BSD libedit libraries. One can not enable both readline and libedit at the same time.

DIFFERENZE¶

This version of bc was implemented from the POSIX P1003.2/D11 draft and contains several differences and extensions relative to the draft and traditional implementations. It is not implemented in the traditional way using dc(1). This version is a single process which parses and runs a byte code translation of the program. There is an "undocumented" option (-c) that causes the program to output the byte code to the standard output instead of running it. It was mainly used for debugging the parser and preparing the math library.

La principale fonte di differenze sono le estensioni, con le quali una caratteristica è estesa per aggiungere più funzionalità e aggiunte, oppure vengono aggiunte nuove caratteristiche. Quel che segue è l'elenco delle differenze e delle estensioni.

ambiente LANG

This version does not conform to the POSIX standard in the processing of the LANG environment variable and all environment variables starting with LC_.

nomi

Traditional and POSIX bc have single letter names for functions, variables and arrays. They have been extended to be multi-character names that start with a letter and may contain letters, numbers and the underscore character.

Stringhe

Le stringhe non possono contenere caratteri NUL. Secondo POSIX nelle stringhe devono essere inclusi tutti i caratteri.

last

POSIX bc does not have a last variable. Some implementations of bc use the period (.) in a similar way.

confronti

POSIX bc allows comparisons only in the if statement, the while statement, and the second expression of the for statement. Also, only one relational operation is allowed in each of those statements.

istruzione if, clausola else

POSIX bc non ha una clausola else.

istruzione for

POSIX bc richiede che siano presenti tutte le espressioni nell'istruzione for.

&&, ||, !

POSIX bc non ha gli operatori logici.

funzione read

POSIX bc non ha una funzione read.

istruzione print

POSIX bc non ha un'istruzione print.

istruzione continue

POSIX bc non ha un'istruzione continue.

istruzione return

POSIX bc richiede le parentesi attorno all'espressione return.

parametri di array

POSIX bc does not (currently) support array parameters in full. The POSIX grammar allows for arrays in function definitions, but does not provide a method to specify an array as an actual parameter. (This is most likely an oversight in the grammar.) Traditional implementations of bc have only call by value array parameters.

funzione format

POSIX bc requires the opening brace on the same line as the define key word and the auto statement on the next line.

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

POSIX bc does not require these "old style" assignment operators to be defined. This version may allow these "old style" assignments. Use the limits statement to see if the installed version supports them. If it does support the "old style" assignment operators, the statement "a =- 1" will decrement a by 1 instead of setting a to the value -1.

spazi nei numeri

Other implementations of bc allow spaces in numbers. For example, "x=1 3" would assign the value 13 to the variable x. The same statement would cause a syntax error in this version of bc.

errori ed esecuzione

This implementation varies from other implementations in terms of what code will be executed when syntax and other errors are found in the program. If a syntax error is found in a function definition, error recovery tries to find the beginning of a statement and continue to parse the function. Once a syntax error is found in the function, the function will not be callable and becomes undefined. Syntax errors in the interactive execution code will invalidate the current execution block. The execution block is terminated by an end of line that appears after a complete sequence of statements. For example,

a = 1
b = 2

{ a = 1


  b = 2 }

ha un blocco di esecuzione. Qualsiasi errore di runtime (errore di esecuzione) farà terminare l'esecuzione del blocco di esecuzione corrente. Un avvertimento in fase di esecuzione non fa terminare il blocco di esecuzione corrente.

Interruzioni

During an interactive session, the SIGINT signal (usually generated by the control-C character from the terminal) will cause execution of the current execution block to be interrupted. It will display a "runtime" error indicating which function was interrupted. After all runtime structures have been cleaned up, a message will be printed to notify the user that bc is ready for more input. All previously defined functions remain defined and the value of all non-auto variables are the value at the point of interruption. All auto variables and function parameters are removed during the clean up process. During a non-interactive session, the SIGINT signal will terminate the entire run of bc.

LIMITI¶

The following are the limits currently in place for this bc processor. Some of them may have been changed by an installation. Use the limits statement to see the actual values.

BC_BASE_MAX

La base massima in uscita è correntemente impostata a 999. La base massima in ingresso è 16.

BC_DIM_MAX

This is currently an arbitrary limit of 65535 as distributed. Your installation may be different.

BC_SCALE_MAX

The number of digits after the decimal point is limited to INT_MAX digits. Also, the number of digits before the decimal point is limited to INT_MAX digits.

BC_STRING_MAX

Il limite del numero di caratteri in una stringa è di INT_MAX caratteri.

esponente

Il valore dell'esponente nell'operazione di elevamento a potenza (^) è limitata a LONG_MAX.

nomi di variabile

Il limite corrente del numero di nomi unici è 32767 per tutte le variabili semplici, gli array e le funzioni.