Nom

bc - Un langage de calculatrice à précision arbitraire

Syntaxe

bc [ -hilwsqv ] [options-longues] [ fichier ... ]

Version

Cette page de manuel documente GNU bc version 1.06.

Description

bc est un langage qui supporte les nombres en précision arbitraire ainsi qu'une exécution interactive des instructions. Il y a quelques similitudes au niveau de la syntaxe avec le langage de programmation C. Une bibliothèque mathématique standard est disponible via les options de ligne de commandes. Si nécessaire, la bibliothèque mathématique peut être définie avant de prendre en compte le moindre fichier. bc démarre en traitant le code de tous les fichiers listés sur la ligne de commandes dans leur ordre d'apparition. Après que tous les fichiers aient été traités, bc lit à partir de l'entrée standard. Tout le code est exécuté dès qu'il est lu (si un fichier contient une commande indiquant d'arrêter le processeur, bc ne lira jamais à partir de l'entrée standard).

Cette version de bc contient plusieurs extensions en sus des implémentations traditionnelles de bc et du document de travail du standard POSIX. Les options de ligne de commandes peuvent faire afficher un avertissement par ces extensions, ou les rejeter. Ce document décrit le langage accepté par ce processeur. Les extensions seront identifiées en tant que telles.

Options

"-h, --help"

Afficher un message d'utilisation et se terminer.

"-i, --interactive"

Forcer le mode interactif.

"-l, --mathlib"

Définir la bibliothèque mathématique standard.

"-w, --warn"

Émettre des avertissements pour les extensions par rapport au bc POSIX.

"-s, --standard"

Traiter exactement le langage bc POSIX.

"-q, --quiet"

Ne pas afficher le message de bienvenue normal de GNU bc.

"-v, --version"

Afficher le numéro de version et le copyright et se terminer.

Nombres

L'élément le plus basique dans bc est le nombre. Les nombres sont des nombres en précision arbitraire. Cette précision vaut à la fois pour la partie entière et pour la partie fractionnaire. Tous les nombres sont représentés de façon interne en décimal et tous les calculs sont effectués en décimal (cette version tronque les résultats des opérations de division et de multiplication). Les nombres ont ici deux attributs : la longueur et l'échelle. La longueur est le nombre total de chiffres décimaux significatifs d'un nombre et l'échelle est le nombre total de chiffres décimaux après le point décimal.

Par exemple, .nf      .000001 a une longueur de 6 et une échelle de 6. 1935.000 a une longueur de 7 et une échelle de 3. .fi

Variables

Les nombres sont stockés dans deux types de variables : les variables simples et les variables tableaux. Toutes deux sont nommées. Les noms commencent par une lettre suivie d'un nombre quelconque de lettres, chiffres ou caractères de soulignement (« _ »). Toutes les lettres doivent être en minuscule. (Les noms entièrement alphanumériques forment une extension ; dans le bc POSIX, tous les noms sont constitués d'une seule lettre minuscule.) Le type de variable est rendu évident grâce au contexte car tous les noms de variables tableaux sont suivis de crochets ([]).

Il y a quatre variables spéciales : scale , ibase , obase et last . scale définit la façon dont certaines opérations utilisent les chiffres après le point décimal. La valeur par défaut pour scale est 0. ibase et obase définissent la base de conversion pour les nombres en entrée et en sortie. La base par défaut est 10 que ce soit pour l'entrée ou pour la sortie. last (une extension) est une variable ayant pour valeur le dernier nombre affiché. Ces variables spéciales seront commentées plus en détail quand le besoin s'en fera sentir. Toutes ces variables peuvent se voir affecter des valeurs, ainsi qu'être utilisées dans des expressions.

Commentaires

Les commentaires dans bc débutent par les caractères /* et se terminent par les caractères */. Les commentaires peuvent démarrer n'importe où et apparaître comme une simple espace en entrée. (Cela conduit les commentaires à délimiter les autres éléments de l'entrée. Par exemple, un commentaire ne peut être trouvé au milieu d'un nom de variable.) Les commentaires incluent tous les sauts de ligne (fin de ligne) situés entre le début et la fin du commentaire.

Pour que bc supporte l'utilisation de scripts, un commentaire d'une seule ligne a été ajouté comme extension. Un commentaire d'une seule ligne débute par un caractère # et continue jusqu'à la fin de la ligne. Le caractère de fin de ligne ne fait pas partie du commentaire et est traité normalement.

Expressions

Les nombres sont manipulés par des expressions et des instructions. Puisque le langage a été conçu pour être interactif, les instructions et expressions sont exécutées le plus tôt possible. Il n'y a pas de programme « main » . Au lieu de cela, le code est exécuté dès qu'il est rencontré. (Les fonctions, discutées en détail par après, sont définies quand elles sont rencontrées.)

Une expression simple est simplement une constante. bc convertit les constantes en nombres décimaux en interne en utilisant la base d'entrée courante, spécifiée par la variable ibase. (Il y a une exception dans les fonctions.) Les valeurs légales pour ibase vont de 2 à 16. Affecter une valeur en dehors de cet intervalle à ibase résultera en une valeur de 2 ou 16. Les nombres d'entrée peuvent contenir les caractères 0-9 et A-F. (Note : ils doivent être en majuscule ; les lettres minuscules sont des noms de variables.) Les nombres d'un seul chiffre ont toujours la valeur de ce chiffre quelle que soit la valeur de ibase. (c.-à-d. A = 10.) Pour les nombres composés de plusieurs chiffres, bc remplace tous les chiffres d'entrée supérieurs ou égaux à ibase par la valeur de ibase-1. Cela fait en sorte que le nombre FFF est toujours le plus grand nombre de 3 chiffres dans la base d'entrée.

Les expressions complètes sont similaires à celles de nombreux autres langages de haut niveau. Puisqu'il n'y a qu'un seul type de nombre, il n'y a pas de règles de mélange des types. Au lieu de cela, il existe des règles portant sur l'échelle des expressions. Chaque expression possède une échelle. Elle est dérivée de l'échelle des nombres originaux, de l'opération effectuée et, dans de nombreux cas, de la valeur de la variable scale. Les valeurs légales pour la variable scale vont de 0 au plus grand nombre représentable par un entier C.

Dans les descriptions suivantes des expressions légales, « expr » se réfère à une expression complète, et « var » se réfère à une variable simple ou tableau. Une variable simple est juste un

nom

et une variable tableau est spécifiée sous la forme

nom[expr]

À moins qu'elle ne soit mentionnée spécifiquement, l'échelle du résultat est la plus grande de celle des expressions impliquées.
"- expr"

Le résultat de la négation de l'expression.

"++ var"

La variable est incrémentée de un et la nouvelle valeur est le résultat de l'expression.

"-- var"

La variable est décrémentée de un et la nouvelle valeur est le résultat de l'expression.

"var ++"

Le résultat de l'expression est la valeur de la variable, et ensuite la variable est incrémentée de un.

"var --"

Le résultat de l'expression est la valeur de la variable, et ensuite la variable est décrémentée de un.

"expr + expr"

Le résultat de l'expression est la somme des deux expressions.

"expr - expr"

Le résultat de l'expression est la différence entre les deux expressions.

"expr * expr"

Le résultat de l'expression est le produit des deux expressions.

"expr / expr"

Le résultat de l'expression est le quotient des deux expressions. L'échelle du résultat est la valeur de la variable scale.

"expr % expr"

Le résultat de l'expression est le « reste » et il est calculé de la manière suivante : pour calculer a%b, a/b est d'abord calculé avec une échelle de scale chiffres. Ce résultat est utilisé pour calculer a-(a/b)*b à l'échelle du maximum entre scale+scale(b) et scale(a). Si scale vaut zéro et que les deux expressions sont entières, cette expression est la fonction de reste entier.

"expr ^ expr"

Le résultat de l'expression est la valeur de la première expression exposant la seconde. La seconde expression doit être un entier. (Si la seconde expression n'est pas un entier, un avertissement est généré et l'expression est tronquée pour obtenir une valeur entière.) L'échelle du résultat est scale si l'exposant est négatif. Si l'exposant est positif, l'échelle du résultat est le minimum entre l'échelle de la première expression fois la valeur de l'exposant, et le maximum entre scale et l'échelle de la première expression (ou, mathématiquement parlant, scale(a^b) = min(scale(a)*b, max(scale, scale(a))) ). Il faut noter que expr^0 renverra toujours la valeur 1.

"( expr )"

Ceci altère la priorité standard pour forcer l'évaluation de l'expression.

"var = expr"

La valeur de l'expression est affectée à la variable.

"var <op>= expr"

C'est équivalent à « var = var <op> expr » à l'exception que la partie « var » n'est évaluée qu'une seule fois. Cela peut faire une différence si « var » est un tableau.

Les expressions relationnelles sont un cas particulier des expressions qui sont toujours évaluées à 0 ou 1 : 0 si la relation est fausse et 1 si la relation est vraie. Elles peuvent apparaître dans n'importe quelle expression légale. (Le bc POSIX requiert que les expressions relationnelles ne peuvent être utilisées que dans les instructions if, for et while, et qu'un seul test relationnel peut y être effectué.) Les opérateurs relationnels sont
"expr1 < expr2"

Le résultat est 1 si expr1 est strictement inférieure à expr2.

"expr1 <= expr2"

Le résultat est 1 si expr1 est plus petite ou égale à expr2.

"expr1 > expr2"

Le résultat est 1 si expr1 est strictement supérieure à expr2.

"expr1 >= expr2"

Le résultat est 1 si expr1 est plus grande ou égale à expr2.

"expr1 == expr2"

Le résultat est 1 si expr1 est égale à expr2.

"expr1 != expr2"

Le résultat est 1 si expr1 n'est pas égale à expr2.

Les opérateurs booléens sont également légaux. (Le bc POSIX ne possède PAS les opérations booléennes). Le résultat de toutes les expressions booléennes est 0 ou 1 (pour faux ou vrai) comme dans les expressions relationnelles. Les opérateurs booléens sont :
"!expr"

Le résultat est 1 si expr vaut 0.

"expr && expr"

Le résultat est 1 si les deux expressions sont non nulles.

"expr || expr"

Le résultat est 1 si (au moins) l'une des deux expressions est non nulle.

La priorité dans les expressions est la suivante (de la plus basse à la plus haute) : .nf

opérateur ||, associatif à gauche opérateur &&, associatif à gauche opérateur !, non associatif opérateurs relationnels, associatifs à gauche opérateur d'affectation, associatif à droite opérateurs + et - , associatifs à gauche opérateurs *, / et %, associatifs à gauche opérateur ^, associatif à droite opérateur - unaire, non associatif opérateurs ++ et -- , non associatifs

.fi

Cette priorité a été choisie de telle sorte que les programmes bc conformes à POSIX s'exécutent correctement. Cela conduira à ce que l'utilisation des opérateurs relationnels et logiques mène à un comportement inhabituel lors de leur utilisation dans des expressions d'affectation. Considérez l'expression

a = 3 < 5

La plupart des programmeurs C supposeraient que cela affecte le résultat de « 3 < 5 » (la valeur 1) à la variable « a ». Ce que cela fait dans bc est d'affecter la valeur 3 à la variable « a » et de comparer ensuite 3 à 5. Il vaut mieux utiliser des parenthèses lors de l'utilisation d'opérateurs relationnels ou logiques en présence d'opérateurs d'affectation.

Il y a quelques expressions spéciales supplémentaires qui sont fournies dans bc. Elles se rapportent à des fonctions définies par l'utilisateur et à des fonctions standard. Elles apparaissent toutes sous la forme « nom(paramètres) ». Voyez la section sur les fonctions pour en savoir plus sur les fonctions définies par l'utilisateur. Les fonctions standard sont :
"length ( expression )"

La valeur de la fonction length est le nombre de chiffres significatifs de l'expression.

"read ( )"

La fonction read (une extension) lit un nombre à partir de l'entrée standard, où qu'elle soit appelée. Attention : cela peut causer des problèmes lors du mélange de données et d'un programme sur l'entrée standard. Le meilleur usage de cette fonction se situe dans un programme précédemment écrit qui a besoin d'entrée en provenance de l'utilisateur, mais qui ne permet jamais que l'utilisateur entre du code. La valeur de la fonction read est le nombre lu à partir de l'entrée standard en utilisant la valeur actuelle de la variable ibase comme base de conversion.

"scale ( expression )"

La valeur de la fonction scale est le nombre de chiffres après la virgule dans l'expression.

"sqrt ( expression )"

La valeur de la fonction sqrt est la racine carrée de l'expression. Si l'expression est négative, une erreur à l'exécution est générée.

Instructions

Les instructions (comme dans la plupart des langages algébriques) fournissent le séquencement de l'évaluation d'une expression. Dans bc, les instructions sont exécutées « le plus tôt possible ». L'exécution se produit quand un saut de ligne est rencontré, et qu'il y a une ou plusieurs instructions complètes. À cause de cette exécution immédiate, les sauts de ligne sont très importants dans bc. En fait, à la fois le point-virgule et le saut de ligne sont utilisés comme séparateurs d'instructions. Un saut de ligne mal placé provoquera une erreur de syntaxe. Puisque les sauts de ligne sont des séparateurs d'instructions, il est possible de cacher un saut de ligne en utilisant le caractère backslash. La séquence « e<nl> », où <nl> est le saut de ligne, apparaît aux yeux de bc comme une espace blanche au lieu d'un saut de ligne. Une liste d'instructions est une série d'instructions séparées par des points-virgules et des sauts de ligne. Voici une liste des instructions bc et ce qu'elles font : (les éléments enfermés entre crochets ([]) sont des parties optionnelles de l'instruction.)
"expression"

Cette instruction accomplit une ou deux actions. Si l'expression débute par « <variable> <affectation> ... », elle est considérée être une instruction d'affectation. Si l'expression n'est pas une instruction d'affectation, l'expression est évaluée et imprimée sur la sortie. Après que le nombre ait été affiché, un saut de ligne l'est également. Par exemple, « a=1 » est une instruction d'affectation et « (a=1) » est une expression qui possède une affectation imbriquée. Tous les nombres qui sont affichés le sont dans la base spécifiée par la variable obase. Les valeurs légales pour obase vont de 2 à BC_BASE_MAX. (Voyez la section LIMITES.) Pour les bases 2 à 16, la méthode habituelle d'écriture des nombres est utilisée. Pour les bases supérieures à 16, bc utilise une méthode utilisant des chiffres multi-caractères pour afficher les nombres, où chaque chiffre d'une base supérieure est affiché comme un nombre en base 10. Les chiffres multi-caractères sont séparés par des espaces. Chaque chiffre contient le nombre de caractères requis pour représenter la valeur en base dix de « obase-1 ». Puisque les nombres sont en précision arbitraire, certains nombres ne peuvent être affichés sur une seule ligne de sortie. Ces nombres longs seront éclatés sur plusieurs lignes en utilisant « e » comme dernier caractère sur une ligne. Le nombre maximal de caractères affichés par ligne est 70. À cause de la nature interactive de bc, l'affichage d'un nombre présente comme effet de bord l'affectation de la valeur affichée à la variable spéciale last. Cela permet à l'utilisateur de récupérer la dernière valeur affichée sans avoir à retaper l'expression qui a affiché le nombre. Affecter vers last est légal et écrasera la dernière valeur affichée par la valeur affectée. La valeur nouvellement affectée restera jusqu'à ce que le nombre suivant soit affiché ou qu'une autre valeur soit affectée à last. (Certaines installations peuvent permettre l'utilisation d'un simple point (.) qui ne fait pas partie d'un nombre comme un raccourci pour last.)

"chaîne"

La chaîne de caractères est imprimée sur la sortie. Les chaînes débutent par un guillemet (") et contiennent tous les caractères présents jusqu'au guillemet suivant. Tous les caractères sont utilisés littéralement, y compris les sauts de ligne. Aucun caractère de saut de ligne n'est imprimé après la chaîne.

"print liste"

L'instruction print (une extension) fournit une autre méthode de sortie. La « liste » est une liste de chaînes et d'expressions séparées par des virgules. Les chaînes ou expressions sont affichées dans leur ordre d'apparition dans cette liste. Aucun saut de ligne terminal n'est affiché. Les expressions sont évaluées et leur valeur est affichée et affectée à la variable last. Les chaînes de l'instruction print sont imprimées sur la sortie et peuvent contenir des caractères spéciaux. Les caractères spéciaux débutent par le caractère backslash (e). Les caractères spéciaux reconnus par bc sont « a » (alerte ou sonnerie), « b » (effacement arrière), « f » (saut de page), « n » (saut de ligne), « r » (retour chariot), « q » (guillemet), « t » (tabulation) et « e » (backslash). Tout autre caractère suivant le backslash sera ignoré.

"{ liste_instructions }"

C'est l'instruction composée. Elle permet à plusieurs instructions d'être regroupées pour exécution.

"if ( expression ) instruction1 [else instruction2]"

L'instruction if évalue l'expression et exécute instruction1 ou instruction2 en fonction de la valeur de l'expression. Si l'expression est non nulle, instruction1 est exécutée. Si instruction2 est présente et que la valeur de l'expression est 0, alors instruction2 est exécutée. (La clause else est une extension.)

"while ( expression ) instruction"

L'instruction while exécutera l'instruction tant que l'expression est non nulle. Elle évalue l'expression avant chaque exécution de l'instruction. La fin de la boucle est causée par une valeur d'expression de 0, ou par l'exécution d'une instruction break.

"for ( [expression1] ; [expression2] ; [expression3] ) instruction"

L'instruction for contrôle l'exécution répétée de l'instruction. Expression1 est évaluée avant la boucle. Expression2 est évaluée avant chaque exécution de l'instruction. Si elle est non nulle, l'instruction est évaluée. Si elle est nulle, la boucle est terminée. Après chaque exécution de l'instruction, expression3 est évaluée avant la réévaluation de expression2. Si expression1 ou expression3 manque, rien n'est évalué au moment où elle devrait l'être. Si expression2 manque, cela revient à substituer la valeur 1 à expression2. (Les expressions optionnelles sont une extension. Le bc POSIX requiert les trois expressions.) Le code suivant est équivalent à l'instruction for :

.nf

expression1; while (expression2) { instruction; expression3; }

.fi
"break"

Cette instruction provoque un arrêt forcé de l'instruction while ou for englobante la plus proche.

"continue"

L'instruction continue (une extension) force l'instruction for englobante la plus proche à commencer l'itération suivante.

"halt"

L'instruction halt (une extension) est une instruction exécutée qui indique au processeur bc de ne s'arrêter que lorsqu'elle est exécutée. Par exemple, « if (0 == 1) halt » n'obligera pas bc à se terminer car le halt n'est pas exécuté.

"return"

Renvoyer la valeur 0 à partir d'une fonction. (Voyez la section sur les fonctions.)

"return ( expression )"

Renvoyer la valeur de l'expression à partir d'une fonction. (Voyez la section sur les fonctions.) Comme extension, les parenthèses ne sont pas requises.

Pseudo-instructions

Ces instructions ne sont pas des instructions au sens traditionnel du terme. Elles ne sont pas des instructions exécutées. Leur fonction est effectuée au moment de la compilation.
"limits"

Afficher les limites locales astreintes par la version locale de bc. C'est une extension.

"quit"

Quand l'instruction quit est lue, le processeur bc est arrêté, quel que soit l'emplacement de l'instruction quit. Par exemple, « if (0 == 1) quit » provoquera l'arrêt de bc.

"warranty"

Afficher une notice de garantie plus longue. C'est une extension.

Fonctions

Les fonctions fournissent une méthode pour définir un calcul qui peut être exécuté ultérieurement. Les fonctions de bc calculent toujours une valeur et la renvoient à l'appelant. Les définitions de fonctions sont « dynamiques » dans le sens où une fonction n'est pas définie avant que sa définition ait été rencontrée en entrée. Cette définition est ensuite utilisée jusqu'à ce qu'une définition de fonction de même nom soit rencontrée. La nouvelle définition remplace ensuite l'ancienne. Une fonction est définie comme suit :

.nf

define nom ( paramètres ) { saut_de_ligne liste_auto liste_instructions }

.fi

Un appel de fonction est simplement une expression de la forme « nom(paramètres) ».

Les paramètres sont des nombres ou des tableaux (une extension). Dans la définition de fonction, zéro paramètres ou plus sont définis en fournissant leurs noms séparés par des virgules. Les nombres sont des paramètres passés uniquement par valeur. Les tableaux sont passés uniquement par variable (référence). Les tableaux sont spécifiés dans la définition des paramètres par la notation « nom[] ». Dans l'appel de fonction, les paramètres réels sont des expressions complètes pour les paramètres nombres. La même notation est utilisée pour passer des tableaux et pour définir des paramètres tableaux. Le tableau nommé est passé par variable à la fonction. Puisque les définitions de fonctions sont dynamiques, le nombre de paramètres et leur type sont vérifiés quand une fonction est appelée. Toute erreur dans le nombre ou le type des paramètres provoquera une erreur à l'exécution. Une erreur à l'exécution se produit également lors de l'appel d'une fonction non définie.

La liste_auto est une liste optionnelle de variables destinées à une utilisation « locale ». La syntaxe de la liste_auto (si elle est présente) est « auto nom, ... ; ». (Le point-virgule est optionnel.) Chaque nom est le nom d'une variable automatique. Les tableaux peuvent être spécifiés en utilisant la même notation que celle utilisée pour les paramètres. Ces variables voient leur valeur empilée au début de la fonction. Les variables sont ensuite initialisées à zéro et utilisées tout au long de l'exécution de la fonction. À la sortie de la fonction, ces valeurs sont dépilées afin que leur valeur originale (au moment de l'appel de la fonction) soit restaurée. Les paramètres sont réellement des variables automatiques qui sont initialisées à une valeur fournie dans l'appel de fonction. Les variables automatiques sont différentes des variables locales traditionnelles car, si une fonction A appelle une fonction B, B peut accéder aux variables automatiques de A en utilisant simplement le même nom, à moins que la fonction B en ait fait des variables automatiques. Étant donné que les variables automatiques et les paramètres sont placés sur une pile, bc supporte les fonctions récursives.

Le corps de la fonction est une liste d'instructions bc. À nouveau, les instructions sont séparées par des points-virgules ou des sauts de ligne. Les instructions return provoquent l'arrêt de la fonction et le renvoi d'une valeur. Il y a deux versions de l'instruction return. La première forme, « return », renvoie la valeur 0 à l'expression appelante. La seconde forme, « return (expression ) », calcule la valeur de l'expression et la renvoie à l'expression appelante. Il y a un « return (0) » implicite à la fin de chaque fonction. Cela permet à une fonction de se terminer et de renvoyer 0 sans avoir besoin d'une instruction return explicite.

Les fonctions modifient également l'utilisation de la variable ibase. Toutes les constantes dans le corps de la fonction seront converties en utilisant la valeur de ibase au moment de l'appel de fonction. Les changements d'ibase seront ignorés durant l'exécution de la fonction sauf pour la fonction standard read, qui utilise toujours la valeur actuelle de ibase pour les conversions de nombres.

Comme extension, le format de la définition a été rendu légèrement moins astreignant. Le standard requiert que l'accolade d'ouverture doit être placée sur la même ligne que le mot-clé define et que toutes les autres parties doivent se situer sur les lignes suivantes. Cette version de bc permettra un nombre quelconque de sauts de ligne avant et après l'accolade d'ouverture de la fonction. Par exemple, les définitions suivantes sont légales : .nf

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

.fi

BibliothÈque mathÉmatique

Si bc est invoqué avec l'option -l, une bibliothèque mathématique est préchargée et l'échelle par défaut est fixée à 20. Les fonctions mathématiques calculeront leur résultat à l'échelle établie au moment de leur appel. La bibliothèque mathématique définit les fonctions suivantes :
"s (x)"

Le sinus de x ; x est exprimé en radians.

"c (x)"

Le cosinus de x ; x est exprimé en radians.

"a (x)"

L'arctangente de x ; l'arctangente renvoie des radians.

"l (x)"

Le logarithme naturel (népérien) de x.

"e (x)"

La fonction d'exponentiation de e à la puissance x.

"j (n,x)"

La fonction de Bessel d'ordre entier n de x.

Exemples

Dans /bin/sh, le code suivant affectera la valeur de « pi » à la variable shell pi.

f(CW pi=$(echo "scale=10; 4*a(1)" | bc -l)

Le code suivant est la définition de la fonction exponentielle utilisée dans la bibliothèque mathématique. Cette fonction est écrite en bc POSIX. .nf

f(CW scale = 20 /* Utilise le fait que e^x = (e^(x/2))^2 Quand x est suffisamment petit, nous utilisons le développement en série : e^x = 1 + x + x^2/2! + x^3/3! + ... */ define e(x) { auto a, d, e, f, i, m, v, z /* Vérifier le signe de x. */ if (x<0) { m = 1 x = -x } /* Précondition x. */ z = scale; scale = 4 + z + .44*x; while (x > 1) { f += 1; x /= 2; } /* Initialiser les variables. */ 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 } }

.fi

Le code suivant utilise les fonctionnalités avancées de bc pour implémenter un programme simple de calcul des soldes de chéquiers. Ce programme est conservé de préférence dans un fichier pour qu'il puisse être réutilisé à maintes reprises sans avoir à le retaper à chaque fois. .nf

f(CW scale=2 print "enProgramme Chéquier !en" print " Rappelez-vous, les dépôts sont des transactions négatives.en" print " Quittez par une transaction 0.enen" print "Solde initial ? "; bal = read() bal /= 1 print "en" while (1) { "Solde actuel = "; bal "transaction ? "; trans = read() if (trans == 0) break; bal -= trans bal /= 1 } quit

.fi

Le code suivant est la définition de la fonction factorielle récursive : .nf

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

.fi

Options readline et libedit

GNU bc peut être compilé (via une option de configuration) pour utiliser soit la bibliothèque d'éditeur d'entrée GNU readline, soit la bibliothèque BSD libedit. Cela permet à l'utilisateur d'éditer des lignes avant de les envoyer à bc. Cela permet également un historique des lignes précédemment tapées. Quand cette option est sélectionnée, bc possède une variable spéciale supplémentaire. Cette variable spéciale, history, est le nombre de lignes d'historique mémorisées. Pour readline, une valeur de -1 signifie qu'un nombre illimité de lignes d'historique sont mémorisées. Fixer la valeur de history à un nombre positif restreint le nombre de lignes d'historique au nombre fourni. La valeur 0 désactive cette fonctionnalité d'historique. La valeur par défaut est 100. Pour plus d'informations, lisez les manuels d'utilisateur des bibliothèques GNU readline et history, et BSD libedit. On ne peut pas activer à la fois readline et libedit au même moment.

DiffÉrences

Cette version de bc a été implémentée sur base du document de travail POSIX P1003.2/D11 et contient plusieurs différences et extensions par rapport au document de travail et aux implémentations traditionnelles. Il n'a pas été implémenté de la façon traditionnelle en utilisant dc(1). Cette version est un unique processus qui analyse et exécute une traduction en code octet (byte code) du programme. Il y a une option « non documentée » (-c) qui fait émettre par le programme le code octet sur la sortie standard au lieu de l'exécuter. Elle a été principalement utilisée pour déboguer l'analyseur syntaxique et pour préparer la bibliothèque mathématique.

Une source majeure de différences est constituée par les extensions, où une fonctionnalité est étendue pour offrir plus de possibilités, ou encore où de nouvelles fonctionnalités sont ajoutées. Voici la liste des différences et extensions :
LANG

Cette version ne se conforme pas au standard POSIX en ce qui concerne le traitement de la variable d'environnement LANG et de toutes les variables d'environnement dont le nom débute par LC_.

noms

Les bc traditionnel et POSIX n'ont des noms composés que d'une seule lettre pour les fonctions, variables et tableaux. Ils ont été étendus pour supporter les noms de plusieurs caractères débutant par une lettre et pouvant contenir des lettres, des nombres, et le caractère de soulignement (_).

Chaînes

Les chaînes de caractères ne peuvent pas contenir de caractère NUL. POSIX dit que tous les caractères peuvent être inclus dans les chaînes de caractères.

last

Le bc POSIX ne possède pas de variable last. Certaines implémentations de bc utilisent le point (.) d'une manière similaire.

comparaisons

Le bc POSIX ne permet les comparaisons que dans l'instruction if, l'instruction while, et la seconde expression de l'instruction for. De plus, une seule opération relationnelle est permise dans chacune de ces instructions.

"instruction if, clause else"

Le bc POSIX ne possède pas de clause else.

"instruction for"

Le bc POSIX requiert que toutes les expressions soient présentes dans l'instruction for.

"&&, ||, !"

Le bc POSIX ne dispose pas des opérateurs logiques.

"fonction read"

Le bc POSIX ne possède pas de fonction read.

"instruction print"

Le bc POSIX ne possède pas d'instruction print.

"instruction continue"

Le bc POSIX ne possède pas d'instruction continue.

"instruction return"

Le bc POSIX requiert des parenthèses autour de l'expression de return.

"paramètres tableaux"

Le bc POSIX ne supporte (actuellement) pas totalement les paramètres tableaux. La grammaire POSIX autorise les tableaux dans les définitions de fonctions, mais ne fournit pas de méthode pour spécifier un tableau comme paramètre réel. (C'est plus que probablement un oubli dans la grammaire.) Les implémentations traditionnelles de bc ne supportent que les paramètres tableaux passés par valeur.

"format de fonction"

Le bc POSIX requiert que l'accolade ouvrante soit sur la même ligne que le mot-clé define et que l'instruction auto soit sur la ligne suivante.

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

Le bc POSIX ne requiert pas la définition de ces opérateurs d'affectation dans l'« ancien style ». Cette version peut permettre ces affectations dans l'« ancien style ». Utilisez l'instruction limits pour voir si la version installée les supporte. Si elle supporte les opérateurs d'affectation dans l'« ancien style », l'instruction « a =- 1 » décrémentera a de 1 au lieu de fixer a à la valeur -1.

"espaces dans les nombres"

D'autres implémentations de bc permettent les espaces dans les nombres. Par exemple, « x=1 3 » affecterait la valeur 13 à la variable x. La même instruction causerait une erreur de syntaxe dans cette version de bc.

"erreurs et exécution"

Cette implémentation se différencie des autres implémentations par le code qui est exécuté quand des erreurs de syntaxe ou d'autres erreurs sont détectées dans le programme. Si une erreur de syntaxe est trouvée dans une définition de fonction, la récupération des erreurs essaie de trouver le début d'une instruction et continue à analyser la fonction. Une fois qu'une erreur de syntaxe est trouvée dans la fonction, la fonction ne sera pas appelable et devient non définie. Les erreurs de syntaxe dans le code d'exécution interactif invalideront le bloc d'exécution courant. Le bloc d'exécution est terminé par une fin de ligne qui apparaît après une séquence complète d'instructions. Par exemple, a = 1 b = 2 possède deux blocs d'exécution et { a = 1 b = 2 } en possède un. Toute erreur à l'exécution terminera l'exécution du bloc d'exécution courant. Un avertissement à l'exécution ne terminera pas l'exécution du bloc d'exécution courant.

"Interruptions"

Durant une session interactive, le signal SIGINT (habituellement généré par le caractère control-C sur le terminal) interrompra l'exécution du bloc d'exécution courant. Il provoquera l'affichage d'une erreur à l'exécution indiquant quelle fonction a été interrompue. Après que toutes les structures à l'exécution aient été « nettoyées », un message sera affiché pour notifier l'utilisateur que bc est prêt à recevoir de l'entrée supplémentaire. Toutes les fonctions précédemment définies le restent, et la valeur de toutes les variables non automatiques est celle ayant cours au moment de l'interruption. Toutes les variables automatiques et paramètres de fonction sont supprimés durant le processus de nettoyage. Durant une session non interactive, le signal SIGINT terminera l'exécution entière de bc.

Limites

Voici les limites actuellement en vigueur pour ce processeur bc. Certaines d'entre elles peuvent avoir été modifiées par une installation. Utilisez l'instruction limits pour voir les valeurs réelles.
BC_BASE_MAX

La base de sortie maximale est actuellement fixée à 999. La base d'entrée maximale est 16.

BC_DIM_MAX

C'est actuellement une limite arbitraire de 65535 dans la distribution. Votre installation peut être différente.

BC_SCALE_MAX

Le nombre de chiffres après la virgule est limité à INT_MAX chiffres. Le nombre de chiffres avant la virgule est également limité à INT_MAX chiffres.

BC_STRING_MAX

La limite sur le nombre de caractères dans une chaîne est de INT_MAX caractères.

exposant

La valeur de l'exposant dans l'opération d'exponentiation (^) est limitée à LONG_MAX.

"noms de variable"

Le nombre maximal de noms uniques est fixé à 32767 pour toutes les variables simples, les tableaux et les fonctions.

Variables denvironnement

Les variables d'environnement suivantes sont traitées par bc :
"POSIXLY_CORRECT"

Comme l'option -s.

"BC_ENV_ARGS"

C'est un autre mécanisme pour obtenir des arguments pour bc. Le format est le même que celui des arguments en ligne de commandes. Ces arguments sont traités en premier lieu, de sorte que les fichiers listés dans les arguments d'environnement sont traités avant n'importe quel fichier apparaissant comme argument sur la ligne de commandes. Cela permet à l'utilisateur de définir des options et des fichiers « standard » à traiter lors de chaque invocation de bc. Les fichiers présents dans les variables d'environnement contiennent typiquement des définitions de fonctions pour les fonctions que l'utilisateur veut voir définies à chaque fois que bc est exécuté.

"BC_LINE_LENGTH"

Cela devrait être un entier spécifiant le nombre de caractères dans une ligne de sortie pour les nombres. Cela inclut les caractères backslash et de saut de ligne pour les nombres longs.

Diagnostiques

Si l'un des fichiers de la ligne de commandes ne peut être ouvert, bc indiquera que le fichier n'est pas disponible et se terminera. Il y a également des diagnostics lors de la compilation et de l'exécution qui devraient être suffisamment explicites.

Bugs

La récupération après erreur n'est pas encore très bonne.

Envoyez vos rapports de bogues par email à bug-bc@gnu.org . Assurez-vous d'inclure le mot « bc » quelque part dans le champ « Sujet : ».

Auteur

.nf Philip A. Nelson philnelson@acm.org .fi

Remerciements

L'auteur voudrait remercier Steve Sommars (Steve.Sommars@att.com) pour son aide intensive lors des tests de l'implémentation. Il a fourni beaucoup de suggestions géniales. C'est un produit bien meilleur grâce à son implication.

Traduction

Frédéric Delanoy <delanoy_f at yahoo.com>, 2001.