(Octobre 2015) Créez une calculatrice

#include <cassert>
#include <cmath>
#include <iostream>
#include <map>
#include <sstream>
#include <string>

#include <llvm/IR/DerivedTypes.h>
#include <llvm/IR/IRBuilder.h>
#include <llvm/IR/LLVMContext.h>
#include <llvm/IR/Module.h>
#include <llvm/IR/Verifier.h>
#include <llvm/IR/Intrinsics.h>
#include <llvm/ExecutionEngine/ExecutionEngine.h>
#include <llvm/ExecutionEngine/MCJIT.h>
#include <llvm/Support/TargetSelect.h>

namespace Token
{
        enum Type
        {
                eof = -1,
                number = -2
        };
}

class InvalidInput : public std::exception
{};

class Lexer
{
        public:
        Lexer() : line_{}, number_{0.0}, last_{'\0'}, last_token_{Token::eof}
        {}

        Lexer(Lexer const&) = delete;
        Lexer& operator=(Lexer const&) = delete;

        Lexer(Lexer&&) = default;
        Lexer& operator=(Lexer&&) = default;

        ~Lexer() = default;

        void newline(std::string&& line)
        {
                line_ = std::istringstream{std::move(line)};
                last_ = ' ';
        }

        char next()
        {
                if (!is_valid())
                        return Token::eof;

                while (std::isspace(last_))
                        last_ = static_cast<char>(line_.get());

                if (last_ == decltype(line_)::traits_type::eof())
                        return last_token_ = Token::eof;

                if (std::isdigit(last_) || last_ == '.')
                {
                        std::string str_num{};
                        bool decimal{last_ == '.'};
                        do
                        {
                                str_num += last_;
                                last_ = static_cast<char>(line_.get());
                                if (last_ == '.')
                                        decimal = decimal ? throw InvalidInput{} : true;
                        } while (std::isdigit(last_) || last_ == '.');
                        try
                        {
                                number_ = stod(str_num);
                        }
                        catch (std::logic_error const&)
                        {
                                throw InvalidInput{};
                        }
                        return last_token_ = Token::number;
                }
                last_token_ = last_;
                last_ = static_cast<char>(line_.get());
                return last_token_;
        }

        double number() const
        {
                assert(last_token_ == Token::number);
                return number_;
        }

        bool is_valid() const
        {
                return line_.good();
        }

        private:
        std::istringstream line_;
        double number_;
        char last_;
        char last_token_;
};

class ExprTree
{
        public:
        virtual ~ExprTree() = default;

        virtual llvm::Value* codegen(llvm::Module&, llvm::IRBuilder<>&) = 0;
};

class NumberTree : public ExprTree
{
        public:
        NumberTree(double number) : ExprTree{}, number_{number}
        {}

        llvm::Value* codegen(llvm::Module&, llvm::IRBuilder<>&) override
        {
                return llvm::ConstantFP::get(llvm::getGlobalContext(), llvm::APFloat(number_));
        }

        private:
        double number_;
};

class UnaryExprTree : public ExprTree
{
        public:
        UnaryExprTree(char op, std::unique_ptr<ExprTree> st)
                : op_{op}, st_{std::move(st)}
        {}

        llvm::Value* codegen(llvm::Module& module, llvm::IRBuilder<>& builder) override
        {
                auto strep = st_->codegen(module, builder);

                switch (op_)
                {
                        case '-':
                                return builder.CreateFNeg(strep, "neg");
                        default:
                                throw InvalidInput{};
                }
        }

        private:
        char op_;
        std::unique_ptr<ExprTree> st_;
};

class BinaryExprTree : public ExprTree
{
        public:
        using Node = std::unique_ptr<ExprTree>;

        BinaryExprTree(char op, Node lhs, Node rhs)
                : op_{op}, lhs_{std::move(lhs)}, rhs_{std::move(rhs)}
        {}

        llvm::Value* codegen(llvm::Module& module, llvm::IRBuilder<>& builder) override
        {

                auto lrep = lhs_->codegen(module, builder);
                auto rrep = rhs_->codegen(module, builder);

                llvm::Function* pow_fn{nullptr};
                if ((pow_fn = module.getFunction("llvm.pow.f64.f64")) == nullptr)
                {
                        std::vector<llvm::Type*> args_type{llvm::Type::getDoubleTy(llvm::getGlobalContext()),
                                                           llvm::Type::getDoubleTy(llvm::getGlobalContext())};
                        pow_fn = llvm::Intrinsic::getDeclaration(&module, llvm::Intrinsic::pow, args_type);
                }

                switch (op_)
                {
                        case '+':
                                return builder.CreateFAdd(lrep, rrep, "add");
                        case '-':
                                return builder.CreateFSub(lrep, rrep, "sub");
                        case '*':
                                return builder.CreateFMul(lrep, rrep, "mul");
                        case '/':
                                return builder.CreateFDiv(lrep, rrep, "div");
                        case '^':
                                return builder.CreateCall(pow_fn, {lrep, rrep}, "pow");
                        default:
                                throw InvalidInput{};
                }
        }

        private:
        char op_;
        Node lhs_;
        Node rhs_;
};

int operator_precedence(char op)
{
        static std::map<char, int> ops
        {{'+', 10},
         {'-', 10},
         {'*', 20},
         {'/', 20},
         {'^', 30}};

        if (ops.find(op) == std::end(ops))
                return -1;
        return ops[op];
}

enum class Associativity
{
        left,
        right,
        unknown
};

Associativity operator_associativity(char op)
{
        static std::map<char, Associativity> ops
        {{'+', Associativity::left},
         {'-', Associativity::left},
         {'*', Associativity::left},
         {'/', Associativity::left},
         {'^', Associativity::right}};

        if (ops.find(op) == std::end(ops))
                return Associativity::unknown;
        return ops[op];
}

class Parser
{
        public:
        Parser() : lex_{nullptr}, cur_tok_{Token::eof}
        {}

        Parser(Parser const&) = delete;
        Parser& operator=(Parser const&) = delete;

        Parser(Parser&&) = default;
        Parser& operator=(Parser&&) = default;

        ~Parser() = default;

        std::unique_ptr<ExprTree> parse(Lexer& lex)
        {
                lex_ = &lex;
                cur_tok_ = lex_->next();
                auto ast = parse_expr_();
                if (cur_tok_ != Token::eof)
                        throw InvalidInput{};
                return ast;
        }

        private:
        std::unique_ptr<ExprTree> parse_expr_()
        {
                std::unique_ptr<ExprTree> lhs{nullptr};
                if (cur_tok_ == '-')
                {
                        auto un_op = cur_tok_;
                        cur_tok_ = lex_->next();
                        lhs = std::make_unique<UnaryExprTree>(un_op, parse_top_());
                }
                else
                        lhs = parse_top_();
                return parse_binary_rhs_(0, std::move(lhs));
        }

        std::unique_ptr<ExprTree> parse_top_()
        {
                switch (cur_tok_)
                {
                        case Token::number:
                                return parse_number_();
                        case '(':
                                return parse_paren_();
                        default:
                                throw InvalidInput{};
                }
        }

        std::unique_ptr<ExprTree> parse_number_()
        {
                auto res = std::make_unique<NumberTree>(lex_->number());
                cur_tok_ = lex_->next();
                for (auto op : {'+', '-', '*', '/', '^', ')', static_cast<char>(Token::eof)})
                {
                        if (cur_tok_ == op)
                                return std::move(res);
                }
                throw InvalidInput{};
        }

        std::unique_ptr<ExprTree> parse_paren_()
        {
                cur_tok_ = lex_->next();
                auto ex = parse_expr_();
                if (cur_tok_ != ')')
                        throw InvalidInput{};
                cur_tok_ = lex_->next();
                return ex;
        }

        std::unique_ptr<ExprTree> parse_binary_rhs_(int expr_prec, std::unique_ptr<ExprTree> lhs)
        {
                while (1)
                {
                        auto cur_prec = operator_precedence(cur_tok_);
                        if (cur_prec < expr_prec)
                                return lhs;
                        auto bin_op = cur_tok_;
                        cur_tok_ = lex_->next();

                        auto rhs = parse_top_();
                        auto next_op = cur_tok_;
                        auto next_prec = operator_precedence(next_op);
                        while (cur_prec < next_prec ||
                            (operator_associativity(next_op) == Associativity::right && cur_prec == next_prec))
                        {
                                rhs = parse_binary_rhs_(next_prec, std::move(rhs));
                                next_op = cur_tok_;
                                next_prec = operator_precedence(next_op);
                        }

                        lhs = std::make_unique<BinaryExprTree>(bin_op, std::move(lhs), std::move(rhs));
                }
        }

        Lexer* lex_;
        char cur_tok_;
};

int main()
{
        llvm::InitializeNativeTarget();
        llvm::InitializeNativeTargetAsmParser();
        llvm::InitializeNativeTargetAsmPrinter();

        Lexer lex{};
        Parser p{};
        std::ostringstream out{};
        std::string in{};
        std::cout << "Use Ctrl^C to exit.\n";
        while (1)
        {
                try
                {
                        auto module = std::make_unique<llvm::Module>("Calc", llvm::getGlobalContext());
                        llvm::IRBuilder<> builder{llvm::getGlobalContext()};
                        std::cout << "> ";
                        std::getline(std::cin, in);
                        lex.newline(std::move(in));
                        auto ast = p.parse(lex);
                        auto calc_type = llvm::FunctionType::get(llvm::Type::getDoubleTy(llvm::getGlobalContext()), {}, false);
                        auto calc_main = llvm::Function::Create(calc_type, llvm::Function::InternalLinkage, "cmain", module.get());

                        auto block = llvm::BasicBlock::Create(llvm::getGlobalContext(), "entry", calc_main);
                        builder.SetInsertPoint(block);
                        builder.CreateRet(ast->codegen(*module, builder));
                        llvm::verifyFunction(*calc_main);

                        std::unique_ptr<llvm::ExecutionEngine> engine{llvm::EngineBuilder{std::move(module)}.create()};
                        engine->finalizeObject();

                        auto tmp = engine->getPointerToFunction(calc_main);
                        auto cmain = reinterpret_cast<double(*)()>(reinterpret_cast<intptr_t>(tmp));
                        std::cout << cmain() << '\n';
                }
                catch (InvalidInput const&)
                {
                        std::cout << "Invalid input.\n";
                }
        }
}

package info.kisai.zds.calculator;

import java.util.Deque;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.function.BiFunction;

/**
 * Created by spacefox on 04/10/15.
 */
public class 역폴란드표기법계산기 {

    private static final Map<String, BiFunction<Double, Double, Double>> 운영자 = new HashMap<>();
    static {
        운영자.put("+", (운1, 운2) -> 운1 + 운2);
        운영자.put("-", (운1, 운2) -> 운1 - 운2);
        운영자.put("*", (운1, 운2) -> 운1 * 운2);
        운영자.put("/", (운1, 운2) -> 운1 / 운2);
        운영자.put("^", (운1, 운2) -> Math.pow(운1, 운2));
    }

    private Deque<Double> 스택 = new LinkedList<>();

    public double 평가(String 입력) {
        스택.clear();
        String[] 요소 = 입력.split(" ");
        for (String 요 : 요소) {
            if (운영자.containsKey(요)) {
                double 운1 = 스택.pop();
                double 운2 = 스택.pop();
                스택.push(운영자.get(요).apply(운2, 운1));
            } else {
                스택.push(Double.parseDouble(요));
            }
        }
        return 스택.pop();
    }
}

package info.kisai.zds.calculator;

import java.util.Scanner;

public class 명령줄인터페이스 {

    private 역폴란드표기법계산기 계산기 = new 역폴란드표기법계산기();

    private void 표시() {
        Scanner 스캐너 = new Scanner(System.in);
        String 입력;
        System.out.println("Calculatrice en notation polonaise inversée");
        System.out.println("Tapez « q » pour quitter");
        while (true) {
            입력 = 스캐너.nextLine();
            if ("q".equalsIgnoreCase(입력)) {
                System.out.println("Au revoir !");
                return;
            }
            System.out.println(계산기.평가(입력));
        }
    }

    public static void main(String... args) {
        new 명령줄인터페이스().표시();
    }
}

package info.kisai.zds.calculator;

import java.util.Deque;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.function.BiFunction;

/**
 * Created by spacefox on 04/10/15.
 */
public class RPNCalculator {

    private static final Map<String, BiFunction<Double, Double, Double>> OPERATORS = new HashMap<>();
    static {
        OPERATORS.put("+", (o1, o2) -> o1 + o2);
        OPERATORS.put("-", (o1, o2) -> o1 - o2);
        OPERATORS.put("*", (o1, o2) -> o1 * o2);
        OPERATORS.put("/", (o1, o2) -> o1 / o2);
        OPERATORS.put("^", (o1, o2) -> Math.pow(o1, o2));
    }

    private Deque<Double> stack = new LinkedList<>();

    public double eval(String in) {
        stack.clear();
        String[] elements = in.split(" ");
        for (String e : elements) {
            if (OPERATORS.containsKey(e)) {
                double o1 = stack.pop();
                double o2 = stack.pop();
                stack.push(OPERATORS.get(e).apply(o2, o1));
            } else {
                stack.push(Double.parseDouble(e));
            }
        }
        return stack.pop();
    }
}

package info.kisai.zds.calculator;

import java.util.Scanner;

public class CLI {

    private RPNCalculator calculator = new RPNCalculator();

    private void show() {
        Scanner scanner = new Scanner(System.in);
        String in;
        System.out.println("Calculatrice en notation polonaise inversée");
        System.out.println("Tapez « q » pour quitter");
        while (true) {
            in = scanner.nextLine();
            if ("q".equalsIgnoreCase(in)) {
                System.out.println("Au revoir !");
                return;
            }
            System.out.println(calculator.eval(in));
        }
    }

    public static void main(String... args) {
        new CLI().show();
    }
}

use std::io;

fn main() {
    let mut pile: Vec<f64> = Vec::new(); //> Seule annotation de type nécessaire

    let mut entree = String::new();
    io::stdin().read_line(&mut entree)
        .ok()
        .expect("Failed to read line");
    println!("You guessed: {}", entree);
    //entree contient la chaine non formatté.

    //> entree.split_whitespace() est directment un itérateur
    for element in entree.split_whitespace() {
        match element {
            "+" => {
                let nombre = pile.pop().expect("Empty pile!");
                let nombre2 = pile.pop().expect("Empty pile!");
                pile.push(nombre + nombre2);
            },
            "-" => {
                let nombre = pile.pop().expect("Empty pile!");
                let nombre2 = pile.pop().expect("Empty pile!");
                pile.push(-nombre + nombre2);
            },
            "*" => {
                let nombre = pile.pop().expect("Empty pile!");
                let nombre2 = pile.pop().expect("Empty pile!");
                pile.push(nombre*nombre2);
            },
            "/" => {
                let nombre = pile.pop().expect("Empty pile!");
                let nombre2 = pile.pop().expect("Empty pile!");
                pile.push(1./nombre*nombre2);
            },
            "^" => {
                let nombre = pile.pop().expect("Empty pile!");
                let nombre2 = pile.pop().expect("Empty pile!");
                pile.push(nombre2.powf(nombre));
            },
            _ => {
            //C'est alors un nombre.
                let nombre = element.trim().parse().ok().expect("Please type a number!");
                pile.push(nombre);
            }
        }
    }
    println!("Resutlat : {}", pile[0])
}

use std::io;

/// Operators and Numbers constitue an Expr
enum Expr {
    Plus,
    Minus,
    Times,
    Divide,
    Pow,
    Num(f64)
}

/// Parsing a string to get the corresponding Expr. Panic on failure
impl<'a> From<&'a str> for Expr {
    fn from(op: &'a str) -> Expr {
        match op {
            "+" => Expr::Plus,
            "-" => Expr::Minus,
            "*" => Expr::Times,
            "/" => Expr::Divide,
            "^" => Expr::Pow,
            val => {
                if let Ok(number) = val.trim().parse() {
                    Expr::Num(number)
                } else {
                    panic!("Could not parse {}", val);
                }
            }
        }
    }
}

/// Do the computation, panic on failure
fn compute(entry: &str) -> f64 {
    let mut stack: Vec<f64> = Vec::new();
    for token in entry.split_whitespace() {
        match Expr::from(token) {
            Expr::Plus => {
                let a = stack.pop().expect("Empty stack!");
                let b = stack.pop().expect("Empty stack!");
                stack.push(a + b);
            },
            Expr::Minus => {
                let a = stack.pop().expect("Empty stack!");
                let b = stack.pop().expect("Empty stack!");
                stack.push(-a + b);
            },
            Expr::Times => {
                let a = stack.pop().expect("Empty stack!");
                let b = stack.pop().expect("Empty stack!");
                stack.push(a*b);
            },
            Expr::Divide => {
                let a = stack.pop().expect("Empty stack!");
                let b = stack.pop().expect("Empty stack!");
                stack.push(b/a);
            },
            Expr::Pow => {
                let a = stack.pop().expect("Empty stack!");
                let b = stack.pop().expect("Empty stack!");
                stack.push(b.powf(a));
            },
            Expr::Num(number) => {
                stack.push(number);
            }
        }
    }
    assert!(stack.len() == 1);
    stack[0]
}

fn main() {
    let mut buffer = String::new();
    io::stdin().read_line(&mut buffer).ok().expect("Failed to read line");
    println!(" = {}", compute(&buffer));
}

\input apnum % macros de calcul pour tex
\edef\restorecatcode{\catcode\number`\_=\number\catcode`\_\relax}
\catcode`\_11
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%% Macros auxiliaires %%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\newcount\_integer
\edef\op_list{\detokenize{ +:2L -:2L *:3L /:3L ^:4R}}% liste des opérateurs
\def\let_cs#1{\expandafter\let\csname#1\endcsname}
\def\gob_tok#1{}
\def\return_firsttok#1#2\return_firsttok{#1}
\def\exec_first#1#2{#1}
\def\exec_second#1#2{#2}
\def\exp_arg#1#2{\expandafter#1\expandafter{#2}}
\def\swap_arg#1#2{#2{#1}}
\def\exp_second#1#2{\exp_arg\swap_arg{#2}{#1}}
\def\exp_twoargs#1#2#3{\exp_second{\exp_arg#1{#2}}{#3}}
\def\push_onstack#1{\edef\_stack{#1 \_stack}}
\def\pop_fromstack#1{%
  \def\pop_fromstack_a##1 ##2\pop_fromstack_a{\def#1{##1}\def\_stack{##2}}%
  \expandafter\pop_fromstack_a\_stack\pop_fromstack_a
}
\def\peek_fromstack#1{%
  \def\peek_fromstack_a##1 ##2\peek_fromstack_a{\def#1{##1}}%
  \expandafter\peek_fromstack_a\_stack\peek_fromstack_a
}
\def\push_onqueue#1{\edef\infix_out_queue{\infix_out_queue#1 }}
\def\if_empty#1{%
  \if\relax\detokenize{#1}\relax
      \expandafter\exec_first
  \else
      \expandafter\exec_second
  \fi
}
\def\ifstring_start#1#2{% la chaine #1 commence-t-elle par le motif #2 ?
  \def\ifstring_start_a##1#2##2\ifstring_start_a{\if_empty{##1}}%
  \ifstring_start_a#1\relax#2\ifstring_start_a%
}
\def\ifstring_contains#1#2{% la chaine #1 contient-elle le motif #2 ?
  \def\ifstring_contains_a##1#2##2\ifstring_contains_a{\if_empty{##2}\exec_second\exec_first}%
  \ifstring_contains_a#1\relax#2\ifstring_contains_a
}
\def\if_op#1{\exp_twoargs\ifstring_contains\op_list{\detokenize{ #1:}}}
\def\parse_stop{\parse_stop}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%% Macros de nombres  %%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% ------ macro \read_digits -------
\def\read_digits#1#2#3{% lit le max de chiffres dans #1, les met dans la macro #2 et met ce qui reste dans la macro #3
  \let#2\empty \def#3{#1}%
  \if_empty{#1}
      {%
      }
      {% si argument non vide
          \let\collect_digits\empty% collecteur vide
          \read_digits_a#1\parse_stop#3% parser #1
          \let#2\collect_digits% #2:=collecteur
      }%
}
\def\read_digits_a#1{% lit un caractère
  \ifx\parse_stop#1\expandafter\exec_first\else\expandafter\exec_second\fi
      {% fin atteinte ?
          \collect_remaining\parse_stop% ne rien récupérer comme reste
      }
      {% si la fin n'est pas atteinte
          \ifstring_contains{0123456789}{#1}% et si le caractère est un chiffre
              {%
                  \edef\collect_digits{\collect_digits#1}% l'ajouter au collecteur
                  \read_digits_a% lire le caractère suivant
              }
              {% si le caractère n'est pas un chiffre,
                  \collect_remaining#1% récupérer ce qui reste (en rajoutant #1 qui a déjà été lu)
              }%
      }%
}
\def\collect_remaining#1\parse_stop#2{\def#2{#1}}

% ------ macro \read_number -------
% lit un <nombre> au début de #1
%    un <nombre entier>  est <- optionnel><chiffres>
%    un <nombre décimal> est <- optionnel><chiffres optionnels><. optionnel><chiffres optionnels>
%    sous réserve que
%        1) si le séparateur décimal "." est présent, il ait des <chiffres optionnels> au moins d'un coté
%        2) le <signe - optionnel> n'est permis que si le booléen \if_possible_negative est vrai
% le nombre au début de #1 est renvoyé dans la macro #2 et ce qui reste dans la macro #3
% #2 sera vide si #1 ne commence pas par des caractères pouvant former un <nombre>
\newif\if_nointpart
\def\read_number#1#2#3{%
  \def\setmacro_if_fail{\let#2\empty\def#3{#1}}% renvoie vide et #1 (si échec)
  \setmacro_if_fail
  \_nointpartfalse
  \ifstring_start{#1}-
      {% si #1 commence par "-"
          \if_possible_negative\expandafter\exec_first\else\expandafter\exec_second\fi
              {% et un négatif est autorisé
                  \def#2{-}\edef#3{\gob_tok#1}%
                  \exp_arg\read_number_intpart#3#2#3% on poursuit et on lit la partie entière
              }
              {%
              }%
      }
      {%
          \read_number_intpart{#1}#2#3%
      }%
}
\def\read_number_intpart#1#2#3{% #1 est purgé d'un éventuel <- optionnel>
  \ifstring_start{#1}.
      {% pas de partie décimale avant le "." ?
          \_nointparttrue% s'en souvenir...
          \read_number_intpart{0#1}#2#3% et recommencer avec 0 en début de #1
      }
      {%
          \read_digits{#1}\digits_collected\_remaining% lire des chiffres au début de #1
          \exp_arg\if_empty\digits_collected
              {% aucun chiffre lu ?
                  \setmacro_if_fail% macro renvoyée nulle, on s'arrête ici
              }
              {% des chiffres lus ?
                  \edef#2{#2\digits_collected}% les rajouter à la macro renvoyée
                  \exp_arg\read_number_decpart\_remaining#2#3% on poursuit avec ce qui reste pour lire la partie décimale
              }%
      }%
}
\def\read_number_decpart#1#2#3{% on a lu la partie entière dans #1
  \ifstring_start{#1}.
      {% un "." au début : il y a une partie décimale
          \exp_arg\read_digits{\gob_tok#1}\digits_collected\_remaining% manger le "." et lire des chiffres au début de #1
          \exp_arg\if_empty\digits_collected
              {% si aucun chiffre dans la partie décimale
                  \if_nointpart% et qu'il n'y en avait aucun dans la partie entière
                      \setmacro_if_fail% on renvoie vide -> nombre non légal
                  \else% SUCCES : #1 commence par un <nombre>
                      \edef#2{#2.0}% si partie entière : rajouter un "0" en partie décimale
                      \edef#3{\gob_tok#1}% reste : #1 sans le .
                  \fi
              }
              {% si des chiffres sont en partie décimale. SUCCES : #1 commence par un <nombre>
                  \edef#2{#2.\digits_collected}% les rajouter dans la macro
                  \let#3\_remaining
              }%
      }
      {% pas de partie décimale, on s'arrête mais SUCCES : #1 commence par un <nombre>
          \def#3{#1}% reste
      }%
}
\def\if_number#1{%
  \begingroup
      \_possible_negativetrue
      \read_number{#1}\__\_remaining
      \expandafter
  \endgroup
  \expandafter\if_empty\expandafter{\_remaining}%
}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%  Macro \npi  %%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\def\npi{%
  \def\print_input{\detokenize\expandafter{\npi_list} = }%
  \npi_a
}
\def\npi_a#1{%
  \begingroup
      \let_cs+\PLUS \let_cs-\MINUS \let_cs*\MUL \let_cs/\DIV \let_cs^\POW
      \let\_stack\empty
      \edef\npi_list{\romannumeral-`\?#1}%
      \exp_arg\if_empty\npi_list
          {%
              \errmessage{Liste d'instructions vide!}%
          }
          {%
              \print_input% à commenter pour n'avoir que le résultat à l'affichage
              \edef\npi_list{\detokenize\expandafter{\npi_list} \noexpand\parse_stop\space}%
              \expandafter\parse_list\npi_list
          }%
}
\def\parse_list#1 {%
  \ifx\parse_stop#1\expandafter\exec_first\else\expandafter\exec_second\fi
      {%
          \print_stack\endgroup
      }
      {%
          \if_number{#1}
              {%
                  \push_onstack{#1}%
              }
              {%
                  \if_op{#1}
                      {%
                          \pop_fromstack\numB
                          \pop_fromstack\numA
                          \csname#1\endcsname\numA\numB
                          \push_onstack\OUT
                      }
                      {%
                          \errmessage{Erreur de syntaxe dans "#1"}%
                      }%
              }%
          \parse_list
      }%
}
\def\print_stack{\expandafter\print_stack_a\_stack\print_stack_a}
\def\print_stack_a#1 #2\print_stack_a{%
  \if_empty{#2}
      {%
          #1%
      }
      {%
          \errmessage{Pile non unaire : \_stack}%
      }%
}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%% Macro \infix %%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\newif\if_possible_negative
\newif\if_start_withnumber
\def\tokenize_infix_expr{%
  \exp_arg\if_empty\infix_expr
      {%
      }
      {% s'il reste des caractères à tokéniser
      \exp_arg\read_number\infix_expr\return_number\infix_expr% lire un <nombre> au début de \infix_expr
      \exp_arg\if_empty\return_number% si aucun nombre n'est lu
          {% ajouter le 1er caractère+" " à l'expression tokénisée
              \edef\infix_expr_tokenized{\infix_expr_tokenized\expandafter\return_firsttok\infix_expr\return_firsttok\space}%
              \edef\infix_expr{\expandafter\gob_tok\infix_expr}% et le supprimer de ce qui reste à lire
              \_possible_negativetrue% autoriser un négatif
          }
          {% si un nombre est lu, l'ajouter +" " à l'expression tokénisée
              \edef\infix_expr_tokenized{\infix_expr_tokenized\return_number\space}%
              \_possible_negativefalse% interdire un négatif après un nombre
          }%
      \tokenize_infix_expr% continuer la tokénisation
      }%
}
\newif\iftopstack_isop
\def\test_item#1{% teste l'item #1
  \if_op{#1}% si l'item est un opérateur
      {%
          \topstack_isoptrue
          \test_op{#1}\top_op_priority\top_op_associativity
      }
      {%
      }%
}
\def\test_op#1#2#3{%
  \def\test_op_a##1 #1:##2##3##4\test_op_a{\def#2{##2}\def#3{##3}}%
  \expandafter\test_op_a\op_list\test_op_a
}
\def\test_topstack#1{%
  \topstack_isopfalse
  \exp_arg\if_empty{#1}
      {%
      }
      {%
          \peek_fromstack\item_topstack
          \exp_arg\test_item\item_topstack
      }%
}
\def\remove_lastspace#1{%
  \def\remove_lastspace_a##1 \remove_lastspace_a{\def#1{##1}}%
  \expandafter\remove_lastspace_a#1\remove_lastspace_a
}
\def\infix{%
  \begingroup
      \catcode 32 9 % espace ignoré
      \infix_a
}
\def\infix_a#1{% espaces ignorés
  \endgroup
  \if_empty{#1}
      {%
          \errmessage{Expression vide !}%
      }
      {%
      }%
  \let\infix_out_queue\empty
  \let\_stack\empty
  \edef\infix_expr{\detokenize{#1}}%
  \infix_expr\space= % à commenter pour n'avoir que le résultat à l'affichage
  \let\infix_expr_tokenized\empty
  \_possible_negativetrue% en début d'expression infixe : nombre négatif permis
  \tokenize_infix_expr% tokénizer l'expresion infixe
  \edef\infix_expr_tokenized{\infix_expr_tokenized\relax\space}% rajouter un \relax+espace à la fin
  \edef\open_paren{\string(}\edef\close_paren{\string)}%
  \expandafter\parse_infix_expr\infix_expr_tokenized
}
\def\parse_infix_expr#1 {% lit un token
  \ifx#1\relax\expandafter\exec_first\else\expandafter\exec_second\fi
      {% s'il n'y a plus de tokens à lire
          \loop% tant que
              \unless\ifx\_stack\empty% la pile d'op n'est pas vide...
                  \pop_fromstack\top_itemstack% dépiler l'élément du haut de pile
                  \ifx\top_itemstack\open_paren\errmessage{Mauvais appariement entre ( et )}\fi
                  \push_onqueue\top_itemstack% et le mettre sur la file de sortie
          \repeat
          \remove_lastspace\infix_out_queue% enlève l'espace de fin
          \let\print_input\empty% neutralise l'affichage de l'entrée npi
          \exp_arg\npi_a\infix_out_queue% évalue la queue de sortie, en notation npi
      }
      {% tant qu'on n'est pas à la fin de l'expression infixe tokénizée
      \if_number{#1}
          {% si le token #1 est un nombre
          \push_onqueue{#1}% le mettre sur la queue de sortie
          }
          {% si le token n'est pas un nombre
              \if_op{#1}
                  {% si le token est un opérateur op1
                      \loop%  BOUCLER
                          \_integer=0 % entier qui fera ou pas continuer la boucle (pour l'instant 0, càd : non)
                          \test_topstack\_stack% teste le sommet de la pile infixe
                          \iftopstack_isop% s'il y a un opérateur op2, \top_op_priority et \top_op_associativity sont affectées
                              \test_op{#1}\current_op_priority\current_op_associativity% trouve la priorité et associativité de op1
                              \advance\_integer% augmenter \_integer de 1 si 
                                  \numexpr\if L\current_op_associativity1\else0\fi% asso(op1)==L
                                          *% et
                                          \ifnum\current_op_priority>\top_op_priority\space0\else1\fi% prio(op1)<=prio(op2)
                                          +% ou
                                          \if R\current_op_associativity1\else0\fi% asso(op1)==R
                                          *% et
                                          \ifnum\current_op_priority<\top_op_priority\space1\else0\fi% prio(op1)<prio(op2)
                                  \relax
                          \fi
                          \ifnum\_integer>0 % exécuter le corps de la boucle (et répéter plus loin) tant que \_integer>0
                              \pop_fromstack\stacked_op% dépiler op2
                              \push_onqueue\stacked_op% l'enfiler sur file de sortie
                      \repeat% FIN BOUCLE
                      \push_onstack{#1}% empiler op1 sur la pile d'op
                  }
                  {% si le token n'est pas un opérateur
                      \def\current_token{#1}%
                      \ifx\current_token\open_paren\expandafter\exec_first\else\expandafter\exec_second\fi
                          {% si le token lu est une parenthèse ouvrante
                              \push_onstack{#1}% empiler "(" sur la pile d'op
                          }
                          {% si le token n'est pas "("
                              \ifx\current_token\close_paren\expandafter\exec_first\else\expandafter\exec_second\fi
                                  {% si le token lu est ")"
                                      \loop% Répéter...
                                          \ifx\_stack\empty\errmessage{Mauvais appariement entre ( et )}\fi
                                          \peek_fromstack\top_itemstack% prendre l'item en haut de la pile
                                          \unless\ifx\top_itemstack\open_paren% si ce n'est pas "("
                                              \pop_fromstack\top_itemstack% dépiler l'élément du haut de pile
                                              \push_onqueue\top_itemstack% et le mettre sur la file de sortie
                                      \repeat
                                      \pop_fromstack\top_itemstack% dépiler l'élément du haut de pile, qui est "("
                                  }
                                  {%
                                      \errmessage{Erreur de syntaxe dans "#1"}%
                                  }%
                          }%
                  }%
              }%
          \parse_infix_expr% lire le token suivant
      }%
}

\restorecatcode% fin préambule
\npi{3 2 ^ 4 6 + *}% "3^2 * (4 + 6)" donne 90

\npi{10 7 / 2 ^}% "(10 / 7) ^2" donne 2.0408163265306122448734693877551020408164

\npi{5 4 / 7 16 / - 2 3 ^ / 84.5 *}% "(5/4 - 7/16)/(2^3)*84.5" donne 8.58203125

\infix{2*(3-4)+5^-1}% donne -1.8

\infix{10- (9- (8-7) ) *2}% donne -6

\infix{-3.14 - 5.4*-6.5 + 2.3^4}% donne 59.941

\infix{0.123-.456*(0.0007-1.111)^2}% donne -.43914133704
\bye

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <ctype.h>
#include <string.h>

#define MAX_ENTRY 255

#define setToken(_token, _type, s_type, _value)\
    _token.type = _type;\
    _token.data_val.s_type = _value;

double add(double a, double b)
{
    return a+b;
}

double sub(double a, double b)
{
    return b-a;
}

double time(double a, double b)
{
    return a*b;
}

double div_(double a, double b)
{
    return b/a;
}

enum {NONE = 0, OPERATOR, NUMBER};
enum {A_NONE = 0, A_LEFT, A_RIGHT};

struct Operators
{
    char op;
    int precedence;
    int associativity;
    double (*callback)(double, double);
} operators[]=
{
    {'+', 2, A_LEFT, add},
    {'-', 2, A_LEFT, sub},
    {'*', 3, A_LEFT, time},
    {'/', 3, A_LEFT, div_},
    {'^', 4, A_RIGHT, pow}
};

typedef struct pile
{
    char op;
    struct pile *prev;
} Pile;

typedef struct result_pile
{
    double data;
    struct result_pile *prev;
} Result_pile;

union Data_type
{
    int op;
    double data;
};

typedef struct Token
{
    int type;
    union Data_type data_val;
} Token;

typedef struct File
{
    Token token;
    struct File *next;
} File;

void pile_push(Pile **pile, char op)
{
    Pile *tmp = malloc(sizeof(*tmp));

    if(!tmp) exit(EXIT_FAILURE);

    tmp->op = op;
    tmp->prev = *pile;

    *pile = tmp;
}

char pile_pop(Pile **pile)
{
    if(*pile == NULL)
        return -1;

    Pile *tmp = (*pile)->prev;
    char op = (*pile)->op;

    free(*pile), *pile = NULL;
    *pile = tmp;

    return op;
}

int pile_size(Pile *pile)
{
    Pile *tmp = pile;
    int size = 0;

    while(tmp)
    {
        size++;
        tmp = tmp->prev;
    }

    return size;
}

void rpile_push(Result_pile **pile, double data)
{
    Result_pile *tmp = malloc(sizeof(*tmp));

    if(!tmp) exit(EXIT_FAILURE);

    tmp->data = data;
    tmp->prev = *pile;

    *pile = tmp;
}

double rpile_pop(Result_pile **pile)
{
    if(*pile == NULL)
        return -1;

    Result_pile *tmp = (*pile)->prev;
    double data = (*pile)->data;

    free(*pile), *pile = NULL;
    *pile = tmp;

    return data;
}

void file_enqueue(File **file, Token token)
{
    File *tmp = malloc(sizeof(*tmp));

    if(!tmp) exit(EXIT_FAILURE);

    tmp->token = token;
    tmp->next = NULL;

    if(!*file) *file = tmp;

    else
    {
        File *tmp2 = *file;
        while(tmp2->next)
        {
            tmp2 = tmp2->next;
        }
        tmp2->next = tmp;
    }
}

Token file_dequeue(File **file)
{
    Token token;

    if(!*file) exit(EXIT_FAILURE);
    File *tmp = (*file)->next;
    token = (*file)->token;

    free(*file), *file = NULL;
    *file = tmp;

    return token;
}

int getOperatorID(char operator_)
{
    for(int i = 0; i < 5; i++)
    {
        if(operator_ == operators[i].op)
            return i;
    }
    return -1;
}

unsigned int isAnOperator(char c)
{
    return (c == '*' || c == '-' || c == '/' || c == '+' || c == '^');
}

unsigned int isFloat(char c)
{
    return (isdigit(c) || c == '.');
}

void eval_expr(char *str, File **f, Pile **p)
{
    char buffer[MAX_ENTRY] = "";
    Token token;

    int numberSaved = 0;
    int op_queued = 0;
    int p_size = 0;

    for(unsigned i = 0, j = 0; str[i] != '\0'; i++)
    {
        if(isAnOperator(str[i]))
        {
            p_size = pile_size(*p);

            while(p_size--)
            {
                char p_op = pile_pop(p);
                int p_opId = getOperatorID(p_op);
                int s_opId = getOperatorID(str[i]);

                if((operators[s_opId].associativity == A_LEFT &&
                        operators[s_opId].precedence <= operators[p_opId].precedence) ||
                        (operators[s_opId].associativity == A_RIGHT &&
                         operators[s_opId].precedence < operators[p_opId].precedence))
                {
                    setToken(token, OPERATOR, op, p_opId);
                    file_enqueue(f, token);
                    op_queued = 1;
                }

                if(!op_queued) pile_push(p, p_op);

                op_queued = 0;
            }
            pile_push(p, str[i]);
        }
        else if(str[i] == '(')
        {
            pile_push(p, str[i]);
        }
        else if(str[i] == ')')
        {
            char p_op;
            while((p_op = pile_pop(p)) != '(')
            {
                if(isAnOperator(p_op))
                {
                    setToken(token, OPERATOR, op, getOperatorID(p_op));
                    file_enqueue(f, token);
                }
            }
        }

        else if(isFloat(str[i]))
        {
            buffer[j] = str[i];
            j++;
            numberSaved = 0;
        }

        else if(isblank(str[i]) || (i == strlen(str) - 1))
        {
            if(!numberSaved && j > 0)
            {
                setToken(token, NUMBER, data, atof(buffer));
                file_enqueue(f, token);
                memset(buffer, '\0', j);
                j = 0;
                numberSaved = 1;
            }
        }
    }

    p_size = pile_size(*p);
    while(p_size--)
    {
        char p_op = pile_pop(p);
        if(isAnOperator(p_op))
        {
            setToken(token, OPERATOR, op, getOperatorID(p_op));
            file_enqueue(f, token);
        }
    }

}

void print_file(File *f)
{
    File *tmp = f;

    while(tmp != NULL)
    {
        if(tmp->token.type == OPERATOR)
        {
            printf("%c ", operators[tmp->token.data_val.op].op);
        }
        else if(tmp->token.type == NUMBER)
        {
            printf("%f ", tmp->token.data_val.data);
        }
        else puts("dafuq!");

        tmp = tmp->next;
    }
}

double eval_file(File **f)
{
    double a, b;
    double result;
    Result_pile *r_pile = NULL;
    Token token;

    while(*f != NULL)
    {
        token = file_dequeue(f);
        if(token.type == OPERATOR)
        {
            a = rpile_pop(&r_pile);
            b = rpile_pop(&r_pile);
            result = operators[token.data_val.op].callback(a,b);
            rpile_push(&r_pile, result);
        }
        else if(token.type == NUMBER)
        {
            rpile_push(&r_pile, token.data_val.data);
        }
    }

   return r_pile->data;
}

int main(void)
{
    Pile *p_pile = NULL;
    File *p_file = NULL;

    char entry[MAX_ENTRY] = "";
    //double result = 0;

    fgets(entry, sizeof(entry), stdin);
    eval_expr(entry, &p_file, &p_pile);

    puts("\nEn Notation Polonaise Inverse: ");
    print_file(p_file);

    printf("\n\nResultat = %f\n", eval_file(&p_file));

    return 0;
}