Ejemplo n.º 1
0
int		evaluate_infix(char **expr, t_list **vs, t_list **os)
{
	int		i;

	i = -1;
	while (expr[++i] != 0)
	{
		if (is_operator(expr[i]) == 0 && expr[i][0] != '(' && expr[i][0] != ')')
			pf(vs, expr[i]);
		else if (is_operator(expr[i]))
		{
			while (ft_list_size(*os) != 0 && g(expr[i]) <= g((*os)->data))
				pf(vs, a(pop(os), ft_atoi(pop(vs)), ft_atoi(pop(vs))));
			pf(os, expr[i]);
		}
		else if (expr[i][0] == '(')
			pf(os, expr[i]);
		else if (expr[i][0] == ')')
		{
			while ((*os)->data[0] != '(')
				pf(vs, a(pop(os), ft_atoi(pop(vs)), ft_atoi(pop(vs))));
			pop(os);
		}
	}
	return (0);
}
Ejemplo n.º 2
0
int		eval_expr(char *str)
{
  int		i;
  char		**tabstring;
  t_list	*op;
  t_list	*nb;
  
  op = 0;
  nb = 0;
  i = 0;
  tabstring = str_to_tab_string(str);
  show_tab_string(tabstring);
  my_putstr("\n");
  while (tabstring[i] != 0)
    {
      if (is_operator(tabstring[i]) == 3)//si '(' on empile le retour de pqrenthesis mode
	my_put_in_list(&nb, parenthesis_mode(&i, tabstring));
      if (is_operator(tabstring[i]) == 0)// si nombre on empile
	my_put_in_list(&nb, tabstring[i]);
      if (is_operator(tabstring[i]) == 1)//si operateur de basse priorite on empile 
	my_put_in_list(&op, tabstring[i]);
      if (is_operator(tabstring[i]) == 2)// si operqteur de priorite on resolv
	resolv(&i, tabstring, &op, &nb);
      i = i + 1;
    }
  return (depile_all(op, nb));
}
Ejemplo n.º 3
0
void				rule_1(t_token *cur_tok, t_list **list, char *input, \
int *index)
{
	char		cur;

	cur = input[*index];
	if (is_operator(cur) && are_complementary(input, *index))
		build_token(cur_tok, cur);
	else
	{
		if (cur_tok->type == WORD)
		{
			build_token(cur_tok, cur);
			return ;
		}
		append_and_reset(list, cur_tok);
		if (is_operator(cur))
			cur_tok->type = OPERATOR;
		discard_whitespace(input, index);
		if (!is_whitespace(cur))
			build_token(cur_tok, cur);
		else
			cur_tok->preceded_by_whitespace = 1;
	}
}
Ejemplo n.º 4
0
void				loop(t_list **list, t_token **cur_tok, char *input)
{
	int			index;
	char		cur;
	char		prev;

	ft_init(&index, &cur, &prev, input);
	while (cur)
	{
		if ((*cur_tok)->token && is_operator(prev) && !is_newline(cur))
			rule_1(*cur_tok, list, input, &index);
		else if (is_quoting(cur))
			handle_quoting(*cur_tok, list, input, &index);
		else if (is_start_of_expansion(cur) || is_operator(cur))
			rule_34(*cur_tok, list, input, &index);
		else if (is_newline(cur) || is_whitespace(cur))
			rule_56(*cur_tok, list, input, &index);
		else if ((*cur_tok)->token && is_word(prev))
			build_token(*cur_tok, cur);
		else if (cur == '#')
			discard_comment(input, &index);
		else
			build_token(*cur_tok, cur);
		prev = cur;
		cur = input[++index];
	}
}
Ejemplo n.º 5
0
void		resolv(int *i, char **tabstring, t_list **op, t_list **nb)
  {
    char	*save;
    int		new_val;
    char	*str;
    my_put_in_list(op, tabstring[*i]);
    *i =*i + 1;
    if  (is_operator(tabstring[*i]) == 0)
      my_put_in_list(nb, tabstring[*i]);
    if (is_operator(tabstring[*i]) == 3) 
      my_put_in_list(nb, parenthesis_mode(i, tabstring));
    //if (is_operator(tabstring[*i]) == 1)
    //{
    //save = malloc(sizeof(*save) * (my_strlen((*nb)->data) + 1));
    //save = (*nb)->data;
    //*i = *i + 1;
    //my_strncat(save,(*nb)->data,my_strlen((*nb)->data));
    // }
    //else 
    //{
	save = malloc(sizeof(*save) * (my_strlen((*nb)->data) + 1));
	save =(*nb)->data;
	//}
    depile(nb);
    if (my_list_size(*(nb)) == 0)
      my_put_in_list(nb, "0");
    new_val = eval(my_getnbr((*nb)->data), *(*op)->data, my_getnbr(save));
    depile(op);
    depile(nb);
    str = malloc(sizeof(*str) * (digit_len(new_val) + 1));
    my_itoa(new_val, str);
    my_put_in_list(nb, str);
    free(save);
  }
Ejemplo n.º 6
0
int		eval_expr(char *str)
{
  int		i;
  char		**tabstring;
  t_list	*op;
  t_list	*nb;
  
  op = 0;
  nb = 0;
  i = 0;
  tabstring = str_to_tab_string(str);
  while (tabstring[i] != 0)
    {
      if (is_operator(tabstring[i]) == 3)
	my_put_in_list(&nb, parenthesis_mode(&i, tabstring));
      if (is_operator(tabstring[i]) == 0)
	my_put_in_list(&nb, tabstring[i]);
      if (is_operator(tabstring[i]) == 1) 
	my_put_in_list(&op, tabstring[i]);
      if (is_operator(tabstring[i]) == 2)
	resolv(&i, tabstring, &op, &nb);
      i = i + 1;
    }
  return (depile_all(op, nb));
}
Ejemplo n.º 7
0
int
expression(void)
{
    int value = 0;
    char op = 0, ch = 0;

    skip_space();
    ch = str[idx];
    if (ch == '\0') {
        return 0;
    }

    if (ch == '(') {
        idx += 1; /* read '(' */
        value = expression();
        skip_space();
        idx += 1; /* read ')' */

        skip_space();
        if (is_operator()) {
            op = operator();
            /*printf("%d|%c ", order++, op);*/
            int v = expression();
            return do_num(op, value, v);
        } else {
            return value;
        }

    } else if (ch == '_' || isdigit(ch)) {
        int num = number();
        /*printf("%d|%d ", order++, num);*/
        skip_space();
        if (is_operator()) {
            op = operator();
            /*printf("%d|%c ", order++, op);*/
            value = expression();
            return do_num(op, num, value);
        } else {
            return num;
        }

    } else {
        char var = variable();
        /*printf("%d|%c ", order++, var);*/
        skip_space();
        if (is_operator()) {
            op = operator();
            /*printf("%d|%c ", order++, op);*/
            value = expression();
            return do_var(op, var, value);
        } else {
            return vars[var - 'A'];
        }
    }
}
Ejemplo n.º 8
0
int Evaluate_Reverse_Polish_Notation(char **str, int len) {
	int top = -1;
	int *stk = new int[len];
	int i;
	int operand_a;
	int operand_b;
	int temp = 0;
	for (i = 0; i < len; i++) {
		if (is_operator(str[i])) {
			operand_b = stk[top--];
			operand_a = stk[top--];
			stk[++top] = comp(operand_a, operand_b, *str[i]);
		}
		else {
			while (isdigit(*str[i])) {
				temp = temp * 10 + (*str[i] - '0');
				str[i] ++;
			}
			//printf("%d\n", top);
			stk[++top] = temp;
			//i--;
			temp = 0;
		}
	}
	temp = stk[top];
	delete stk;
	return temp;
}
Ejemplo n.º 9
0
double calculate_post(queue<string>& post) {
    stack<double> result_stack;
    while(!post.empty()) {
        string temp = post.front();
        post.pop();
        if(is_operator(temp[0])) { //是操作符
            if(result_stack.size()<2) {
                cout<<"表达式错误"<<endl;
                exit(-1);
            }
            //从栈中取出两个元素,计算并将结果压入栈中
            double operand2 = result_stack.top();
            result_stack.pop();
            double operand1 = result_stack.top();
            result_stack.pop();
            
            double m = calculate_two(operand1, operand2, temp);
            result_stack.push(m);
        } else { //操作数
            double temp_operand = atof(temp.c_str());
            result_stack.push(temp_operand);
        }
    }
    return result_stack.top();
}
Ejemplo n.º 10
0
bool infix_is_correct(std::string infix_str){
	int brk_k=0;	
	int opr_k=0;
	for(int i=0;i<infix_str.length();++i){
		if(prior(infix_str[i])==-1){
			 return false;
		}
		
		if(infix_str[i]=='('){
			++brk_k;
		}
		else if(infix_str[i]==')'){
			--brk_k;
		}
		else if(infix_str[i]==' '){
			++opr_k;
		}
		else if(is_operator(prior(infix_str[i]))){
			opr_k-=2;
		}
		
		if(brk_k<0){	
			return false;
		}

	}
	
	return (brk_k==0 && opr_k==1 )?true:false;
}	
Ejemplo n.º 11
0
int evaluate_postfix(const char *expression) {
  assert(expression && "No expression");
  int operand = NOT_SET;
  DynamicArrayStack *stack = dynamic_array_stack_create();
  const char *temp = expression;
  do {
    const char ch = *temp;
    if (is_digit(ch)) {
      operand = max(to_digit_int(ch), operand * BASE + to_digit_int(ch));
    } else if (ch == ' ' || ch == '\0') {
      if (operand != NOT_SET) {
        dynamic_array_stack_push(stack, operand);
        operand = NOT_SET;
      }
    } else {
      assert(is_operator(ch) && "Unsupported character");
      const int operand2 = dynamic_array_stack_top(stack);
      dynamic_array_stack_pop(stack);
      const int operand1 = dynamic_array_stack_top(stack);
      dynamic_array_stack_pop(stack);
      dynamic_array_stack_push(stack, apply(ch, operand1, operand2));
    }
  } while (*(temp++) != '\0');
  assert(operand == NOT_SET && "Operand was not flushed");
  assert(dynamic_array_stack_size(stack) == 1 && "Result must be on stack");
  const int result = dynamic_array_stack_top(stack);
  dynamic_array_stack_destroy(stack);
  return result;
}
Ejemplo n.º 12
0
 // Evaluate Postfix Expression.
 int evaluatePostfixExpression(const vector<string> &postfix) {
     if (postfix.empty()) {
         return 0;
     }
     stack<string> s;
     for (const auto& tok : postfix) {
         if (!is_operator(tok)) {
             s.emplace(tok);
         } else {
             int y = stoi(s.top());
             s.pop();
             int x = stoi(s.top());
             s.pop();
             if (tok[0] == '+') {
                 x += y;
             } else if (tok[0] == '-') {
                 x -= y;
             } else if (tok[0] == '*') {
                 x *= y;
             } else {
                 x /= y;
             }
             s.emplace(to_string(x));
         }
     }
     return stoi(s.top());
 }
Ejemplo n.º 13
0
Archivo: lexer.c Proyecto: Nquere/42sh
int				lexer(char *line, char **env)
{
	char	*op;

	if ((op = is_operator(line)))
		return (exec_op(op, line, env));
	ft_execve(env, line);
	return (0);
}
Ejemplo n.º 14
0
bool iscalcformula (const TCHAR *formula)
{
	for (int i = 0; i < _tcslen (formula); i++) {
		TCHAR c = formula[i];
		if (is_operator (c))
			return true;
	}
	return false;
}
Ejemplo n.º 15
0
 //------------------------------------------------------------------
 void code_colorer::color_code(const char_type* p)
 {
     while(*p)
     {
         unsigned len;
         if(is_block_comment(p, &len))
         {
             m_result.add(keyword_rem, p, len, true);
             p += len;
         }
         else if(is_line_comment(p, &len))
         {
             m_result.add(keyword_rem, p, len, true);
             p += len;
         }
         else if(is_string_literal(p, &len))
         {
             m_result.add(keyword_str, p, len, true);
             p += len;
         }
         else if(is_number(p, &len))
         {
             m_result.add(keyword_num, p, len, true);
             p += len;
         }
         else if(is_operator(p, &len))
         {
             m_result.add(keyword_op, p, len, true);
             p += len;
         }
         else if(is_identifier(p, &len))
         {
             const keyword* kw = 0;
             if     (is_keyword(keyword_kw1_suffix, p, len)) kw = &keyword_kw1;
             else if(is_keyword(keyword_kw2_suffix, p, len)) kw = &keyword_kw2;
             else if(is_keyword(keyword_kw3_suffix, p, len)) kw = &keyword_kw3;
             else if(is_keyword(keyword_kw4_suffix, p, len)) kw = &keyword_kw4;
             if(kw)
             {
                 m_result.add(backslash);
                 m_result.add(kw->name, kw->len);
                 m_result.add(open_brace);
             }
             m_result.add(p, len, true);
             if(kw)
             {
                 m_result.add(close_brace);
             }
             p += len;
         }
         else
         {
             m_result.add(*p++);
         }
     }
 }
Ejemplo n.º 16
0
void Lex_analyzer::addToken(int tokenType, QString tokenValue){
    TokenType *t = new TokenType;
    Token *tok = new Token;
    switch(tokenType){
    case 1:
        if(is_keyword(tokenValue,t)){
            qDebug() <<"Token" <<tokenValue <<"found in keywords: id=" <<t->id  <<"type=" <<t->type <<endl;
            tok->id=t->id;
            tok->tokclass = "keywords";
            tok->toktype = t->type;
            tok->value = tokenValue;
            tokens->append(tok);
        }else if(is_type(tokenValue,t)){
            qDebug() <<"Token" <<tokenValue <<"found in types: id=" <<t->id  <<"type=" <<t->type <<endl;
            tok->id=t->id;
            tok->tokclass = "types";
            tok->toktype = t->type;
            tok->value = tokenValue;
            tokens->append(tok);
        }else{
            is_id(tokenValue, t);
            qDebug() <<"Token" <<tokenValue <<"found in/inserted to ids: id=" <<t->id  <<"type=" <<t->type <<endl;
            tok->id=t->id;
            tok->tokclass = "ids";
            tok->toktype = t->type;
            tok->value = tokenValue;
            tokens->append(tok);
        }
        break;
    case 2:
        is_const(tokenValue, t);
        qDebug() <<"Token" <<tokenValue <<"found in/inserted to constants: id=" <<t->id  <<"type=" <<t->type <<endl;
        tok->id=t->id;
        tok->tokclass = "constants";
        tok->toktype = t->type;
        tok->value = tokenValue;
        tokens->append(tok);
        break;
    case 3:
    case 4:
        if(is_operator(tokenValue, t)){
            qDebug() <<"Token" <<tokenValue <<"found in operators/separators: id=" <<t->id  <<"type=" <<t->type <<endl;
            tok->id=t->id;
            tok->tokclass = "separators";
            tok->toktype = t->type;
            tok->value = tokenValue;
            tokens->append(tok);
        }else{
            qDebug() <<"Error unknown token type: " <<tokenType  <<endl;
        }
        break;
    default:
        qDebug() <<"Error unknown token type: " <<tokenType  <<endl;
    }
    qDebug() <<"Adding token of type[" <<tokenType <<"] = " <<tokenValue  <<endl;
}
Ejemplo n.º 17
0
static void strfilter_node__delete(struct strfilter_node *self)
{
	if (self) {
		if (self->p && !is_operator(*self->p))
			free((char *)self->p);
		strfilter_node__delete(self->l);
		strfilter_node__delete(self->r);
		free(self);
	}
}
Ejemplo n.º 18
0
static void strfilter_node__delete(struct strfilter_node *node)
{
	if (node) {
		if (node->p && !is_operator(*node->p))
			zfree((char **)&node->p);
		strfilter_node__delete(node->l);
		strfilter_node__delete(node->r);
		free(node);
	}
}
Ejemplo n.º 19
0
/* Determine if a command is complex (has an operator like pipe '|') */
int is_complex_command(char **tokens) {
	
	int i = 0;
	while(tokens[i]) {		
		if (is_operator(tokens[i]))
			return 1;
		i++;
	}	
	return 0;
}
Ejemplo n.º 20
0
static const unsigned char*
skip_action( const unsigned char* action) {
    const unsigned char* as;
    unsigned char ac;

    as = action;
    for ( ; ; ) {
        ac = *as++;
        switch (ac) {
        case PT_END:
            return as-1;
        case PT_SEPARATOR:
            return as;

        case PT_PUT_ARG:
        case PT_VAR1:
        case PT_AUX:
        case PT_QUOTE:
            as++;

        case PT_ONE_OPT:
        case PT_LINE:
        case PT_MATCHED_TEXT:
            break;

        case PT_DOMAIN:
#if MAX_DOMAINS < 256
            as = skip_action( as+1 );
#else
            as = skip_action( as+2 );	/* +2 since domains take up 2 bytes */
#endif
            break;
        case PT_OP: {
            int n;
            for ( n = fnnargs[*as++] ; n > 0 ; n-- ) {
                assert ( *as != PT_END );
                as = skip_action(as);
            }
            break;
        }

#ifdef PT_ARG_DELIM
        case PT_ARG_DELIM:
#endif
        case PT_WORD_DELIM:
        case PT_ID_DELIM:
        case PT_SPACE:
        case PT_SKIP_WHITE_SPACE:
            break;
        default:
            assert( !is_operator(ac) );
            break;
        } /* end switch ac */
    } /* end for */
} /* end skip_action */
SymbolListPtr CodeBlock::convert_postfix(SymbolListPtr p) {
	// data structs
	unique_ptr<stack<SymbolPtr>> op_stack = unique_ptr<stack<SymbolPtr>>(new stack<SymbolPtr>);
	SymbolListPtr unpostfix_symbols = SymbolListPtr(new SymbolList());
	
	// shunting yard (modified for unary operators!)
	for (auto i = p->begin(); i !=
		 p->end(); i++) {
		if (is_operand(*i)) {
			unpostfix_symbols->push_back(*i);
			if (!op_stack->empty()) {
				if (is_unary(op_stack->top())) {
					unpostfix_symbols->push_back(op_stack->top());
					op_stack->pop();
				}
			}
		} else if (is_operator(*i)) {
			if (is_unary((*i))) {
				op_stack->push(*i);
			} else {
				while (!op_stack->empty()
					   && !is_lparen(op_stack->top())
					   && compare_ops(*i, op_stack->top()) <= 0) {
					unpostfix_symbols->push_back(op_stack->top());
					op_stack->pop();
				}
				op_stack->push(*i);
			}
		} else if (is_lparen(*i)) {
			op_stack->push(*i);
		} else if (is_rparen(*i)) {
			while (!op_stack->empty()) {
				if (is_lparen(op_stack->top())) {
					op_stack->pop();
					if (!op_stack->empty()) {
						if (is_unary(op_stack->top())) {
							unpostfix_symbols->push_back(op_stack->top());
							op_stack->pop();
						}
					}
					break;
				}
				unpostfix_symbols->push_back(op_stack->top());
				op_stack->pop();
			}
		}
	}
	while(!op_stack->empty()) {
		unpostfix_symbols->push_back(op_stack->top());
		op_stack->pop();
	}
	
	// set the temp symbols as the postfix stuff
	return unpostfix_symbols;
}
Ejemplo n.º 22
0
 // Build expression tree by prefix expression.
 ExpressionTreeNode* buildExpressionTree(vector<string>& prefix, int& start) {
     if (prefix.empty()) {
         return nullptr;
     }
     ExpressionTreeNode *node = new ExpressionTreeNode(prefix[start++]);
     if (is_operator(prefix[start - 1])) {
         node->left = buildExpressionTree(prefix, start);
         node->right = buildExpressionTree(prefix, start);
     }
     return node;
 }
Ejemplo n.º 23
0
void	read_token(t_env *env, char *str, int *i)
{
	while (str[*i] == ' ' || str[*i] == '\t')
		(*i)++;
    if (is_number(str[*i]))
        add_to_queue(env, read_number(str, i));
    else if (is_operator(str[*i]))
		add_operator(env, str, i);
	else
		add_paranthesis(env, str, i);
}
  std::vector<char> ExpressionParser::parse_expression(const std::string& expression) {
    output_.clear();
    for (size_t pos = 0; pos < expression.length(); pos++) {
      if (is_left_paren(expression[pos]))
	process_left_paren();
      else if (is_right_paren(expression[pos]))
	process_right_paren();
      else if (is_operator(expression[pos]))
	process_operator(expression[pos]);
      else
	output_.push_back(expression[pos]);
    }
    while (!token_stack_.empty()) {
      assert(is_operator(token_stack_.top()));
      move_top_token_to_output();
    }
    for (size_t i = 0; i < output_.size(); i++)
      if (output_[i] == EPSILON_INPUT_CHAR)
	output_[i] = (char)EPSILON;
    return output_;
  }
bool CheckTree(creek::tree<std::string> const& _tree)
{
    typedef creek::tree<std::string>::const_pre_order_iterator const_pre_order_iterator;
    const_pre_order_iterator it = _tree.pre_order_begin();
    const_pre_order_iterator end = _tree.pre_order_end();
    
    while(it != end){
        if((creek::child_order_begin(it) != creek::child_order_end(it)) && !is_operator(*it)) return false;
        if((creek::child_order_begin(it) == creek::child_order_end(it)) && !is_number(*it)) return false;
        ++it;
    }
    return true;
}
Ejemplo n.º 26
0
int	get_operator_pos(char *str, int pos, int pre_op)
{
  int	i;

  if (pre_op == 1)
  {
    i = pos - 1;
    while (i > 0 && is_operator(str[i], 0) == 0)
      --i;
    if (str[i] == '-' && i > 0 && is_operator(str[i - 1], 0) == 1)
      --i;
    return (i);
  }
  else
  {
    i = pos + 1;
    if (str[i] == '-' && i != 1)
      ++i;
    while (str[i] != '\0' && is_operator(str[i], 0) == 0)
      ++i;
    return (i);
  }
}
Ejemplo n.º 27
0
static void postfix_infix(const char *postfix)
{
    assert(postfix != 0);
    printf("Postfix expression: %s\n", postfix);
    char c;
    bool valid = true;
    Stack stack;

    stack_init(&stack);
    while ((c = *postfix++) != '\0')
    {
        if (isdigit(c))
            stack_push_chr(&stack, c);
        else if (is_operator(c))
        {
            char *rhs = stack_pop(&stack);
            char *lhs = stack_pop(&stack);
            size_t l_rhs = strlen(rhs);
            size_t l_lhs = strlen(lhs);
            char expr[l_lhs + l_rhs + sizeof("()*()")];
            snprintf(expr, sizeof(expr), "%s%s%s%c%s%s%s",
                    (l_lhs > 1) ? "(" : "", lhs, (l_lhs > 1) ? ")" : "", c,
                    (l_rhs > 1) ? "(" : "", rhs, (l_rhs > 1) ? ")" : "");
            stack_push_str(&stack, expr);
            free(lhs);
            free(rhs);
        }
        else if (isspace(c))
            continue;
        else
        {
            err_remark("Invalid character %c (0x%.2X) found\n", c, c);
            valid = false;
            break;
        }
    }

    if (valid)
    {
        if (stack.tos != 1)
            err_remark("Stack has wrong number of entries (%zu instead of 1)\n", stack.tos);
        else
        {
            char *infix = stack_pop(&stack);
            printf("Infix expression: %s\n", infix);
            free(infix);
        }
    }
    stack_free(&stack);
}
Ejemplo n.º 28
0
int apply(const char operation, const int operand1, const int operand2) {
  assert(is_operator(operation) && "Unsupported operation");
  switch (operation) {
    case '+':
      return operand1 + operand2;
    case '-':
      return operand1 - operand2;
    case '/':
      return operand1 / operand2;
    case '*':
      return operand1 * operand2;
    default:
      assert(false && "Unsupported operation");
  }
}
Ejemplo n.º 29
0
Archivo: expr.c Proyecto: zzt93/myNEMU
/*
  args: {:}
  return value: return the value of expression (now only uint32) if the `e` is valid, or -1
  Usage:
*/
uint32_t expr(char *e, bool *success) {
	if(!make_token(e)) {
		*success = false;
		return 0;
	}
    
    int i = 0;
    for (;i < nr_token; ++i) {
        if (tokens[i].type == MIN &&
            (i == 0 || (i != 0 && is_operator(tokens[i-1].type) ))) {
            tokens[i].type = NEGA;
            puts("in negation");
        } else if (tokens[i].type == MUL &&
            (i == 0 || (i != 0 && is_operator(tokens[i-1].type) ))) {
            tokens[i].type = DEREF;
        }

    }

    su = true;
    uint32_t res = eval(0, nr_token);
    *success = su;
    return res;
}
Ejemplo n.º 30
0
std::vector<std::string>  postfix(std::string infix_str){
	if(!infix_is_correct(infix_str)){
		std::vector<std::string> err;
		err.push_back(infix_str);
		return err;
	}

	std::stack<char> char_stack;
 	std::vector<std::string> result;
	char  clean_number[5];
	int clean_index=0;
	
	for(int i=0;i<infix_str.size() ;++i){
		int q=prior(infix_str[i]);
	
		if(is_number(q)){
			clean_number[clean_index++]=infix_str[i];
		}
		else if(is_space(q) && clean_index>0){

			clean_number[clean_index]='\0';
			result.push_back(clean_number);
			clean_index=0;
		}
		else if(is_operator(q)){
			
			while(!char_stack.empty() && prior(char_stack.top())>q){
				save(char_stack,result);
			}
			char_stack.push(infix_str[i]);
		}
		else if(is_brk_open(q)){
			char_stack.push(infix_str[i]);
		}else if(is_brk_close(q)){
			while( char_stack.top()!='('){
				save(char_stack,result);
			}	
			char_stack.pop();		
		}

	}
	
	while(!char_stack.empty()){
		save(char_stack,result);
	}

	return result;
}