bc(1) General Commands Manual bc(1) NOM bc - Un langage de calculatrice a precision arbitraire SYNTAXE bc [ -hlwsqv ] [options_longues] [ fichier ... ] DESCRIPTION bc est un langage qui prend en charge les nombres en precision arbitraire ainsi qu'une execution interactive des instructions. Il y a quelques similitudes au niveau de la syntaxe avec le langage de programmation C. Une bibliotheque mathematique standard est disponible a l'aide d'options de ligne de commande. Si necessaire, la bibliotheque mathematique peut etre definie avant de prendre en compte le moindre fichier. bc demarre en traitant le code de tous les fichiers listes sur la ligne de commande dans leur ordre d'apparition. Apres que tous les fichiers ont ete traites, bc lit a partir de l'entree standard. Tout le code est execute des qu'il est lu (si un fichier contient une commande indiquant d'arreter le processeur, bc ne lira jamais a partir de l'entree standard). Cette version de bc contient plusieurs extensions en sus des implementations traditionnelles de bc et du document de travail de la norme POSIX. Les options de ligne de commande peuvent faire afficher un avertissement par ces extensions ou les rejeter. Ce document decrit le langage accepte par ce processeur. Les extensions seront considerees selon cela. OPTIONS -h, --help Afficher ce message et quitter. -i, --interactive Forcer le mode interactif. -l, --mathlib Definir la bibliotheque mathematique standard. -w, --warn Emettre des avertissements pour les extensions du bc POSIX. -s, --standard Utiliser exactement le langage bc POSIX. -q, --quiet Ne pas afficher le message normal de bienvenue de GNU bc. -V, --version Afficher le numero de version et le copyright et quitter. NOMBRES L'element le plus basique dans bc est le nombre. Les nombres sont des nombres en precision arbitraire. Cette precision vaut a la fois pour la partie entiere et pour la partie fractionnaire. Tous les nombres sont representes de facon interne en decimal et tous les calculs sont effectues en decimal (cette version tronque les resultats des operations de division et de multiplication). Les nombres ont deux attributs : la longueur et l'echelle. La longueur est le nombre total de chiffres decimaux utilises par bc pour representer un nombre et l'echelle est le nombre total de chiffres decimaux apres le point decimal. Par exemple : .000001 a une longueur de 6 et une echelle de 6. 1935.000 a une longueur de 7 et une echelle de 3. VARIABLES Les nombres sont stockes dans deux types de variables : les variables simples et les variables de tableau. Toutes deux sont nommees. Les noms commencent par une lettre suivie d'un nombre quelconque de lettres, de chiffres ou de caracteres de soulignement (<< _ >>). Toutes les lettres doivent etre en minuscule. Les noms entierement alphanumeriques sont une extension. Dans bc POSIX, tous les noms sont constitues d'une seule lettre minuscule. Le type de variable est rendu evident grace au contexte, car tous les noms de variable de tableau sont suivis de crochets ([]). Il y a quatre variables speciales : scale, ibase, obase et last. scale definit la facon dont certaines operations utilisent les chiffres apres le point decimal. La valeur par defaut pour scale est 0. ibase et obase definissent la base de conversion pour les nombres en entree et en sortie. La base par defaut est 10, que ce soit pour l'entree ou pour la sortie. last (une extension) est une variable ayant pour valeur le dernier nombre affiche. Ces variables seront commentees plus en detail quand cela sera approprie. Toutes ces variables peuvent se voir affecter des valeurs, ainsi qu'etre utilisees dans des expressions. COMMENTAIRES Les commentaires dans bc debutent par les caracteres /* et se terminent par les caracteres */. Les commentaires peuvent demarrer n'importe ou et apparaitre comme une simple espace en entree. Cela conduit les commentaires a delimiter les autres elements de l'entree. Par exemple, un commentaire ne peut etre trouve au milieu d'un nom de variable. Les commentaires incluent tous les sauts de ligne (fin de ligne) situes entre le debut et la fin du commentaire. Pour que bc prenne en charge l'utilisation de scripts, un commentaire d'une seule ligne a ete ajoute comme extension. Un commentaire d'une seule ligne debute par un caractere # et continue jusqu'a la fin de la ligne. Le caractere de fin de ligne ne fait pas partie du commentaire et est traite normalement. EXPRESSIONS Les nombres sont manipules par des expressions et des instructions. Puisque le langage a ete concu pour etre interactif, les instructions et les expressions sont executees le plus tot possible. Il n'y a pas de programme << main >>. Au lieu de cela, le code est execute des qu'il est rencontre. Les fonctions, expliquees en detail ci-apres, sont definies quand elles sont rencontrees. Une expression simple est simplement une constante. bc convertit les constantes en nombres decimaux internes en utilisant la base de l'entree actuelle specifiee par la variable ibase. Une exception existe pour les fonctions. Les valeurs legales pour ibase vont de 2 a 36, celles superieures a 16 sont une extension. Affecter une valeur en dehors de cet intervalle a ibase resultera en une valeur de 2 ou 36. Les nombres d'entree peuvent contenir les caracteres 0-9 et A-F (remarque : ils doivent etre en capitales, les lettres minuscules etant des noms de variable). Les nombres d'un seul chiffre ont toujours la valeur de ce chiffre quelle que soit la valeur de ibase (c'est-a-dire A = 10). Pour les nombres composes de plusieurs chiffres, bc remplace tous les chiffres d'entree superieurs ou egaux a ibase par la valeur de ibase - 1. Cela fait que le nombre ZZZ est toujours le plus grand nombre de 3 chiffres dans la base d'entree. Les expressions completes sont similaires a 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 regle pour melanger des types. Au lieu de cela, il existe des regles portant sur l'echelle des expressions. Chaque expression possede une echelle. Elle est derivee de l'echelle des nombres originaux, de l'operation effectuee et, dans de nombreux cas, de la valeur de la variable scale. Les valeurs legales pour la variable scale vont de 0 au plus grand nombre representable par un entier C. Dans les descriptions suivantes des expressions legales, << expr >> fait reference a une expression complete, et << var >> a une variable simple ou de tableau. Une variable simple est juste un nom et une variable de tableau est indiquee par nom[expr] A moins qu'elle ne soit mentionnee specifiquement, l'echelle du resultat est la plus grande de celles des expressions impliquees. - expr Le resultat de la negation de l'expression. ++ var La variable est incrementee de un et la nouvelle valeur est le resultat de l'expression. -- var La variable est decrementee de un et la nouvelle valeur est le resultat de l'expression. var ++ Le resultat de l'expression est la valeur de la variable et ensuite la variable est incrementee de un. var -- Le resultat de l'expression est la valeur de la variable et ensuite la variable est decrementee de un. expr + expr Le resultat de l'expression est la somme des deux expressions. expr - expr Le resultat de l'expression est la difference des deux expressions. expr * expr Le resultat de l'expression est le produit des deux expressions. expr / expr Le resultat de l'expression est le quotient des deux expressions. L'echelle du resultat est la valeur de la variable scale. expr % expr Le resultat de l'expression est le << reste >> et il est calcule de la maniere suivante : pour calculer a%b, a/b est d'abord calcule avec une echelle de scale chiffres. Ce resultat est utilise pour calculer a-(a/b)*b avec comme echelle le maximum de scale + echelle(b) et echelle(a). Si scale vaut zero et que les deux expressions sont des entiers, cette expression est la fonction modulo d'entiers. expr ^ expr Le resultat de l'expression est la valeur de l'elevation de la premiere expression a une puissance egale a la valeur de la seconde expression. La seconde expression doit etre un entier. Si la seconde expression n'est pas un entier, un avertissement est genere et l'expression est tronquee pour obtenir une valeur entiere. L'echelle du resultat est scale si l'exposant est negatif. Si l'exposant est positif, l'echelle du resultat est le minimum entre l'echelle de la premiere expression multipliee par la valeur de l'exposant et celle maximale entre scale et l'echelle de la premiere expression (par exemple, scale(a^b) = min(scale(a)*b, max(scale, scale(a)))). Il faut noter que expr^0 renverra toujours la valeur 1. ( expr ) Cela altere la priorite standard pour forcer l'evaluation de l'expression. var = expr La valeur de l'expression est affectee a la variable. var = expr C'est equivalent a << var = var expr >> excepte que la partie << var >> n'est evaluee qu'une seule fois. Cela peut faire une difference si << var >> est un tableau. Les expressions relationnelles sont un cas particulier des expressions qui sont toujours evaluees a 0 ou 1 : 0 si la relation est fausse et 1 si la relation est vraie. Elles peuvent apparaitre dans n'importe quelle expression legale. Le bc POSIX requiert que les expressions relationnelles ne soient utilisees que dans les instructions if, for et while, et qu'un seul test relationnel y soit effectue. Les operateurs relationnels sont expr1 < expr2 Le resultat est 1 si expr1 est strictement inferieure a expr2. expr1 <= expr2 Le resultat est 1 si expr1 est inferieure ou egale a expr2. expr1 > expr2 Le resultat est 1 si expr1 est strictement superieure a expr2. expr1 >= expr2 Le resultat est 1 si expr1 est superieure ou egale a expr2. expr1 == expr2 Le resultat est 1 si expr1 est egale a expr2. expr1 != expr2 Le resultat est 1 si expr1 n'est pas egale a expr2. Les operations booleennes sont egalement legales. Le bc POSIX NE possede PAS d'operations booleennes. Le resultat de toutes les operations booleennes est 0 ou 1 (pour faux ou vrai) comme dans les expressions relationnelles. Les operateurs booleens sont : !expr Le resultat est 1 si expr vaut 0. expr && expr Le resultat est 1 si les deux expressions sont differentes de zero. expr || expr Le resultat est 1 si au moins l'une des deux expressions est differente de zero. La priorite dans les expressions est la suivante (de la plus basse a la plus haute) : operateur ||, associatif a gauche operateur &&, associatif a gauche operateur !, non associatif operateurs relationnels, associatifs a gauche operateur d'affectation, associatif a droite operateurs + et - , associatifs a gauche operateurs *, / et %, associatifs a gauche operateur ^, associatif a droite operateur - unaire, non associatif operateurs ++ et --, non associatifs Cette priorite a ete choisie de telle sorte que les programmes bc conformes a POSIX s'executent correctement. Cela conduira a ce que l'utilisation des operateurs relationnels et logiques mene a un comportement inhabituel lors de leur utilisation dans des expressions d'affectation. Considerez l'expression a = 3 < 5 La plupart des programmeurs C supposeraient que cela affecte le resultat de << 3 < 5 >> (la valeur 1) a la variable << a >>. Dans bc, cela affecte la valeur 3 a la variable << a >> et compare ensuite 3 a 5. Il vaut mieux utiliser des parentheses lors de l'utilisation d'operateurs relationnels ou logiques en presence d'operateurs d'affectation. Il y a quelques expressions speciales supplementaires qui sont fournies dans bc. Elles se rapportent a des fonctions definies par l'utilisateur et a des fonctions standard. Elles apparaissent toutes sous la forme << nom(parametres) >>. Consulter la section sur les fonctions pour les fonctions definies par l'utilisateur. Les fonctions standard sont : length ( expression ) La valeur de la fonction length est le nombre de chiffres significatifs dans l'expression. read ( ) La fonction read (une extension) lit un nombre a partir de l'entree standard independamment de l'endroit ou elle est appelee. Attention : cela peut causer des problemes lors du melange de donnees et d'un programme sur l'entree standard. Le meilleur usage de cette fonction se situe dans un programme precedemment ecrit qui a besoin d'une saisie de l'utilisateur, mais qui ne permet jamais que l'utilisateur saisisse du code de programme. La valeur de la fonction read est le nombre lu a partir de l'entree 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 apres le point decimal dans l'expression. sqrt ( expression ) La valeur de la fonction sqrt est la racine carree de l'expression. Si l'expression est negative, une erreur d'execution est generee. INSTRUCTIONS Les instructions (comme dans la plupart des langages algebriques) fournissent l'ordre d'evaluation d'une expression. Dans bc, les instructions sont executees << le plus tot possible >>. L'execution se produit quand un saut de ligne est rencontre et qu'il y a une ou plusieurs instructions completes. A cause de cette execution immediate, les sauts de ligne sont tres importants dans bc. En fait, le point-virgule et le saut de ligne sont utilises comme separateurs d'instructions. Un saut de ligne mal place provoquera une erreur de syntaxe. Puisque les sauts de ligne sont des separateurs d'instructions, il est possible de cacher un saut de ligne en utilisant une barre oblique inverse. La sequence << \ >>, ou est le saut de ligne, apparait a bc comme un espace blanc au lieu d'un saut de ligne. Une liste d'instructions est une serie d'instructions separees par des points-virgules et des sauts de ligne. Voici une liste des instructions de bc et ce qu'elles font (les elements entre crochets ([]) sont des parties facultatives de l'instruction) : expression Cette instruction accomplit une des deux actions. Si l'expression debute par << ... >>, elle est consideree comme une instruction d'affectation. Si l'expression n'est pas une instruction d'affectation, l'expression est evaluee et affichee sur la sortie. Apres l'affichage du nombre, un saut de ligne est egalement affiche. Par exemple, << a=1 >> est une instruction d'affectation et << (a=1) >> est une expression qui possede une affectation imbriquee. Tous les nombres qui sont affiches le sont dans la base specifiee par la variable obase. Les valeurs legales pour obase vont de 2 a BC_BASE_MAX (consulter la section LIMITES). Pour les bases 2 a 16, la methode habituelle d'ecriture des nombres est utilisee. Pour les bases superieures a 16, bc utilise une methode utilisant des chiffres multicaracteres pour afficher les nombres ou chaque chiffre d'une base superieure est affiche comme un nombre en base 10. Les chiffres multicaracteres sont separes par des espaces. Chaque chiffre contient le nombre de caracteres requis pour representer la valeur en base dix de << obase - 1 >>. Puisque les nombres sont en precision arbitraire, certains nombres ne peuvent etre affiches sur une seule ligne de sortie. Ces nombres longs seront repartis sur plusieurs lignes en utilisant << \ >> comme dernier caractere de la ligne. Le nombre maximal de caracteres affiches par ligne est 70. A cause de la nature interactive de bc, l'affichage d'un nombre presente comme effet de bord l'affectation de la valeur affichee a la variable speciale last. Cela permet a l'utilisateur de recuperer la derniere valeur affichee sans avoir a retaper l'expression qui a affiche le nombre. Affecter une valeur a last est legal et remplacera la derniere valeur affichee par la valeur affectee. La valeur nouvellement affectee restera jusqu'a ce que le nombre suivant soit affiche ou qu'une autre valeur soit affectee a last. Certaines installations peuvent permettre l'utilisation d'un simple point (.) qui ne fait pas partie d'un nombre etant un raccourci pour last. string La chaine de caracteres est affichee sur la sortie. Les chaines debutent par un guillemet double droit et contiennent tous les caracteres presents jusqu'au guillemet suivant. Tous les caracteres sont utilises litteralement, y compris les sauts de ligne. Aucun caractere de saut de ligne n'est imprime apres la chaine. print liste L'instruction print (une extension) fournit une autre methode de sortie. La << liste >> est une liste de chaines et d'expressions separees par des virgules. Les chaines ou expressions sont affichees dans leur ordre d'apparition dans cette liste. Aucun saut de ligne terminal n'est affiche. Les expressions sont evaluees et leur valeur est affichee et affectee a la variable last. Les chaines de l'instruction print sont imprimees sur la sortie et peuvent contenir des caracteres speciaux. Les caracteres speciaux debutent par une barre oblique inverse (\). Les caracteres speciaux reconnus par bc sont << a >> (alerte ou sonnerie), << b >> (effacement arriere), << f >> (saut de page), << n >> (saut de ligne), << r >> (retour chariot), << q >> (guillemet double droit), << t >> (tabulation) et << \ >> (barre oblique inverse). Tout autre caractere suivant la barre oblique inverse sera ignore. { liste_instructions } C'est l'instruction composee. Elle permet a plusieurs instructions d'etre regroupees pour execution. if ( expression ) instruction1 [else instruction2] L'instruction if evalue l'expression et execute instruction1 ou instruction2 en fonction de la valeur de l'expression. Si l'expression est differente de zero, instruction1 est executee. Si instruction2 est presente et que la valeur de l'expression est 0, alors instruction2 est executee (la clause else est une extension). while ( expression ) instruction L'instruction while executera l'instruction tant que l'expression est differente de zero. Elle evalue l'expression avant chaque execution de l'instruction. La fin de la boucle est causee par une valeur d'expression de 0 ou par l'execution d'une instruction break. for ( [expression1] ; [expression2] ; [expression3] ) instruction L'instruction for controle l'execution repetee de l'instruction. Expression1 est evaluee avant la boucle. Expression2 est evaluee avant chaque execution de l'instruction. Si elle est differente de zero, l'instruction est evaluee. Si c'est zero, la boucle est terminee. Apres chaque execution de l'instruction, expression3 est evaluee avant la reevaluation de expression2. Si expression1 ou expression3 sont absentes, rien n'est evalue au moment ou elles devraient l'etre. Si expression2 manque, cela revient a substituer la valeur 1 a expression2. Les expressions facultatives sont une extension. Le bc POSIX requiert les trois expressions. Le code suivant est equivalent a l'instruction for : expression1; while (expression2) { instruction; expression3; } break Cette instruction provoque un arret force de l'instruction while ou for englobante la plus proche. continue L'instruction continue (une extension) force l'instruction for englobante la plus proche a commencer l'iteration suivante. halt L'instruction halt (une extension) est une instruction executee qui indique au processeur bc de ne s'arreter que lorsqu'elle est executee. Par exemple, << if (0 == 1) halt >> n'obligera pas bc a se terminer, car le halt n'est pas execute. return Renvoyer la valeur 0 a partir d'une fonction (consulter la section sur les fonctions). return ( expression ) Renvoyer la valeur de l'expression a partir d'une fonction (consulter la section sur les fonctions). Comme extension, les parentheses ne sont pas requises. PSEUDO-INSTRUCTIONS Ces instructions ne sont pas des instructions au sens traditionnel du terme. Elles ne sont pas des instructions executees. Leur fonction est effectuee au moment de la compilation. limits Afficher les limites locales imposees par la version locale de bc. C'est une extension. quit Quand l'instruction quit est lue, le processeur bc est arrete, quel que soit l'emplacement de l'instruction quit. Par exemple, << if (0 == 1) quit >> provoquera l'arret de bc. warranty Afficher une notice de garantie plus longue. C'est une extension. FONCTIONS Les fonctions fournissent une methode pour definir un calcul pouvant etre execute ulterieurement. Les fonctions de bc calculent toujours une valeur et la renvoient a l'appelant. Les definitions de fonction sont << dynamiques >> dans le sens ou une fonction n'est pas definie avant que sa definition ait ete rencontree en entree. Cette definition est ensuite utilisee jusqu'a ce qu'une definition de fonction de meme nom soit rencontree. La nouvelle definition remplace ensuite l'ancienne. Une fonction est definie comme suit : define nom ( parametres ) { saut_de_ligne liste_auto liste_instructions } Un appel de fonction est simplement une expression de la forme << nom(parametres) >>. Les parametres sont des nombres ou des tableaux (une extension). Dans la definition de fonction, zero parametre ou plus sont definis en fournissant leurs noms separes par des virgules. Les nombres sont des parametres passes uniquement par valeur. Les tableaux sont specifies dans la definition des parametres par la notation << nom[] >>. Dans l'appel de fonction, les parametres reels sont des expressions completes pour les parametres nombres. La meme notation est utilisee pour passer des tableaux et pour definir des parametres de tableau. Le tableau nomme est passe par valeur a la fonction. Puisque les definitions de fonctions sont dynamiques, le nombre de parametres et leur type sont verifies quand une fonction est appelee. Toute erreur dans le nombre ou le type des parametres provoquera une erreur a l'execution. Une erreur a l'execution se produit egalement lors de l'appel d'une fonction non definie. La liste_auto est une liste facultative de variables destinees a une utilisation << locale >>. La syntaxe de la liste_auto (si elle est presente) est << auto nom, ... ; >>, le point-virgule etant facultatif. Chaque nom est le nom d'une variable automatique. Les tableaux peuvent etre specifies en utilisant la meme notation que celle utilisee pour les parametres. Ces variables voient leur valeur empilee au debut de la fonction. Les variables sont ensuite initialisees a zero et utilisees tout au long de l'execution de la fonction. A la sortie de la fonction, ces valeurs sont depilees afin que leur valeur originale (au moment de l'appel de la fonction) soit restauree. Les parametres sont reellement des variables automatiques qui sont initialisees a une valeur fournie dans l'appel de fonction. Les variables automatiques sont differentes des variables locales traditionnelles car, si une fonction A appelle une fonction B, B peut acceder aux variables automatiques de A en utilisant simplement le meme nom, a moins que la fonction B en ait fait des variables automatiques. Etant donne que les variables automatiques et les parametres sont places sur une pile, bc prend en charge les fonctions recursives. Le corps de la fonction est une liste d'instructions de bc. A nouveau, les instructions sont separees par des points-virgules ou des sauts de ligne. Les instructions return provoquent l'arret d'une fonction et le renvoi d'une valeur. Il y a deux versions de l'instruction return. La premiere forme, << return >>, renvoie la valeur 0 a l'expression appelante. La seconde forme, << return (expression ) >>, calcule la valeur de l'expression et la renvoie a l'expression appelante. Il y a un << return (0) >> implicite a la fin de chaque fonction. Cela permet a une fonction de se terminer et de renvoyer 0 sans avoir besoin d'une instruction return explicite. Les fonctions modifient egalement 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 ignores durant l'execution de la fonction sauf pour la fonction standard read, qui utilise toujours la valeur actuelle de ibase pour les conversions de nombres. Plusieurs extensions ont ete ajoutees aux fonctions. D'abord, le format de la definition a ete rendu legerement moins astreignant. La norme requiert que l'accolade d'ouverture soit placee sur la meme ligne que le mot-cle define et que toutes les autres parties se situent sur les lignes suivantes. Cette version de bc permet un nombre quelconque de sauts de ligne avant et apres l'accolade d'ouverture de la fonction. Par exemple, les definitions suivantes sont legales : define d (n) { return (2*n); } define d (n) { return (2*n); } Les fonctions peuvent etre definies comme void. Une fonction void ne renvoie aucune valeur et par consequent ne peut etre utilisee dans toute place necessitant une valeur. Une fonction void ne produit aucune sortie lorsqu'appelee par elle-meme sur une ligne d'entree. Le mot-cle void est place entre le mot-cle define et le nom de fonction. Par exemple, en considerant la session suivante : define py (y) { print "--->", y, "<---", "\n"; } define void px (x) { print "--->", x, "<---", "\n"; } py(1) --->1<--- 0 px(1) --->1<--- Puisque py n'est pas une fonction void, l'appel de py(1) affiche la sortie desiree et une seconde ligne qui est la valeur de la fonction. Puisque la valeur d'une fonction qui n'a pas recu d'instruction return explicite est zero, celui-ci est affiche. Pour px(1), aucun zero n'est affiche parce que la fonction est une fonction void. L'appel par variable a ete aussi ajoute pour les tableaux. Pour declarer un appel par variable, la declaration du parametre de tableau dans la definition de fonction ressemble a << *name[] >>. L'appel de la fonction reste le meme que l'appel par tableaux de valeurs. BIBLIOTHEQUE MATHEMATIQUE Si bc est invoque avec l'option -l, une bibliotheque mathematique est prechargee et l'echelle par defaut est fixee a 20. Les fonctions mathematiques calculeront leur resultat a l'echelle etablie au moment de leur appel. La bibliotheque mathematique definit les fonctions suivantes : s (x) Le sinus de x ; x est exprime en radians. c (x) Le cosinus de x ; x est exprime en radians. a (x) L'arc tangente de x ; arctan renvoie des radians. l (x) Le logarithme naturel (neperien) de x. e (x) La fonction exponentielle de e a 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 >> a la variable d'interpreteur pi. pi=$(echo "scale=10; 4*a(1)" | bc -l) Le code suivant est la definition de la fonction exponentielle utilisee dans la bibliotheque mathematique. Cette fonction est ecrite en bc POSIX. scale = 20 /* Utilisation du fait que e^x = (e^(x/2))^2 Quand x est suffisamment petit, la serie suivante est utilisee : e^x = 1 + x + x^2/2! + x^3/3! + ... */ define e(x) { auto a, d, e, f, i, m, v, z /* Verification du signe de x. */ if (x<0) { m = 1 x = -x } /* Precondition x. */ z = scale; scale = 4 + z + .44*x; while (x > 1) { f += 1; x /= 2; } /* Initialisation des 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 fonctionnalites avancees de bc pour implementer un programme simple de calcul des soldes de chequier. Ce programme est conserve de preference dans un fichier pour qu'il puisse etre reutilise a maintes reprises sans avoir a le retaper a chaque fois. scale=2 print "\nProgramme de chequier !\n" print " Rappelez-vous, les depots sont des transactions negatives.\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 definition de la fonction factorielle recursive : define f (x) { if (x <= 1) return (1); return (f(x-1) * x); } OPTIONS READLINE ET LIBEDIT GNU bc peut etre compile (a l'aide d'une option de configuration) pour utiliser soit la bibliotheque d'editeur d'entree GNU readline, soit la bibliotheque BSD libedit. Cela permet a l'utilisateur d'editer des lignes avant de les envoyer a bc. Cela permet egalement un historique des lignes precedemment tapees. Quand cette option est selectionnee, bc possede une variable speciale supplementaire. Cette variable speciale, history, est le nombre de lignes d'historique memorisees. Pour readline, une valeur de -1 signifie qu'un nombre illimite de lignes d'historique sont memorisees. Fixer la valeur de history a un nombre positif restreint le nombre de lignes d'historique au nombre fourni. La valeur 0 desactive cette fonctionnalite d'historique. La valeur par defaut est 100. Pour plus d'informations, lisez les manuels d'utilisateur des bibliotheques GNU readline et history et BSD libedit. Il n'est pas possible d'activer a la fois readline et libedit. DIFFERENCES Cette version de bc a ete implementee sur la base du document de travail POSIX P1003.2/D11 et contient plusieurs differences et extensions par rapport au document de travail et aux implementations traditionnelles. Elle n'a pas ete implementee de la facon traditionnelle en utilisant dc(1). Cette version est un unique processus qui analyse et execute une traduction en code intermediaire (byte code) du programme. Il y a une option << non documentee >> (-c) qui fait emettre par le programme le code intermediaire sur la sortie standard au lieu de l'executer. Elle a ete principalement utilisee pour deboguer l'analyseur syntaxique et pour preparer la bibliotheque mathematique. Une source majeure de differences est constituee par les extensions, ou une fonctionnalite est etendue pour offrir plus de fonctionnalites et des ajouts pour de nouvelles fonctionnalites. Voici la liste des differences et des extensions : environnement LANG Cette version ne se conforme pas a la norme POSIX en ce qui concerne le traitement de la variable d'environnement LANG et de toutes les variables d'environnement dont le nom debute par LC_. noms Les bc traditionnel et POSIX ont des noms composes d'une seule lettre pour les fonctions, les variables et les tableaux. Ils ont ete etendus pour gerer les noms multicaracteres debutant par une lettre et pouvant contenir des lettres, des nombres et le caractere de soulignement (_). chaines Les chaines de caracteres ne peuvent pas contenir d'octet NULL. POSIX dit que tous les caracteres doivent etre inclus dans des chaines. last Le bc POSIX ne possede pas de variable last. Certaines implementations de bc utilisent le point (.) d'une maniere 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 operation relationnelle est permise dans chacune de ces instructions. if instruction, else clause Le bc POSIX ne possede pas de clause else. instruction for Le bc POSIX requiert que toutes les expressions soient presentes dans l'instruction for. &&, ||, ! Le bc POSIX ne dispose pas des operateurs logiques. fonction read Le bc POSIX ne possede pas de fonction read. instruction print Le bc POSIX ne possede pas d'instruction print. instruction continue Le bc POSIX ne possede pas d'instruction continue. instruction return Le bc POSIX requiert des parentheses autour de l'expression return. parametres de tableau Le bc POSIX ne gere (actuellement) pas totalement les parametres tableau. La grammaire POSIX autorise les tableaux dans les definitions de fonction, mais ne fournit pas de methode pour specifier un tableau comme parametre reel. C'est plus que probablement un oubli dans la grammaire. Les implementations traditionnelles de bc ne gerent que les parametres tableau par valeur. format de fonction Le bc POSIX requiert que l'accolade ouvrante soit sur la meme ligne que le mot-cle define et que l'instruction auto soit sur la ligne suivante. =+, =-, =*, =/, =%, =^ Le bc POSIX ne requiert pas la definition de ces operateurs 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 installee les prend en charge. Si elle gere les operateurs d'affectation dans << l'ancien style >>, l'instruction << a = -1 >> decrementera a de 1 au lieu de fixer a a la valeur -1. espaces dans les nombres D'autres implementations de bc permettent les espaces dans les nombres. Par exemple, << x=1 3 >> affecterait la valeur 13 a la variable x. La meme instruction causerait une erreur de syntaxe dans cette version de bc. erreurs et execution Cette implementation se differencie des autres implementations par le code qui est execute quand des erreurs de syntaxe ou d'autres erreurs sont detectees dans le programme. Si une erreur de syntaxe est trouvee dans une definition de fonction, la recuperation des erreurs essaie de trouver le debut d'une instruction et continue a analyser la fonction. Une fois qu'une erreur de syntaxe est trouvee dans la fonction, la fonction ne sera pas appelable et devient non definie. Les erreurs de syntaxe dans le code d'execution interactive invalideront le bloc d'execution courant. Le bloc d'execution est termine par une fin de ligne qui apparait apres une sequence complete d'instructions. Par exemple, a = 1 b = 2 possede deux blocs d'execution et { a = 1 b = 2 } en possede un. Toute erreur a l'execution terminera l'execution du bloc d'execution courant. Un avertissement a l'execution ne terminera pas l'execution du bloc d'execution courant. Interruptions Durant une session interactive, le signal SIGINT (habituellement genere par la sequence control-C sur le terminal) interrompra l'execution du bloc d'execution courant. Il provoquera l'affichage d'une erreur a l'execution indiquant quelle fonction a ete interrompue. Apres que toutes les structures a l'execution ont ete << nettoyees >>, un message est affiche pour notifier l'utilisateur que bc est pret a recevoir des entrees supplementaires. Toutes les fonctions precedemment definies 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 parametres de fonction sont supprimes durant le processus de nettoyage. Durant une session non interactive, le signal SIGINT terminera l'execution entiere de bc. LIMITES Voici les limites actuellement en vigueur pour ce processeur bc. Certaines d'entre elles peuvent avoir ete modifiees par une installation. Utilisez l'instruction limits pour voir les valeurs reelles. BC_BASE_MAX La base de sortie maximale est actuellement fixee a 999. La base d'entree maximale est 16. BC_DIM_MAX C'est actuellement une limite arbitraire de 65535 dans la distribution. Votre installation peut etre differente. BC_SCALE_MAX Le nombre de chiffres apres le point decimal est limite a INT_MAX chiffres. Le nombre de chiffres avant le point decimal est egalement limite a INT_MAX chiffres. BC_STRING_MAX La limite sur le nombre de caracteres dans une chaine est de INT_MAX caracteres. exposant La valeur de l'exposant dans l'operation d'exponentielle (^) est limitee a LONG_MAX. noms de variable Le nombre maximal de noms uniques est fixe a 32767 pour toutes les variables simples, les tableaux et les fonctions. VARIABLES D'ENVIRONNEMENT Les variables d'environnement suivantes sont prises en compte par bc : POSIXLY_CORRECT C'est la meme chose que l'option -s. BC_ENV_ARGS C'est un autre mecanisme pour obtenir des arguments pour bc. Le format est le meme que celui des arguments en ligne de commande. Ces arguments sont traites en premier lieu, de sorte que les fichiers listes dans les arguments d'environnement sont traites avant n'importe quel fichier apparaissant comme argument sur la ligne de commande. Cela permet a l'utilisateur de definir des options et des fichiers << standard >> a traiter lors de chaque invocation de bc. Les fichiers presents dans les variables d'environnement contiennent typiquement des definitions de fonction pour les fonctions que l'utilisateur veut voir definies a chaque fois que bc est execute. BC_LINE_LENGTH Cela doit etre un entier specifiant le nombre de caracteres dans une ligne de sortie pour les nombres. Cela inclut les caracteres de barre oblique inversee et de saut de ligne pour les nombres longs. Comme extension, la valeur zero desactive la fonctionnalite multiligne. Toute autre valeur de cette variable inferieure a trois definit la longueur de ligne a 70. DIAGNOSTICS Si l'un des fichiers de la ligne de commandes ne peut etre ouvert, bc indiquera que le fichier n'est pas disponible et se terminera. Il y a egalement des diagnostics lors de la compilation et de l'execution qui devraient etre suffisamment auto-explicites. BOGUES La recuperation apres erreur n'est pas encore tres bonne. Envoyez vos rapports de bogues par courriel a 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 veut remercier Steve Sommars (Steve.Sommars@att.com) pour son aide intensive lors des tests de l'implementation. Il a fourni beaucoup de suggestions geniales. C'est un produit bien meilleur grace a son implication. TRADUCTION La traduction francaise de cette page de manuel a ete creee par Frederic Delanoy et Jean-Paul Guillonneau Cette traduction est une documentation libre ; veuillez vous reporter a la GNU General Public License version 3 concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITE LEGALE. Si vous decouvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un message a . Projet GNU 11 juin 2006 bc(1)