bc

NOM

SYNTAXE

DESCRIPTION

Cette version de bc contient plusieurs extensions en sus des implémentations 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 décrit le langage accepté par ce processeur. Les extensions seront considérées selon cela.  

OPTIONS

-h, --help

Afficher ce message et quitter.

-i, --interactive

Forcer le mode interactif.

-l, --mathlib

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

-w, --warn

Émettre 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 numéro de version et le copyright et quitter.

NOMBRES

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

VARIABLES

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 seront commentées plus en détail quand cela sera approprié. Toutes ces variables peuvent se voir affecter des valeurs et être utilisées dans des expressions.  

COMMENTAIRES

Pour que bc prenne en charge 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

Une expression simple est simplement une constante. bc convertit les constantes en nombres décimaux internes en utilisant la base courante de l’entrée courante, spécifiée par la variable ibase. Une exception existe pour les fonctions. Les valeurs valables pour ibase vont de 2 à 36, celles supérieures à 16 sont une extension. Affecter une valeur en dehors de cet intervalle à ibase résultera en une valeur de 2 ou 36. Les nombres d'entrée peuvent contenir les caractères 0-9 et A-F (remarque : ils doivent être en capitales, les lettres minuscules étant 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’est-à-dire 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 ZZZ 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ègle pour mélanger 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 valables pour la variable scale vont de 0 au plus grand nombre représentable par un entier C.

Dans les descriptions suivantes des expressions valables, « expr » fait référence à une expression complète, et « var » à une variable simple ou de tableau. Une variable simple est juste un

nom

nom[expr]

- 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 des 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 avec comme échelle le maximum de scale + échelle(b) et échelle(a). Si scale vaut zéro et que les deux expressions sont des entiers, cette expression est la fonction modulo d’entiers.

expr ^ expr

Le résultat de l'expression est la valeur de l’élévation de la première expression à une puissance égale à la valeur de la seconde expression. 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 multipliée par la valeur de l'exposant et celle maximale entre scale et l'échelle de la première 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 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 » excepté 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 valable. Le bc POSIX requiert que les expressions relationnelles ne soient utilisées que dans les instructions if, for et while, et qu'un seul test relationnel y soit 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 inférieure 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 supérieure 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érations booléennes sont également valables. Le bc POSIX NE possède PAS d’opérations booléennes. Le résultat de toutes les opérations 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 différentes de zéro.

expr || expr

Le résultat est 1 si au moins l'une des deux expressions est différente de zéro.

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 ». Dans bc, cela affecte la valeur 3 à la variable « a » et compare 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/) ». Consulter la section sur les fonctions pour 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 dans l'expression.

read ( )

La fonction read (une extension) lit un nombre à partir de l'entrée standard indépendamment de l’endroit où elle est 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’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 à 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 le point décimal 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 d’exécution est générée.

INSTRUCTIONS

expression

Cette instruction accomplit une des deux actions. Si l'expression débute par « <variable> <affectation> ... », elle est considérée comme une instruction d'affectation. Si l'expression n'est pas une instruction d'affectation, l'expression est évaluée et affichée sur la sortie. Après l’affichage du nombre, un saut de ligne est également affiché. 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 valables pour obase vont de 2 à BC_BASE_MAX (consulter 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 multicaractères pour afficher les nombres où chaque chiffre d'une base supérieure est affiché comme un nombre en base 10. Les chiffres multicaractè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 de la 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 une valeur à last est légal et remplacera 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.

string

La chaîne de caractères est affichée sur la sortie. Les chaînes débutent par un guillemet double droit 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 affichées sur la sortie et peuvent contenir des caractères spéciaux. Les caractères spéciaux débutent par une barre oblique inverse (\). 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 double droit), « t » (tabulation) et « \ » (barre oblique inverse). Tout autre caractère suivant la barre oblique inverse 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 différente de zéro, 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 différente de zéro. 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 différente de zéro, l'instruction est évaluée. Si c’est zéro, 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 sont absentes, rien n'est évalué au moment où elles devraient l'être. Si expression2 manque, cela revient à substituer la valeur 1 à expression2. Les expressions facultatives 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 (consulter la section sur les fonctions).

return ( expression )

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

PSEUDO-INSTRUCTIONS

limits

Afficher les limites locales imposées 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

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

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. Tous les paramètres sont passés par valeur. 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 de tableau. Le tableau nommé est passé par valeur à 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 facultative de variables destinées à une utilisation « locale ». La syntaxe de la liste_auto (si elle est présente) est « auto nom, ... ; », le point-virgule étant facultatif. 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 prend en charge les fonctions récursives.

Le corps de la fonction est une liste d'instructions de bc. À nouveau, les instructions sont séparées par des points-virgules ou des sauts de ligne. Les instructions return provoquent l'arrêt d’une 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.

Plusieurs extensions ont été ajoutées aux fonctions. D’abord, le format de la définition a été rendu légèrement moins astreignant. La norme requiert que l'accolade d'ouverture soit placée sur la même ligne que le mot-clé 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 après l'accolade d'ouverture de la fonction. Par exemple, les définitions suivantes sont valables :

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

Les fonctions peuvent être définies comme void. Une fonction void ne renvoie aucune valeur et par conséquent ne peut être utilisée dans toute place nécessitant une valeur. Une fonction void ne produit aucune sortie lorsqu’appelée par elle-même sur une ligne d’entrée. Le mot-clé void est placé entre le mot-clé define et le nom de fonction. Par exemple, en considérant la session suivante  :

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

L’appel par variable a été aussi ajouté pour les tableaux. Pour déclarer un appel par variable, la déclaration du paramètre de tableau dans la définition de fonction ressemble à « ,*nom/[] ». L’appel de la fonction reste le même que l’appel par tableaux de valeurs.  

BIBLIOTHÈQUE MATHÉMATIQUE

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’arc tangente de x ; arctan renvoie des radians.

l (,x/)

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

e (,x/)

La fonction exponentielle de e à la puissance x.

j (,n,x/)

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

EXEMPLES

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

/* Utilisation du fait que e^x = (e^(x/2))^2    Quand x est suffisamment petit, la série suivante est utilisée :      e^x = 1 + x + x^2/2! + x^3/3! + ... */

define e(x) {   auto  a, d, e, f, i, m, v, z

  /* Vérification du 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;   }

  /* 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 fonctionnalités avancées de bc pour implémenter un programme simple de calcul des soldes de chéquier. 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 de 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

DIFFÉRENCES

Une source majeure de différences est constituée par les extensions, où une fonctionnalité est étendue pour offrir plus de fonctionnalités et des ajouts pour de nouvelles fonctionnalités. Voici la liste des différences et des extensions :

environnement LANG

Cette version ne se conforme pas à 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 débute par LC_.

noms

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

chaines

Les chaînes de caractères ne peuvent pas contenir d’octet NULL. POSIX dit que tous les caractères doivent être inclus dans des chaînes.

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.

if instruction, else clause

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

paramètres de tableau

Le bc POSIX ne gère (actuellement) pas totalement les paramètres tableau. La grammaire POSIX autorise les tableaux dans les définitions de fonction, 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 gèrent que les paramètres tableau 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 prend en charge. Si elle gère 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 interactive 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 la séquence 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 ont été « nettoyées », un message est affiché pour notifier l'utilisateur que bc est prêt à recevoir des entrées supplémentaires. 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

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 le point décimal est limité à INT_MAX chiffres. Le nombre de chiffres avant le point décimal 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’exponentielle (^) 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

POSIXLY_CORRECT

C’est la même chose que 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 commande. 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 commande. 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 fonction pour les fonctions que l'utilisateur veut voir définies à chaque fois que bc est exécuté.

BC_LINE_LENGTH

Cela doit être un entier spécifiant le nombre de caractères dans une ligne de sortie pour les nombres. Cela inclut les caractères de barre oblique inversée et de saut de ligne pour les nombres longs. Comme extension, la valeur zéro désactive la fonctionnalité multiligne. Toute autre valeur de cette variable inférieure à trois définit la longueur de ligne à 70.

DIAGNOSTICS

BOGUES

Envoyez vos rapports de bogues par courriel à 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

TRADUCTION

Cette traduction est une documentation libre ; veuillez vous reporter à la GNU General Public License version 3 concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE.

Si vous découvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un message à

Index

NOM

SYNTAXE

DESCRIPTION

OPTIONS

NOMBRES

VARIABLES

COMMENTAIRES

EXPRESSIONS

INSTRUCTIONS

PSEUDO-INSTRUCTIONS

FONCTIONS

BIBLIOTHÈQUE MATHÉMATIQUE

EXEMPLES

OPTIONS READLINE ET LIBEDIT

DIFFÉRENCES

LIMITES

VARIABLES D'ENVIRONNEMENT

DIAGNOSTICS

BOGUES

AUTEUR

REMERCIEMENTS

TRADUCTION