Re: algorithm, two implementations that act the same, same type etc

[Mehdi Saada <00120260a@gmail.com>]

>> I'll refactor stuff and you'll tell if that complies with your standard. 
I hope that's better.
------------------
body part of "p_expression_a.a_moi")
   function Computation (V: in T_Vect_Token) return integer is separate;
   function Calcul(V: in T_Vect_Token) return Integer renames Computation;
----------------------
separate (P_Expression.A_Moi)
function Computation ( V : in T_Vect_Token) return Integer is
   
   package P_stack is new P_Pile_4(T_Elem   => Integer,
                                   Max_Pile => 80);

   -- call on stack package
   
   subtype T_stack is P_stack.T_Pile;
   subtype T_Token_Operand is T_Token_Operande;
   subtype T_Token_Operator is T_Token_Operateur;
   procedure Stack_Uppon (A_Stack : in out T_stack; Elem: Integer)
                          renames P_stack.Empiler;
   procedure Pop (A_Stack: in out T_STACK; Elem: out Integer)
                  renames P_stack.Depiler;
   function Is_Stack_Empty (A_Stack: T_stack) return Boolean
                            renames P_stack.Pile_Vide;
   Exception_Wrong_Token : exception renames P_Expression.Exc_Erreur;
   
   -- renamings for conveniance, avoids usage of "use"
   
   Stack_for_Operands : T_stack(40);
   Operand_1, Operand_2: Integer;
   
begin
   
   -- Loop runs through the token vector, if it's an operand it's stacked,
   -- if it's an operator the last two operands stacked are recovered and the computation made,
   -- but in the inverse order of the recovered operands, or "/" and "-" would misbehave.
   
   for I in V'Range loop
      
      -- Tag comparisons to choose decision
     
      if V(I).all'Tag = T_Token_Operand'Tag then

         Stack_Uppon(Stack_for_operands,T_Token_Operand(v(I).all).Get_Elem);

      -- Get the value  to stack       

      elsif V(I).all'Tag = T_Token_Operateur'Tag then
         
         Pop(Stack_for_operands,Operand_2);
         Pop(Stack_for_operands,Operand_1);
         
         -- decision over which operator to apply.
         
         case T_Token_Operateur(v(I).all).L_Operateur is
            when '*' => Stack_Uppon(Stack_for_operands,Operand_1 * Operand_2);
            when '-' => Stack_Uppon(Stack_for_operands,Operand_1 - Operand_2);
            when '+' => Stack_Uppon(Stack_for_operands,Operand_1 + Operand_2);
            when '/' => Stack_Uppon(Stack_for_operands,Operand_1 / Operand_2);
         end case;
         
      else raise P_Expression.Exc_Erreur
         with "wrong token inserted please review previous steps";
         
         -- if any wrong token (parentheses, terminator) has still crept in
         -- from the previous steps. Or if the vector is invalid and it has not been seen,
      
      end if;
   end loop;
     
   declare
      Result: INTEGER renames Operand_1;  
      -- clarity rules !
   begin
      Pop(A_Stack => Stack_for_Operands,
          Elem     => Result);
      pragma Assert (Is_Stack_Empty(Stack_for_operands)
                     and (P_Expression.Calcul(V) = Result));
      return Result;
   end;
exception
   when P_stack.Exc_Pile_Vide => Put_Line("Invalidity not recognized by previous subroutine");
return 0;
   when E: others => Put_Line(Exception_Information(E)); return 0;
end Computation;