Ввод через командную строку

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
 
int ErrCode;
 
double s1[100];  // хранилище чисел
int ptrs1;       // номер первой свободной клетки
 
double s2[100];  // хранилище операций
int ptrs2;       // номер первой свободной клетки
 
// Препроцессор
 
char *prepro(char *formula)
{
 
    int size = strlen(formula);
    
    char *res = (char *) calloc(size*2,sizeof(char));
    int i=0,ir=0;
    
    char a1,a2;
    
    if (formula[0] == '-')
    {
        res[ir++]='0';
    }
 
    if (formula[0] == '+') i++;
    
    while (i < size-1)
    {
        a1=formula[i];
 
        if (a1 != '(')
        {
            res[ir++]=a1;
            i++;
            continue;
        }
        
        a2=formula[i+1];
        
        if (a2 == '-')
        {
            res[ir++]='(';
            res[ir++]='0';
        }
        
        if (a2 == '+') 
        {
           res[ir++]='(';    
           i++;
        }
        
        i++;
        
    }
    
    res[ir]=formula[size-1];
    
    res=realloc(res,ir*sizeof(char)+1);
    
    return res;
 
}
 
// Парсер
 
char ** parse(char *formula, int *nlex)
{
    int par_count=0;
    
    int size = strlen(formula);
    
    char ** Lex = (char **) calloc(size,sizeof(char *));
    int ptrlex  = 0;
    
    char *alex;
    
    char tmp[20] = {0};    // очередная лексема-число
    int ptrt    = 0;
    
    char a;               // очередной символ
    
    for (int i=0; i < size; i++)  // цикл по всем символам формулы
    {
        a=formula[i];
        
        if (a != ' ')  // пропуск пробелов
        {
            if (a == '(') 
               par_count++;
            else if (a == ')')
                    par_count--;
                    
            if (par_count < 0)
            {
  
              ErrCode=2;
                
              // Освобождаем занятую память
             
              for (int t=0; t<ptrlex; t++) free(Lex[t]);
              free(Lex);
                     
              *nlex=0;
              return NULL;
                
            }
 
            if ((a >= '0' && a <= '9') || a == '.')  // числовой символ
            {
                tmp[ptrt++]=a;
            }
            else if (a == '(' || a == ')' || a == '+' || a == '-' || a == '*' || a == '/' || a == '^') // разделитель
                 {
                    if (ptrt > 0)                        // что-то было накоплено
                    {
                       alex= (char *) calloc(ptrt+1,sizeof(char));
                       strcpy(alex,tmp);
                       Lex[ptrlex++]=alex;
                   
                       // чистка tmp
                   
                      for (int t=0; t<20; t++) tmp[t]=0;
                      ptrt=0;
 
                    }
                
                    alex= (char *) calloc(2,sizeof(char));  // лексема-разделитель
                    alex[0]=a;
                    Lex[ptrlex++]=alex;
                }
                else // недопустимый символ
                {
                     printf("Недопустимый символ: %c\n",a);
                     
                     ErrCode=1;
                     
                     // Освобождаем занятую память
                     
                     for (int t=0; t<ptrlex; t++) free(Lex[t]);
                     free(Lex);
                     
                     *nlex=0;
                     return NULL;
                }
 
        }
    } 
    
    // Последняя лексема
    
    if (ptrt > 0)                        // что-то было накоплено
    {
       alex= (char *) calloc(ptrt+1,sizeof(char));
       strcpy(alex,tmp);
       Lex[ptrlex++]=alex;
    }
 
 
    if (par_count != 0)
    {
  
       ErrCode=3;
                
       // Освобождаем занятую память
             
       for (int t=0; t<ptrlex; t++) free(Lex[t]);
           free(Lex);
                     
       *nlex=0;
       return NULL;
                
    }
 
    // Возвращаем лишнюю память
    
    if (ptrlex < size)  Lex=realloc(Lex,ptrlex*sizeof(char *));
    
    *nlex=ptrlex;
 
    return Lex;
 
}
 
// Стек чисел (операндов)
 
void init_s1()
{
    for (int i=0; i<100; i++) s1[i]=0;
    ptrs1=0;  
}
 
void pushN(double x)
{
    s1[ptrs1++]=x;
}
 
double popN()
{
    double x = s1[--ptrs1];
    return x;
}
 
// Стек операций
 
void init_s2()
{
    for (int i=0; i<100; i++) s2[i]=0;
    ptrs2=0;  
}
 
void pushO(char x)
{
    s2[ptrs2++]=x;
}
 
char popO()
{
    char x = s2[--ptrs2];
    return x;
}
 
char peekO()
{
    return s2[ptrs2-1];
}
 
// Приоритеты операций
 
int prty(char o)
{
    switch (o)
    {
        case '(':
           return 0;
        case '+':
        case '-':
           return 1;
        case '*':
        case '/':
           return 2;
        case '^':
           return 3;
        default:
           return -1; // !!!
    }
}
 
// Исполнитель бинарной операции
 
double exec(double a1, double a2, char op)
{
    double r;
    //printf("%lf %c %lf = ",a1,op,a2);
    
    switch (op)
    {
        case '+':
           r=a1+a2;
           break;
           //return a1+a2;
        case '-':
           r=a1-a2;
           break;
           //return a1-a2;
        case '*':
           r=a1*a2;
           break;
           //return a1*a2;
        case '/':
           r=a1/a2;
           break;
           //return a1/a2;
        case '^':
           r=pow(a1,a2);
           break;
        default:
           return 0; // !!!
    }
    
    //printf("%lf\n",r);
    return r;
}
 
// Головная функция вычислителя
 
double calc(char *formula)
{
    char sym,op;
    int nlex,p1,p2;
    double x,a1,a2,r;
    
    ErrCode=0;
 
    char *tmp=prepro(formula);
 
    char **Lex=parse(tmp,&nlex);
    
    if (ErrCode != 0)
    {
        printf("Вычисления не выполнялись!\n");
        return 0;
    }
    
    // Подготовка стеков
    
    init_s1();
    init_s2();
    
    for (int ilex=0; ilex<nlex; ilex++)
    {
        sym=Lex[ilex][0]; // первый символ лексемы
        
        if (sym>='0' && sym<='9') // число
        {
            sscanf(Lex[ilex],"%lf",&x);
            pushN(x);
            continue;
        }
        
        if (sym == '(')
        {
            pushO(sym);
            continue;
        }
        
        if (sym == ')')
        {
           while(1)
           {
             if (peekO()=='(')
             {
                 popO();
                 break;
             }
               
             a2=popN();
             a1=popN();
             op=popO();
            
             r=exec(a1,a2,op);
             pushN(r);
           }
           continue;
        }
        
        if (ptrs2 == 0) // Первая операция
        {
            pushO(sym);
            continue;
        }
        
        // Не первая операция
        
        p1=prty(sym);      // приоритет пришедшей операции
        p2=prty(peekO());  // приоритет вершины стека операций
        
        if (p1 > p2)       // пришла оп. более высокого приоритета
        {
            pushO(sym);
            continue;
        }
        
        // Выполняем операцию из стека
        
        while(1)
        {
            a2=popN();
            a1=popN();
            op=popO();
            
            r=exec(a1,a2,op);
            
            pushN(r);
            
            p2=prty(peekO());
            
            if (p2 != p1) break;
 
        }
        
        pushO(sym);
        
        continue;        
 
    }
    
    // Выполнение отложенных (оставшихся) операций
    
    while(ptrs2 > 0)
    {
        a2=popN();
        a1=popN();
        op=popO();
            
        r=exec(a1,a2,op);
        pushN(r);
    }
    
    // Освобождаем дин. память
    
    for (int i=0; i<nlex; i++) free(Lex[i]);
    free(Lex);
    free(tmp);
 
    return s1[0];    
    
}
 
 
int main()
{
 
    char *f="-7+8*(3+6)-9*5"; 
    
    double x=calc(f);
    
    if (ErrCode==0)
       printf("x=%lf\n",x);
    else
    {
        printf("Произошла ошибка!");
    }
    
    return 0;
}

char s2[100];  // хранилище операций

// #include <stdio.h>
 
/**
 * @brief
 *
 */
enum class TokenType
{
    /// @brief
    X,
    /// @brief
    CONST_NUMBER,
    /// @brief
    LPAR,
    /// @brief
    RPAR,
    /// @brief
    MINUS,
    /// @brief
    PLUS,
    /// @brief
    MUT,
    /// @brief
    DIV,
    /// @brief
    POW,
    /// @brief
    EOF,
};
 
/**
 * @brief
 *
 */
struct Token
{
    /// @brief
    TokenType type;
    /// @brief
    int value;
};
 
/**
 * @brief
 *
 * @param expr
 * @param tokens Out
 */
void tokenize(const char *expr, Token *tokens)
{
    size_t i = 0;
    size_t it = 0;
    while (true)
    {
        switch (expr[i])
        {
        case '\0':
            return;
        case '(':
            tokens[it].type = TokenType::LPAR;
            i++;
            break;
        //---
        default:
            exit(1);
        }
        it++;
    }
}
 
/**
 * @brief
 *
 * @return int
 */
int main()
{
    const char *expr = "(x-2)*(x-2)*(x-2)-1";
    Token tokens[255];
    tokenize(expr, tokens /*out*/);
}