Programmation avancée sous Linux

% ./calculator
Veuillez saisir une expression postfixée :
2 3 +
5
Veuillez saisir une expression postfixée :
2 3 + 4 -
1

% gcc -pg -c -o calculator.o calculator.c
% gcc -pg -c -o stack.o stack.c
% gcc -pg -c -o number.o number.c
% gcc -pg calculator.o stack.o number.o -o calculator

Flat profile:
Each sample counts as 0.01 seconds.
  %   cumulative   self             self    total
 time   seconds   seconds    calls ms/call ms/call name
 26.07      1.76     1.76 20795463    0.00    0.00 decrement_number
 24.44      3.41     1.65     1787    0.92    1.72 add
 19.85      4.75     1.34 62413059    0.00    0.00 zerop
 15.11      5.77     1.02     1792    0.57    2.05 destroy_number
 14.37      6.74     0.97 20795463    0.00    0.00 add_one
  0.15      6.75     0.01     1788    0.01    0.01 copy_number
  0.00      6.75     0.00     1792    0.00    0.00 make_zero
  0.00      6.75     0.00       11    0.00    0.00 empty_stack

index % time    self  children    called     name
                                                 <spontaneous>
[1]    100.0    0.00    6.75                 main [1]
                0.00    6.75       2/2           apply_binary_function [2]
                0.00    0.00       1/1792        destroy_number [4]
                0.00    0.00       1/1           number_to_unsigned_int [10]
                0.00    0.00       3/3           string_to_number [12]
                0.00    0.00       3/5           push_stack [16]
                0.00    0.00       1/1           create_stack [18]
                0.00    0.00       1/11          empty_stack [14]
                0.00    0.00       1/5           pop_stack [15]
                0.00    0.00       1/1           clear_stack [17]
-----------------------------------------------
                0.00    6.75       2/2           main [1]
[2]    100.0    0.00    6.75       2         apply_binary_function [2]
                0.00    6.74       1/1           product [3]
                0.00    0.01       4/1792        destroy_number [4]
                0.00    0.00       1/1           subtract [11]
                0.00    0.00       4/11          empty_stack [14]
                0.00    0.00       4/5           pop_stack [15]
                0.00    0.00       2/5           push_stack [16]
-----------------------------------------------
                0.00    6.74       1/1           apply_binary_function [2]
[3]     99.8    0.00    6.74       1         product [3]
                1.02    2.65    1787/1792        destroy_number [4]
                1.65    1.43    1787/1787        add [5]
                0.00    0.00    1788/62413059     zerop [7]
                0.00    0.00       1/1792        make_zero [13]

-----------------------------------------------
                0.00    0.02       1/1           main [1]
[9]      0.1    0.00    0.02       1         apply_unary_function [9]
                0.01    0.00       1/1           even <cycle 1> [13]
                0.00    0.00       1/1806        destroy_number [5]
                0.00    0.00       1/13          empty_stack [17]
                0.00    0.00       1/6           pop_stack [18]
                0.00    0.00       1/6           push_stack [19]
-----------------------------------------------
[10]     0.1    0.01    0.00       1+69693   <cycle 1 as a whole> [10]
                0.00    0.00   34847             even <cycle 1> [13]
-----------------------------------------------
                               34847             even <cycle 1> [13]
[11]     0.1    0.01    0.00   34847         odd <cycle 1> [11]
                0.00    0.00   34847/186997954     zerop [7]
                0.00    0.00       1/1806        make_zero [16]
                               34846             even <cycle 1> [13]

/* Effectue des calculs en utilisant des nombres unaires.  */
/* Saisissez des expressions utilisant la notation postfixée sur une ligne,
   par exemple : 602 7 5 - 3 * +
   Les nombres positifs sont saisis en utilisant une notation décimal. Les
   opérateurs "+", "-" et "*" sont acceptés. Les opérateurs unaires
   "even" et "odd" renvoient le nombre 1 si leur opérande est pair ou impair,
   respectivement. Les différents éléments doivent être séparés par des espaces.
   Les nombres négatifs ne sont pas pris en charge. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include "definitions.h"
/* Applique la fonction binaire demandée aux opérandes obtenues depuis la pile
   et place le résultat sur la pile. Renvoie une valeur différente de zéro si
   tout se passe bien. */
int apply_binary_function (number (*function) (number, number),
                           Stack* stack)
{
  number operand1, operand2;
  if (empty_stack (*stack))
    return 0;
  operand2 = pop_stack (stack);
  if (empty_stack (*stack))
    return 0;
  operand1 = pop_stack (stack);
  push_stack (stack, (*function) (operand1, operand2));
  destroy_number (operand1);
  destroy_number (operand2);
  return 1;
}
/* Applique la fonction unaire demandée aux opérandes obtenues depuis la pile
   et place le résultat sur la pile. Renvoie une valeur différente de zéro si
   tout se passe bien. */
int apply_unary_function (number (*function) (number),
                          Stack* stack)
{
  number operand;
  if (empty_stack (*stack))
    return 0;
  operand = pop_stack (stack);
  push_stack (stack, (*function) (operand));
  destroy_number (operand);
  return 1;
}
int main ()
{
  char command_line[1000];
  char* command_to_parse;
  char* token;
  Stack number_stack = create_stack ();
  while (1) {
    printf ("Veuillez saisir une opération postfixée :\n");
    command_to_parse = fgets (command_line, sizeof (command_line), stdin);
    if (command_to_parse == NULL)
      return 0;
    token = strtok (command_to_parse, " \t\n");
    command_to_parse = 0;
    while (token != 0) {
      if (isdigit (token[0]))
        push_stack (&amp;number_stack, string_to_number (token));
      else if (((strcmp (token, "+") == 0) &amp;&amp;
                !apply_binary_function (&amp;add, &amp;number_stack)) ||
               ((strcmp (token, "-") == 0) &amp;&amp;
                !apply_binary_function (&amp;subtract, &amp;number_stack)) ||
               ((strcmp (token, "*") == 0) &amp;&amp;
                !apply_binary_function (&amp;product, &amp;number_stack)) ||
               ((strcmp (token, "even") == 0) &amp;&amp;
                !apply_unary_function (&amp;even, &amp;number_stack)) ||
               ((strcmp (token, "odd") == 0) &amp;&amp;
                !apply_unary_function (&amp;odd, &amp;number_stack)))
        return 1;
      token = strtok (command_to_parse, " \t\n");
    }
    if (empty_stack (number_stack))
      return 1;
    else {
      number answer = pop_stack (&amp;number_stack);
      printf ("%u\n", number_to_unsigned_int (answer));
      destroy_number (answer);
      clear_stack (&amp;number_stack);
    }
  }
  return 0;
}

/* Opérations sur les nombres unaires.  */
#include <assert.h>
#include <stdlib.h>
#include <limits.h>
#include "definitions.h"
/* Crée un nombre représentant zéro.  */
number make_zero ()
{
  return 0;
}
/* Renvoie une valeur différente de zéro si le nombre représente un zéro.  */
int zerop (number n)
{
  return n == 0;
}
/* Soustrait 1 à un nombre positif.  */
number decrement_number (number n)
{
  number answer;
  assert (!zerop (n));
  answer = n->one_less_;
  free (n);
  return answer;
}
/* Ajoute 1 à un nombre.  */
number add_one (number n)
{
  number answer = malloc (sizeof (struct LinkedListNumber));
  answer->one_less_ = n;
  return answer;
}
/* Détruit un nombre.  */
void destroy_number (number n)
{
  while (!zerop (n))
    n = decrement_number (n);
}
/* Copie un nombre. Cette fonction n'est nécessaire qu'à
   cause de l'allocation mémoire. */
number copy_number (number n)
{
  number answer = make_zero ();
  while (!zerop (n)) {
    answer = add_one (answer);
    n = n->one_less_;
  }
  return answer;
}
/* Additionne deux nombres.  */
number add (number n1, number n2)
{
  number answer = copy_number (n2);
  number addend = n1;
  while (!zerop (addend)) {
    answer = add_one (answer);
    addend = addend->one_less_;
  }
  return answer;
}
/* Soustrait un nombre d'un autre.  */
number subtract (number n1, number n2)
{
  number answer = copy_number (n1);
  number subtrahend = n2;
  while (!zerop (subtrahend)) {
    assert (!zerop (answer));
    answer = decrement_number (answer);
    subtrahend = subtrahend->one_less_;
  }
  return answer;
}
/* Renvoie le produit de deux nombres.  */
number product (number n1, number n2)
{
  number answer = make_zero ();
  number multiplicand = n1;
  while (!zerop (multiplicand)) {
    number answer2 = add (answer, n2);
    destroy_number (answer);
    answer = answer2;
    multiplicand = multiplicand->one_less_;
  }
  return answer;
}
/* Renvoie une valeur différente de zéro si un nombre est
   pair.  */
number even (number n)
{
  if (zerop (n))
    return add_one (make_zero ());
  else
    return odd (n->one_less_);
}
/* Renvoie une valeur différente de zéro si un nombre est
   impair.  */
number odd (number n)
{
  if (zerop (n))
    return make_zero ();
  else
    return even (n->one_less_);
}
/* Convertit une chaîne représentant un entier décimal en un "number". */
number string_to_number (char * char_number)
{
  number answer = make_zero ();
  int num = strtoul (char_number, (char **) 0, 0);
  while (num != 0) {
    answer = add_one (answer);
    --num;
  }
  return answer;
}
/* Convertit un "number" en "unsigned int".  */
unsigned number_to_unsigned_int (number n)
{
  unsigned answer = 0;
  while (!zerop (n)) {
    n = n->one_less_;
    ++answer;
  }
  return answer;
}

/* Implante une pile de "number"s.  */
#include <assert.h>
#include <stdlib.h>
#include "definitions.h"
/* Crée une pile vide.  */
Stack create_stack ()
{
  return 0;
}
/* Renvoie une valeur différente de zéro si la pile est vide.  */
int empty_stack (Stack stack)
{
  return stack == 0;
}
/* Supprime le number situé au sommet d'une pile non vide.
   Échoue si la pile est vide. */
number pop_stack (Stack* stack)
{
  number answer;
  Stack rest_of_stack;
  assert (!empty_stack (*stack));
  answer = (*stack)->element_;
  rest_of_stack = (*stack)->next_;
  free (*stack);
  *stack = rest_of_stack;
  return answer;
}
/* Ajoute un number au début de la pile.  */
void push_stack (Stack* stack, number n)
{
  Stack new_stack = malloc (sizeof (struct StackElement));
  new_stack->element_ = n;
  new_stack->next_ = *stack;
  *stack = new_stack;
}
/* Supprime tous les éléments de la pile.  */
void clear_stack (Stack* stack)
{
  while (!empty_stack (*stack)) {
    number top = pop_stack (stack);
    destroy_number (top);
  }
}

#ifndef DEFINITIONS_H
#define DEFINITIONS_H 1
/* Implante un number en utilisant une liste chaînée.  */
struct LinkedListNumber
{
   struct LinkedListNumber*
                 one_less_;
};
typedef struct LinkedListNumber* number;
/* Implante une pile de numbers sous forme de liste chaînée. Utilise 0 pour
   représenter une pile vide. */
struct StackElement
{
   number        element_;
   struct        StackElement* next_;
};
typedef struct StackElement* Stack;
/* Opérations sur les piles de numbers. */
Stack create_stack ();
int empty_stack (Stack stack);
number pop_stack (Stack* stack);
void push_stack (Stack* stack, number n);
void clear_stack (Stack* stack);
/* Operations sur les numbers. */
number make_zero ();
void destroy_number (number n);
number add (number n1, number n2);
number subtract (number n1, number n2);
number product (number n1, number n2);
number even (number n);
number odd (number n);
number string_to_number (char* char_number);
unsigned number_to_unsigned_int (number n);
#endif /* DEFINITIONS_H */