/*!\file postfix.h * * \author SOUPLET Antoine * \version 1.0 * \date 09-01-2012 * * \brief Fichier contenant les entêtes des fonctions de traitement de la transformation d'une chaine infixe en postfixe et du calcul de celle-ci (contenues dans postfix.c) * */ #include "stack.h" /*!\fn double calculPostfix(char* pc_postfix, double d_X, double d_Y) * * \author SOUPLET Antoine * \version 1.0 * \date 09-01-2012 * * \brief Calcule une expression postfixe * * \pre * \post * * \param pc_postfix : Une chaine de caractère correspondant à l'expression postfixe * \param d_X : Un réel représentant l'abscisse du point auquel on effectue la transformation flamme * \param d_Y : Un réél représentant l'ordonnée du point auquel on effectue la transformation flamme * \return Un double correspondant au résultat après calcul de l'expression postfixe * */ double calculPostfix(char* pc_postfix, double d_X, double d_Y); /*!\fn int calcNumeralOperand(int i_cpt, char* pc_postfix, stack** st_stack) * * \author SOUPLET Antoine * \version 1.0 * \date 09-01-2012 * * \brief Réalise le traitement d'un opérand numérique * * \pre * \post * * \param i_cpt : Un entier représentant la position du caractère en cours de lecture dans l'expression postfixe (ce caractère correspond à l'opérand en cours de calcul) * \param pc_postfix : Une chaine de caractère représentant l'expression postfixe * \param st_stack : Un pointeur vers une pile permettant le calcul de l'expression postfixe * \return Un entier correspondant à la nouvelle position à lire dans la chaine de caractère postfixe * */ int calcNumeralOperand(int i_cpt, char* pc_postfix, stack** st_stack); /*!\fn double calcDualOperator(char c_operator, stack** st_stack) * * \author SOUPLET Antoine * \version 1.0 * \date 09-01-2012 * * \brief Réalise le traitement d'un opérateur binaire (un opérateur prenant en paramètre deux opérandes) * * \pre * \post * * \param c_operator : Un caractère correspondant au caractère en cours de lecture (un opérateur) * \param st_stack : Un pointeur vers une pile permettant le calcul de l'expression postfixe * \return Un réel correspondant à la valeur calculée * */ double calcDualOperator(char c_operator, stack** st_stack); /*!\fn double calcSimpleOperator(char c_operator, stack** st_stack) * * \author SOUPLET Antoine * \version 1.0 * \date 09-01-2012 * * \brief Réalise le traitement d'un opérateur unitaire (un opérateur prenant en paramètre un seul opérande) * * \pre * \post * * \param c_operator : Un caractère correspondant au caractère en cours de lecture (un opérateur) * \param st_stack : Un pointeur vers une pile permettant le calcul de l'expression postfixe * \return Un réel correspondant à la valeur calculée * */ int calcSimpleOperator(char c_operator, stack** st_stack); /*!\fn char* infixToPostfix(char* pc_infix) * * \author SOUPLET Antoine * \version 1.0 * \date 09-01-2012 * * \brief Transforme une expression mathématique infixe en une expression mathématique de type postfixe, évitant ainsi de gérer les parenthèses lors du calcul de l'expression mathématique * * \pre * \post * * \param pc_infix : Une chaine de caractère correspondant à l'expression infixe * \return Une chaine de caractère correspondant à l'expression postfixe * */ char* infixToPostfix(char* pc_infix); /*!\fn void processEndOfStack(stack** st_stack, char* pc_postfix) * * \author SOUPLET Antoine * \version 1.0 * \date 09-01-2012 * * \brief Ajoute à l'expression postfixe les derniers éléments contenus dans la pile * * \pre * \post * * \param st_stack : Un pointeur vers une pile correspondant à la pile contenant les éléments à dépiler et à concatener à l'expression postfixe * \param pc_postfix : Une chaine de caractère correspondant à l'expression postfixe * */ void processEndOfStack(stack** st_stack, char* pc_postfix); /*!\fn processParenthesisOpen(stack** st_stack) * * \author SOUPLET Antoine * \version 1.0 * \date 09-01-2012 * * \brief Réalise le traitement des parenthèses ouvrantes lors de la transformation d'une chaine infixe en postfixe * * \pre * \post * * \param st_stack : Un pointeur vers une pile utilisé pour le calcul d'une expression postfixe, ici on empile le caractère lu, c'est à dire la parenthèse ouvrante * */ void processParenthesisOpen(stack** st_stack); /*!\fn void processParenthesisClose(stack** st_stack, char* pc_postfix) * * \author SOUPLET Antoine * \version 1.0 * \date 09-01-2012 * * \brief Réalise le traitement des parenthèses fermantes lors de la transformation d'une chaine infixe en postfixe * * \pre * \post * * \param st_stack : Un pointeur vers une pile utilisé pour le calcul d'une expression postfixe * \param pc_postfix : Une chaine de caractère correspondant à l'expresion postfixe * */ void processParenthesisClose(stack** st_stack, char* pc_postfix); /*!\fn int processOperator(int i_cpt, stack** st_stack, char* pc_infix, char* pc_postfix) * * \author SOUPLET Antoine * \version 1.0 * \date 09-01-2012 * * \brief Réalise le traitement des opérateur lors de la transformation d'une expression infixe en postfixe * * \pre * \post * * \param i_cpt : Un entier correspondant à la position du caractère en cours de lecture (ici un opérateur) * \param st_stack : Un pointeur vers une pile utilisé pour le calcul d'une expression postfixe * \param pc_infix : Une chaine de caractère correspondant à l'expression infixe * \param pc_postfix : Une chaine de caractère correspondant à l'expression postfixe * \return Un entier, 1 si tout c'est bien passé, 0 sinon * */ int processOperator(int i_cpt,stack** st_stack, char* pc_infix, char* pc_postfix); /*!\fn int processOperand(int i_cpt, char* pc_infix, char* pc_postfix) * * \author SOUPLET Antoine * \version 1.0 * \date 09-01-2012 * * \brief Réalise le traitement d'un opérande lors de la transformation d'une expression infixe en postfixe * * \pre * \post * * \param i_cpt : Un entier correspondant à la position du caractère en cours de lecture (ici un opérande) * \param pc_infix : Une chaine de caractère correspondant à l'expression infixe * \param pc_postfix : Une chaine de caractère correspondant à l'expression postfixe * \return Un entier, 1 si tout c'est bien passé, 0 sinon * */ int processOperand(int i_cpt, char* pc_infix, char* pc_postfix); /*!\fn int priority(char c_operator) * * \author SOUPLET Antoine * \version 1.0 * \date 09-01-2012 * * \brief Retourne la priorité de l'opérateur passé en paramètre * * \pre * \post * * \param c_operator : Un caractère correspondant au caractère en cours de lecture, ici un opérateur * \return Un entier correspondant à la valeur de la priorité de l'opérateur, plus celle-ci est élevé, plus l'opérateur est prioritaire * */ int priority(char c_operator); /*!\fn int isOperator(char c_op) * * \author SOUPLET Antoine * \version 1.0 * \date 10-01-2012 * * \brief Teste si le caractère passé en paramètre correspond à un opérateur. Retourne le nombre de caractère de cet opérateur si celui-ci en est un, 0 sinon. * * \pre * \post * * \param c_op : Un caractère correspondant au caractère en cours de lecture * \return Un entier correspondant au nombre de caractère de l'opérateur passé en paramètre, ou 0 si le caractère en question n'est pas un opérateur * */ int isOperator(char c_op); /*!\fn int isOperator2(char c_op) * * \author SOUPLET Antoine * \version 1.0 * \date 10-01-2012 * * \brief Teste en association avec isOperator si le caractère passé en paramètre correspond à un opérateur. Retourne le nombre de caractère de cet opérateur si celui-ci en est un, 0 sinon. * * \pre * \post * * \param c_op : Un caractère correspondant au caractère en cours de lecture * \return Un entier correspondant au nombre de caractère de l'opérateur passé en paramètre, ou 0 si le caractère en question n'est pas un opérateur * */ int isOperator2(char c_op); /*!\fn int isOperand(char c_op) * * \author SOUPLET Antoine * \version 1.0 * \date 10-01-2012 * * \brief Teste si le caractère passé en paramètre correspond à un opérande. * * \pre * \post * * \param c_op : Un caractère correspondant au caractère en cours de lecture * \return Un entier correspondant au type de l'opérande (1 ou 2), ou 0 si le caractère en cours de lecture n'est pas un opérande * */ int isOperand(char c_op); /*!\fn int isDualOperator(char c_operator) * * \author SOUPLET Antoine * \version 1.0 * \date 10-01-2012 * * \brief Teste si l'opérateur est binaire * * \pre * \post * * \param c_operator : Un caractère correspondant au caractère en cours de lecture, ici un opérateur * \return Un entier, 1 si le caractère en cours de lecture est un opérateur binaire, 0 sinon * */ int isDualOperator(char c_operator); /*!\fn void calcOperand(int i_operandNumber, stack** st_stack, double d_X, double d_Y) * * \author SOUPLET Antoine * \version 1.0 * \date 10-01-2012 * * \brief Réalise le traitement d'un opérande lors du calcul de l'expression postfixe * * \pre * \post * * \param i_operandNumber : Un entier correspondant au numéro de l'opérande * \param st_stack : Un pointeur vers une pile utilisée lors du calcul de l'expression postfixe * \param d_X : Un réél représentant l'abscisse du point auquel on effectue la transformation flamme * \param d_Y : Un réél représentant l'ordonnée du point auquel on effectue la transformation flamme * */ void calcOperand(int i_operandNumber, stack** st_stack, double d_X, double d_Y); /*!\fn int isParticularOperand(char c_op) * * \author SOUPLET Antoine * \version 1.0 * \date 10-01-2012 * * \brief Teste si le l'opérande est un opérande particulier (pas un chiffre) * * \pre * \post * * \param c_op : Un caractère correspondant au caractère en cours de lecture * \return Un entier, 0 si le caractère n'est pas un opérande spécifique (un chiffre), un entier positif correspondant à l'opérande spécifique sinon * */ int isParticularOperand(char c_op); /*!\fn void filterNegative(char* pc_infix) * * \author SOUPLET Antoine * \version 1.0 * \date 09-01-2012 * * \brief Ajoute un 0 devant les signes + et - afin que l'analyseur syntaxique puisse les interpréter comme des opérateurs + et - * * \pre * \post * * \param pc_infix : Une chaine de caractère représentant l'expression infixe à modifier * */ void filterNegative(char* pc_infix); /*!\fn previousIsOperator(char* pc_infix, int i_cpt) * * \author SOUPLET Antoine * \version 1.0 * \date 10-01-2012 * * \brief Teste si le caractère précédent est un opérateur * * \pre * \post * * \param pc_infix : Une chaine de caractère représentant l'expression infixe * \param i_cpt : Un entier représentant la position du caractère en cours de lecture * \return Un entier, 1 si ke caractère précédent correspond à un opérateur, 0 sinon * */ int previousIsOperator(char* pc_infix, int i_cpt);