LouiseMathique

                                                          -*- Outline -*-
         Sujet Louisemathique


* Thème
Il s'agit d'un autre sujet de calcul en précision arbitraire, mais
reposant sur une autre technique de parsage, et sur une bibliothèque
de calcul multiprécision.  Ce sujet vise également à vous faire
manipuler deux structures de données fondamentales : les piles, et les
arbres n-aires.  Par ailleurs, on travaille avec des fractions, et non
plus des entiers.

* Sujet
Écrire louisemathique, qui n'admet aucune option, prend l'expression
à évaluer sur l'entrée standard, sort le résultat sur la sortie
standard, et, le cas échéant, les messages d'erreur sur la sortie
d'erreur standard.  La valeur de retour de l'application (exit status)
est contrôlée :

- si elle est égale à 0
alors la sortie standard est contrôlée, et la sortie d'erreur doit
être vide.

- si elle est différente de 0
alors ni la sortie standard ni la sortie d'erreur ne sont contrôlées.

Tous les lexèmes, ou tokens, ou simplement mots, sont séparés par des
blancs (espace, tabulation ou retour à la ligne).  Les seuls lexèmes
admis sont :

- Les nombres
  Uniquement composés de chiffres décimaux, 0123456789.
  Arbitrairement grands, pas de support pour la négation unaire (-1
  n'existe pas, écrire `0 1 -').

- Les opérateurs
  `+', `-', `/', `*' avec leur sens habituel.

- Tout autre lexème
  est une erreur de parsage, signalée par un exit 2 et le message
  d'erreur que vous voudrez.

Une fois l'entrée standard complètement lue avec succès, la
louisemathique affiche en notation infixe l'expression qui vient
d'être lue, puis son résultat sous forme normale, séparés par un `='.
Tous les opérateurs produisent une paire de parenthèses pour leur
expression :

1 2 +
=> (1 + 2) = 3

1 2 3 + *
=> (1 * (2 + 3)) = 5

1 2 + 3 4 + /
=> ((1 + 2) / (3 + 4)) = 3 / 7

Les blancs en sortie standard sont non significatifs, par exemple les
résultats suivants sont également acceptés :

1 2 +
=>   (
=>       1
=>     +
=>       2
=>   )
=> =
=>   3

1 2 3 + *
=> (1*(2+3)) = 5

1 2 + 3 4 + /
=> ((1+2)/(3+4))
=> =
=> 3/7

En cas d'erreur de manque d'arguments pour effectuer le calcul, sortir
avec erreur 3 et le message d'erreur que vous voudrez.

Si à la fin du calcul il reste plusieurs arguments sur la pile, sortir
avec erreur 4 et le message d'erreur que vous voudrez.

En cas d'erreur due au calcul, par exemple division par zéro, donne
lieu à un exit 5 et le message d'erreur que vous voudrez.

Tout autre erreur (problème de mémoire, d'accès aux fichiers, etc.)
conduit à un exit 1 et le message d'erreur que vous voudrez.

* GMP, GNU Multiprecision Library

La documentation est disponible sur

   http://www.lrde.epita.fr/~akim/doc/gmp/

Ou encore via info(1) sur les NetBSD :

        info -f ~akim/info/gmp.info

Ou par Emacs :

   C-h i g /u/prof/akim/info/gmp.info

Un exemple simple est disponible dans

   http://www.lrde.epita.fr/~strub_p/miniproj/gmp.c

Pour compiler, vous devez spécifier
- La racine de l'installation de gmp
  GMPPREFIX = /u/prof/akim
- Le chemin vers les includes
  -I $(GMPPREFIX)/include
- Le chemin vers les bibliothèques
  -L $(GMPPREFIX)/lib
- et la bibliothèque elle-même
  -lgmp

* Machine de référence.
  Une machine de référence est disponible dans ~akim/bin.
  Tout comportement correct de cette machine est a` reproduire, et bien
  entendu aucun des comportements incorrects :)

  Elle supporte --version, --help, et --compact, ce qui ne vous est
  pas demandé, mais --compact peut vous aider à vous comparer à une
  machine ayant le même format de sortie que vous.

* Modalités de rendu
- Le projet louisemathique est à faire en mononôme (à une personne
  donc).

- Le projet devra etre rendu le repertoire ~/c/rendu/projs/louisemathique

- Le projet est à réaliser en C, et devra respecter strictement la norme
  EPITA.

- Les droits sur le répertoire ~/c/rendu/projs de rendu devront être 700

- Tous vos fichiers devront être en 600, sauf l'exécutable généré qui
  conservera les droits par défaut (surtout les droits d'exécution).

- Vous devrez écrire un Makefile contenant les règles suivantes :
        * une cible `all' qui compilera la  calculatrice
        * une cible `clean'  qui  effacera  tous  les  objets  et  les
          exécutables

La régle par default sera "all".

- Pour ce sujet, et pour ce sujet seulement, utilisez fputs, fputc
  pour les sorties, getc etc. pour les entrées, de façon à ne pas
  devoir jongler avec fflush entre vos appels bas niveaux, et ceux de
  GMP, utilisant des FILEs.

- Pour ce sujet, et pour ce sujet seulement, vous avez droit aux enums
  pour étiqueter vos noeuds d'arbre, de façon à marquer leur nature
  (nature opération-binaire, nature nombre).

- L'exécutable généré devra obligatoirement s'appeler
``louisemathique''. Tout autre nom entraînera une note de 0, sans
  négociation possible.

- Votre programme devra compiler ET fonctionner obligatoirement sur
  les NetBSD.  Il ne sera pas testé sur les autres architectures.