bc

BC(1)                     Manuel de l'utilisateur Linux                    BC(1)



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,

               .000001 a une longueur de 6 et une échelle de 6.
               1935.000 a une longueur de 7 et une échelle de 3.


   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 \[u00BB] 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) :
              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

       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 « \<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 « \ » 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 (\).  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
              « \ » (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 :

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

       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 :

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

       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 :
              define d (n) { return (2*n); }
              define d (n)
                { return (2*n); }


   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.
               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.
              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
                }
              }

       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.
              scale=2
              print "\nProgramme Chéquier !\n"
              print "  Rappelez-vous, les dépôts sont des transactions
                       négatives.\n"
              print "  Quittez par une transaction 0.\n\n"

              print "Solde initial ? "; bal = read()
              bal /= 1
              print "\n"
              while (1) {
                "Solde actuel = "; bal
                "transaction ? "; trans = read()
                if (trans == 0) break;
                bal -= trans
                bal /= 1
              }
              quit

       Le code suivant est la définition de la fonction factorielle récursive :
              define f (x) {
                if (x <= 1) return (1);
                return (f(x-1) * x);
              }


   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 D'ENVIRONNEMENT
       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.

DIAGNOSTICS
       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.

BOGUES
       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
       Philip A. Nelson
       philnelson@acm.org

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.



v1.06                           12 septembre 2000                          BC(1)